#swiftlint

[himanshu123]

Reducing iOS App Size Without Sacrificing Functionality 

As user expectations grow and storage constraints persist—especially on older devices—iOS mobile application development teams are under increasing pressure to build lightweight yet fully functional apps. With limited storage on iPhones and iPads, users are more likely to delete apps that consume too much space or hesitate to download large ones in the first place. 

Reducing your iOS app's size isn't just a technical optimization—it's a competitive advantage. But how can developers trim down an app without compromising its core features or user experience? In this post, we’ll dive into proven strategies and tools to help developers minimize app size while still delivering a powerful product. 

Why App Size Matters More Than Ever 

App size plays a critical role in user acquisition and retention. According to industry data, apps larger than 200 MB are often skipped due to limited mobile data plans or slow download speeds. On the Apple App Store, apps over 200 MB cannot be downloaded over cellular data without Wi-Fi—an important restriction for on-the-go users. 

Moreover, as more functionalities are added, app size can quickly balloon out of control. Developers need smart strategies to strike the right balance between functionality and file size. 

1. Optimize Image Assets 

One of the first and most effective ways to reduce app size is by optimizing image assets. Use vector graphics (like PDFs or SVGs) instead of raster images when possible. Also, implement image compression tools such as: 

ImageOptim 

TinyPNG 

JPEGmini 

Additionally, consider using asset catalogs and slicing techniques like @2x, @3x only where necessary to reduce redundant high-resolution files for unsupported devices. 

2. Use App Thinning 

Apple’s App Thinning technology—comprising Slicing, Bitcode, and On-Demand Resources—is a game-changer in reducing the actual size of the app installed on a device. 

Slicing: Creates device-specific app variants. 

Bitcode: Uploads intermediate representation, allowing Apple to re-optimize the app binary. 

On-Demand Resources: Lets you tag resources to be downloaded only when needed, reducing initial download size. 

Using these techniques can significantly decrease the amount of data users need to install and run your app. 

3. Remove Unused Code and Libraries 

Over time, codebases accumulate unused methods, classes, and third-party libraries. These not only increase app size but also potentially introduce security vulnerabilities. 

Tools like Xcode’s static analyzer, SwiftLint, and AppCode help identify dead code. Additionally, selectively importing third-party SDKs rather than bloating your project with full libraries can make a substantial difference. 

4. Modularize Your Codebase 

Dividing your code into smaller, reusable modules makes it easier to isolate what’s essential during the initial install. Non-essential modules—such as less frequently used features or premium content—can be downloaded later through Apple’s On-Demand Resources or custom logic. 

This is a smart approach for apps with multiple functions like e-learning platforms, where some users might only use a fraction of the available content. 

5. Analyze Before You Build 

Using tools like Xcode’s size report and App Store Connect analytics, developers can identify which components contribute most to app size. Once you’ve visualized your app’s weight distribution, you can better target optimizations. 

This leads to smarter budgeting and planning. If you’re still in the early stages, a mobile app cost calculator can help estimate how your design decisions (including those affecting size) will impact the overall development cost. 

Want expert help streamlining your app without losing its core features? Book an Appointment with our iOS specialists today. 

6. Compress and Optimize Audio/Video 

Media files can eat up storage faster than any other asset. Use efficient formats like HEVC (H.265) for video and AAC for audio. Additionally, stream or download larger media files only when required instead of bundling them into the initial app install. 

Apps that rely on heavy media—like workout videos or meditation guides—can adopt a hybrid strategy by loading lighter versions initially and allowing the user to download HD content later. 

7. Reevaluate Fonts and Icons 

Many developers overlook fonts and icons as a source of unnecessary bulk. Use system fonts where possible instead of bundling custom fonts. If you must use custom typography, include only the characters you need, particularly if your app supports multiple languages. 

Similarly, switch from icon sets to icon fonts or vector graphics to reduce redundancy and improve scaling across devices. 

8. Keep Your Build Settings Clean 

Regularly cleaning up your build settings and configurations in Xcode can prevent unnecessary files from sneaking into your final product. Also, avoid embedding debugging tools, test frameworks, or logging modules in production builds. 

Use build flags to ensure that development-only features are stripped from release versions. This not only saves space but also improves security and performance. 

Final Thoughts: Less Can Be More 

Reducing iOS app size while maintaining functionality is a nuanced process that blends strategy with smart tooling. It’s not about cutting corners—it’s about refining your app to focus on what truly matters to your users. 

Smaller apps load faster, install quicker, and often provide a smoother user experience. By leveraging Apple’s App Thinning, optimizing assets, and trimming unnecessary code, you can ensure that your app is lean without being lacking. 

Whether you’re building a new app or refining an existing one, adopting these practices can significantly improve usability and accessibility—key factors in a competitive App Store market. 

If you're looking for expert guidance on building optimized, user-friendly apps, explore our Custom iOS App Development Services. We’re here to help you create impactful, scalable applications that never compromise on performance. 

[appdevelopmentgurgaon]

QicApp’s Proven Approach to Delivering Clean, Reliable Code

At QicApp, we believe that code quality isn’t just a technical metric—it’s the very foundation of a successful digital product. As a trusted iOS-app-development-company-in-Gurgaon, we know that high-quality code directly impacts performance, scalability, security, and long-term maintainability. Our goal is never just to deliver working solutions—we aim to build clean, efficient, and future-proof codebases that clients can rely on for years to come.

Whether it's a mobile app for a fast-growing startup or a complex backend system for a large enterprise, we follow rigorous development practices to ensure our code is robust, adaptable, and maintainable. Here’s how we maintain top-tier quality across all our projects:

Structured Architecture With MVVM

At QicApp, we adopt the MVVM (Model-View-ViewModel) design pattern in both our iOS and Android projects. This architectural approach separates UI logic, data management, and business rules, leading to cleaner and more testable codebases. This structure not only enhances code clarity but also improves scalability and facilitates faster feature rollouts with fewer bugs.

Continuous Performance Profiling

User experience is everything, and performance plays a huge role. Our team regularly uses tools like Instruments for iOS and Android Profiler to detect and fix issues like memory leaks, thread blocks, and UI slowdowns. By identifying bottlenecks early, we ensure our apps deliver smooth performance, even in demanding environments.

Enforced Coding Standards With Linters

Code consistency drives collaboration. We use linters like SwiftLint (iOS), Ktlint/Detekt (Android), and ESLint/Prettier (web/backend) to enforce coding standards. Paired with CI pipeline checks and pre-commit hooks, this ensures that all developers follow best practices and deliver clean, readable code every time.

Peer Code Reviews for Every Feature

Every new feature goes through a peer review before it’s merged. These sessions aren’t just about catching bugs—they foster team-wide accountability, spark ideas for improvements, and ensure our solutions stay aligned with architectural, performance, and security standards.

Security by Design: JWT & AES

As an iOS-app-development-company-in-Gurgaon, security is baked into everything we do. We use JWT (JSON Web Tokens) for secure API communication and AES encryption for sensitive data storage. Our secure development lifecycle includes HTTPS enforcement, input validation, endpoint protection, and adherence to best coding practices.

Clear Documentation and Transparent Workflows

We prioritize documentation at every level—from code and APIs to Git workflows and setup guides. Well-documented projects reduce onboarding time, improve developer productivity, and give our clients full visibility into the development process.

Automated Testing & CI/CD Integration

We champion frequent, reliable deployments. Our teams integrate automated testing (unit and integration) and CI/CD pipelines to validate code quality, catch issues early, and ensure smooth, continuous delivery. This automation helps us push stable updates faster while minimizing bugs in production.

Code Quality: A Culture, Not a Task

At QicApp, code quality is more than a checklist—it’s embedded into our culture. From MVVM architecture and secure-by-design coding to peer reviews and test automation, every aspect of our workflow is designed to deliver products that are stable, scalable, and secure.

If you're looking for an iOS-app-development-company-in-Gurgaon that’s committed to long-term product excellence, QicApp is your trusted partner.

[qualitytesting]

SwiftLint Configuration Example

For those wondering about some of the less-obvious parts of a SwiftLint configuration file, here's an example file which hopefully spreads some light on how to configure some of the more complex rules.

excluded Rules

The excluded section of the configuration file expects a list of paths to exclude from linting. Paths are relative to the directory from which SwiftLint was called, so make sure that you include paths relative to the location of the file that invokes SwiftLint. For example:

When running from the command line, the excluded paths need to be relative to the location you run the command from.

When using Danger, the excluded paths need to be relative to the location of the Danger file which invokes SwiftLint, e.g. Danger_postclone.

For a file structure like this:

MyProject |-- .swiftlint.yml # SwiftLint configuration file |-- Danger | |-- Danger_postclone # invokes SwiftLint |-- Libraries | |-- SomeLibrary | | |-- SomeLibraryClass.swift | | |-- SomeLibraryProtocol.swift | |-- SomeOtherLibrary | | |-- SomeOtherLibraryClass.swift | | |-- SomeOtherLibraryProtocol.swift |-- MyCode |-- MyClass.swift |-- MyProtocol.swift

Use the following configuration to enable exclusion of any files under Libraries when using Danger:

# .swiftlint.yml excluded: - ../Libraries

Or this configuration when using the command line from the MyProject directory:

# .swiftlint.yml excluded: - Libraries

Adjusting Severity Levels

Run $ swiftlint rules to get a table with all of the rule identifiers you might want to use in your configuration file.

To work out how to adjust rule configurations, look under the configuration column.

Simple Rules

If the contents of the column just says "warning" or "error", the only thing that can be adjusted for that rule is the severity. The adjustment syntax for this kind of adjustment is:

{rule_identifier}: {desired_severity}

For example, to downgrade the closing_brace rule to a warning instead of an error:

# .swiftlint.yml closing_brace: warning

Or to upgrade the class_delegate_protocol to an error instead of a warning:

# .swiftlint.yml class_delegate_protocol: error

Complex Rules

Some rules have more attributes that can be configured than just the severity. The names of these attributes will be specified in the rules table.

If you are trying to configure complex rules incorrectly, you may be getting a warning when running $ swiftlint rules like:

Invalid configuration for 'statement_position'. Falling back to default.

Complex rules do not accept the same configuration syntax as simple rules.

This is what the rules table says for the colon rule:

| colon | warning, flexible_right_spacing: false, apply_to_dictionaries: true |

In this case, you can override the severity and the attributes like this:

# .swiftlint.yml colon: severity: error flexible_right_spacing: true apply_to_dictionaries: false

If you only want to override the severity on these complex rules, you still need to use the severity: syntax - you can't just do colon: error as with simple rules.

Other rules can be more complex, like nesting:

| nesting | (type_level) w: 1, (statement_level) w: 5 |

For the nesting rule, you can configure the severity levels of type-nesting and statement-nesting separately, and you can also define what level of nesting triggers a warning and what level of nesting triggers an error.

The default configuration shows that a warning will be triggered by 1 level of type-nesting and at 5 levels of statement-nesting, and there are no levels of nesting which will trigger an error.

You can change this configuration to (for example) trigger type-nesting warnings at 2 levels of nesting, errors at 3 levels, and statement-nesting warnings at 3 levels of nesting, errors at 5 levels.

# .swiftlint.yml nesting: type_level: warning: 2 error: 3 statement_level: warning: 3 error: 5

[yudizblog]

Overview

Early in this month of June was WWDC 2022. After a huge update in iOS 16, Now, let’s talk about the some technical updates about the SWIFT 5.7.

Topics

Swift Playgrounds

Swift Packages Update

Plugins

Performance Improvements

Concurrency

Async Algorithms

Regex Builder

Updates in Swift 5.7

Swift Playgrounds

Swift playground allows users to create applications directly from Swift playground and submit it to the App-Store.

Swift Packages update

Trust on First User (TOFU)

New security protocol where the fingerprint of a package is now being recorded when the package is first downloaded.

Report an error if the fingerprint is mismatched.

Plugins

Command Plugins

Build tool Plugins

Providing more secure build tools and extensible

Used for documentation generation, source code re-formatting, etc

Tool Ex: SwiftLint 12345678910import Foundationimport PackagePlugin //Creating a struct that conforms to CommandPlugin protocol.@mainstruct GenerateMyPlugin: CommandPlugin {    func performCommand(context: PluginContext, arguments: [String]) throws {    //init code     }}

Can implement additional build steps

Ex: Source Code Generation, Resource processing

Original Source : What’s new in swift? | WWDC 2022

[webzian]

Webzian offers complete Mobile development for their customers. we are best in providing both Consumer-oriented needs as well enterprise digital needs. we are compatible in providing ideal mobile development solutions and post-delivery technical support. Webzian includes some services in their mobile app development portfolio:• Custom iOS and Android apps development• REST API, Third-party API Integration• Cross-platform iOS and Android Apps- React Native, Flutter, Ionic & Xamarin.• Native iOS and Android Apps ��� Swift, Objective-C, SwiftUI, CocoaPods, SwiftLint• UI/UX design.• Ideation and prototyping.• Embedded Android & AOSP customizations.• Role management, Notification management, and Geo-fencing

[ios-goodies]

Week 240

Happy Thursday! It was a quiet vacation week among my colleagues, at least, so I decided it's the perfect time to add SwiftLint to our biggest project. SwiftLint is a great tool, a mature and solid project, and I totally recommend it. However, adding it to a project that was started more than 2 years ago can take a bit of time 😅.

Even though it's the middle of the summer, there was again a lot of new content. Our iOS community never ceases to surprise me coming up with new and quality materials. I'm happy to be a part of it ☺️.

Articles

Building a camera calculator with Vision and Tesseract OCR in iOS, by @onmyway133 via Heartbeart

Updating Strings For Swift 4.2, by @kharrison

Custom Types for Powerful Matching, by @jemmons

Writing Cleaner View Code in Swift By Overriding loadView(), by @rockthebruno

Better iOS projects: Getting (nearly) rid of Xcodeproject, by @wlborg

Design Patterns in Swift #1: Factory Method and Singleton, by @iosbrain

Tools/Controls

Best 12 tools to create amazing screenshots for your mobile apps (2018), by @ott_max via AppManager

TypingIndicator - A replica of iMessage's typing indicator bubble with support for a variety of animations, by @nathantannar4

Business/Career

State of Mobile App Quality 2018: What We Learned From Analyzing 100 Million Bugs, by @instabug

Now I see you, now I don’t, by @S_Lindemann

Imaginary problems, the root of bad software, by @Cerebralab2

Library Rules: How to make an open office plan work, by @jasonfried

UI/UX

What Can Bike Sharing Apps Teach Us About Mobile On-boarding Design?, by @lukew

Stop letting the data decide, by @NielsHoven

Rounded or Sharp-Corner Buttons? - Trivial Design Decisions That Actually Matter, by @taimekoe

Videos

Designing For Augmented Reality, by @flarup

Credits

onmyway133, ajandrade, rbarbosa

[manzanitas]

A tweet

SwiftLint in Use https://t.co/zYRd7YRoGX

— iOS Developers (@ios__developers) December 10, 2019

[openwebsolutions]

Top 10 Open Source Swift Libraries that help to make a Project Better

New Post has been published on http://blog.openwebsolutions.in/open-source-swift-libraries-help-project-better/

Top 10 Open Source Swift Libraries that help to make a Project Better

There are more than 6000 third party libraries in swift but here I will discuss those which are really helpful in your project. We compare other as GitHub rating or star but believe me I do not judge these by rating rather I look at how they improve a project. Someone tell a line “Third Party Make Coding Life Easier”. I also follow this rule. So, Let’s move on to those libraries.

IQKeyboardManagerSwift:  This library is super awesome. This is a keyboard manager tool for textfield in your project. You just write one line of code and they just fully managed the textfield delegate method.                                                                                                                                                                                   

SCAlertView: This help to modify your alert view. This will give a beautiful look in your project.                                                              

SkeletonView: It also comes with awesome features when your tableView or collectionView is busy with fetching data on that time this animation show and user understand that our view is in loading mode.                                                                                                                                                                                      

SwiftLint: This is a tool to enforce Swift style and conventions. It will beautify your coding style.                                            

ARKit-CoreLocation: This awesome tool provides us to map out the local world as you move around with uses camera and motion data. This Tell us real location with a camera.                                                                                                                                                                                                                                         

NotificationBanner:  NotificationBanner is an extremely customizable and lightweight library that makes the task of displaying in app notification banners and drop down alerts an absolute breeze in iOS.                                                                                                                                                                                                       

Hero:  This is a library for building iOS view controller transitions. It provides a declarative layer on top of the UIKit’s cumbersome transition APIs—making custom transitions an easy task for developers.                                                                                                                                                                            

ViewAnimator: This is a library for building complex iOS UIView animations in an easy way. It provides one line animations for any view included the ones which contain other views like UITableView and UICollectionView with its cells or UIStackView with its arrangedSubviews.                                                         

SwipeCellKit :  This library helps you to add some functionality when the user swipes any cell they can perform some action smoothly with beautiful animation.                                                                                                                     

SwiftKotlin: We all know that the current Android version is in high demand. Kotlin is used to make android apps. If swift code converts to Kotlin then this is a smooth way to build an android app. This tool helps to do converting easily. Check it out one time.                                                                                                                                Happy Programming

[thecodepro-blog]

iOS Swiftlint Tutorial

Swiftlint makes it easy to write good and clean Swift code and catches bad practices along the way.

[myrtlecornish]

Producing a CircleCI Test Summary with Fastlane

The heart of Continuous Integration is running tests. Whenever a test fails, you want to know why ASAP so you can correct it. Whenever a CI build fails, you want to see that failing test and how it failed.

CircleCI’s Test Summary feature puts this info front-and-center so you can respond directly to the test failure without anything getting in your way. The trick is to feed CircleCI your test info the way it expects.

Why set up Test Summary when you already have a build log?

The build log might be fine to start. You expand the failing step, scroll to the end of the page, and then scroll up till you hit the test failure.

This is not too bad. At first.

But with a big enough project, the build and test logs grow too long to view in-place on the web page. Then you find yourself downloading the log file first.

Sometimes the failing test isn’t really that near the end of the file. Then you’re fumbling around trying to find it.

Across a lot of developers on a long project, this time and friction adds up.

Don’t CircleCI’s docs cover this already?

If you’re building an iOS app, and you copy-paste the Example Configuration for Using Fastlane on CircleCI, you should luck into something that works.

But you’ll want to better understand what the Test Summary feature is looking for if:

Your Test Summary omits info you want in there, like linter output.

Test Summary isn’t working for you, and you want to fix it.

You’re not building an iOS app using Fastlane, and one of the other example configs doesn’t meet your needs.

What does CircleCI need for a Test Summary?

CircleCI’s Collecting Test Metadata doc calls out one big thing:

Report tests using JUnit’s XML format.

The store_test_results step reference calls out another:

Your test report should be in a subdirectory of another “all the tests” directory.

This subdirectory name is used to identify the test suite.

There’s one more requirement that I haven’t seen documented anywhere, though:

The JUnit XML test report file must literally have the xml extension.

The rest of the filename doesn’t seem matter for the test summary, but if you have the wrong path extension, you won’t see any test summary.

What does that look like on disk?

You’ll wind up with a directory layout like:

/Users/distiller/project/ └── fastlane └── test_output └── xctest └── junit.xml 3 directories, 1 file

This ticks all the boxes:

XML file: junit.xml

“Test Suite” directory: xctest

“All Test Suites” directory: test_output

(Fastlane only produces a single test report, so the nesting of report-in-folder-in-folder admittedly looks a little silly.)

How do you get Fastlane Scan to write JUnit XML to that path?

Scan provides a lot of config knobs. You can view a table of the full list and their default values by running fastlane action scan.

We need to arrange three things:

The report format: JUnit

The report filename: junit.xml

The directory that report file should be written to: fastlane/test_output/xctest

Conveniently enough, Scan has three config settings, one for each of those needs.

Scan also happens to have three different ways to set those three options:

In your Fastfile:

Using keyword arguments to scan()

In your shell:

Using option flags

Anywhere (but probably in your shell):

Using environment variables

Keyword Arguments to scan()

In your Fastfile, you can set them using keyword arguments to the scan method call:

scan( # … other arguments … output_types: 'junit', output_files: 'junit.xml', output_directory: './fastlane/test_output/xctest')

Option Flags to fastlane scan

If you’re invoking fastlane directly, you can set them using CLI options:

fastlane scan \ --output_directory="./fastlane/test_output/xctest" \ --output_types="junit" \ --output_files="junit.xml"

Environment Variables

Because Ruby is a true descendant of Perl, TMTOWTDI, so you could also configure Scan using environment variables:

env \ SCAN_OUTPUT_DIRECTORY=./fastlane/test_output/xctest \ SCAN_OUTPUT_TYPES=junit \ SCAN_OUTPUT_FILES=junit.xml \ fastlane scan

(You could also set those environment variables in the environment stanza in your CircleCI config. Six one way, half-dozen the other.)

How do you get CircleCI to process the JUnit XML?

Now you have Fastlane Scan writing its test report using the JUnit format into a *.xml file under a suggestively-named subdirectory.

To get CircleCI to actually process this carefully arranged data, you’ll need tell the store_test_results step to snarf everything at and under fastlane/test_output.

That’s right: not just the xctest subdirectory that holds the test report XML, but the directory.

Add this step to the pipeline that runs scan:

- store_test_results: path: "./fastlane/test_output"

What about the rest of Scan’s output?

At some point, you’ll probably want to be able to look at the test report yourself, as well as the overall build logs.

You can send both of those on up to CircleCI as build artifacts using a couple store_artifacts steps:

- store_artifacts: path: "./fastlane/test_output" destination: scan-test-output - store_artifacts: path: ~/Library/Logs/scan destination: scan-logs

What about more than just Scan?

You’re not limited to just one artifact or just one test output. In fact, handling multiple kinds of test output is precisely why there’s the folder-in-folder nesting.

Say you wanted to have CircleCI call out SwiftLint nits. You could drop this snippet into your jobs list:

lint: docker: - image: dantoml/swiftlint:latest steps: - checkout - run: name: Run SwiftLint command: | mkdir -p ./test_output/swiftlint swiftlint lint --strict --reporter junit | tee ./test_output/swiftlint/junit.xml - store_test_results: path: "./test_output" - store_artifacts: path: "./test_output"

The key links in the chain here are:

Create an “ALL the tests” directory: ./test_output/

Create a “test suite” directory: ./test_output/swiftlint/

Write JUnit output into a .xml file: ./test_output/swiftlint/junit.xml

Aim store_test_results at that “ALL the tests” directory: path: "./test_output/"

Any output you can massage into meeting those requirements, you can cadge CircleCI into calling out in your Test Summary.

Conclusion

There you have it:

Quickly debug CI build failures

By putting relevant test details in prime real estate

By feeding a folder two steps up from a carefully located, precisely named test report file

To CircleCI’s store_test_results build step.

Producing a CircleCI Test Summary with Fastlane published first on https://johnellrod.weebly.com/

[iyarpage]

Large Mobile Dev Teams and The Android Avalanche – Podcast S07 E13

In our season 7 finale, Dru and Janie bring back Capital One’s Louie de la Rosa to talk about working with large mobile development teams and then Razeware’s Joe Howard opens up the gates on the Android Avalanche.

[Subscribe in iTunes] [RSS Feed]

This episode is sponsored by The Android Avalanche.

Interested in sponsoring a podcast episode? We sell ads via Syndicate Ads, check it out!

Episode Links

Large Mobile Development Teams

Capital One

Two Pizza Team

Fastlane

Agile

GitHub Enterpise

SwiftLint

Semantic Versioning

Dogfooding

Your Show of Shows

Herding Cats

Haiku

π Pi Day

The Android Avalanche

Razeware

Android Apprentice

Kotlin Apprentice

Android Studio

Eclipse

Rest API

MVVM Episode

Android Architecture Components

TRS-80

RWDevCon

Contact Us

Janie Clayton on Twitter

Dru Freeman on Twitter

Luis de la Rosa on Twitter

Joe Howard on Twitter

Email the Podcast Team

Where To Go From Here?

We hope you enjoyed this episode of our podcast. Be sure to subscribe in iTunes to get notified when the next episode comes out.

We’d love to hear what you think about the podcast, and any suggestions on what you’d like to hear in future episodes. Feel free to drop a comment here, or email us anytime at podcast@raywenderlich.com.

The post Large Mobile Dev Teams and The Android Avalanche – Podcast S07 E13 appeared first on Ray Wenderlich.

Large Mobile Dev Teams and The Android Avalanche – Podcast S07 E13 published first on https://medium.com/@koresol

[shashikant86]

Top 5 Tips for Integrating SwiftLint into iOS CI/CD Pipelines

Swift is getting popular programming language for developing iOS apps these days. Being a type safe language, it’s important to

The post Top 5 Tips for Integrating SwiftLint into iOS CI/CD Pipelines appeared first on XCBlog.

via XCBlog http://ift.tt/2wqmUFu

[ios-goodies]

Week 181

Major apps abandoning Apple Watch, including Google Maps, Amazon & eBay 🤔

Articles

Preserves Superview Layout Margins, by @kharrison

SwiftLint doing its best to ease conflict, by @wibosco

Deep Dive Into iOS Automation At Grab - Continuous Delivery, by @xiangxinsun

Avoiding Massive View Controllers by refactoring, by @roch4brun

Tools/Controls

TestDrive, by @johnsundell

Toolbar, by @1amageek

XcodeColorSense2, by @onmyway133

Business

How to make Apple Search Ads work for your App, by @DenZhadanov

Creating iMessage Apps Your Users Will Love, by @weareprolific

Basecamp's handbook, by @basecamp

UI/UX

Redesign Checkout Process of Lazada Mobile App, by @soundCreativ

Modal & Nonmodal Dialogs: When (& When Not) to Use Them, by @TBFessenden

Credits

LisaDziuba, naeemshaikh90, onmyway133, rbarbosa, prolificinteractive, yangshun, tevelee

[ios-goodies]

Week 165

Chris Lattner went to tesla

Articles

Testing iOS Apps, by @merowing_

Accessing Dictionaries with Key Paths, by @olebegemann

Creating a Compelling Today Widget, by @steviki

Bring Magic To Your Mobile App With Deep Learning

Control what you're sharing, by @ricardopereiraw

Tools/Controls

GDPerformanceView-Swift, by Gavrilov Daniil

Sharaku, by Makoto Mori

SwiftyCam, by Andrew Walz

Business

On Getting Old(er) in Tech, by @denoncourt

All of 2016’s top mobile apps are owned by either Google or Facebook, by @ossia

UI/UX

A Smart Way to Manage Colour Schemes for iOS Application Development, by @sauvik_dolui

The Best Design Articles of 2016, by @toptal

Useless UI, by @graiz

Videos

"Watch Your Language!": The Road to Cleaner Code with SwiftLint, by @simjp

Credits

naeemshaikh90, manuelescrig, mariusc, SandroEMachado, ricardopereira, rbarbosa

[manzanitas]

Favorite tweets

SwiftLint in Use https://t.co/zYRd7YRoGX

— iOS Developers (@ios__developers) December 10, 2019

from http://twitter.com/ios__developers via IFTTT