How to create code snippets in Xcode: Easy way to create your own snippets for auto-completion in Xcode.
The 7 roles of a CTO: Some takeaways from a CTO discussing the CTO role with other CTOs.
The 8 Jobs of Management: Motivator/Expert/Mentor/Sponsor/Shield/Process designer/Gaol setter/Recruiter.
How to build and scale a Staff+ engineering community: Stripe’s strategy to successfully onboard Staff+ Engineers.
Why Most Strategies Lack Clarity: We confuse clarity/coherence and certainty.
Three-Part Solution To Leaders’ Burnout: Teach them. Delegate to a capable team. Handle the toughest cases.
Planning for Project Deadlines so You Can Sleep at Night: The first step is to create a plan. Make a spreadsheet and outline the to-do list of every task needed to complete the project. With a plan in place, it’s up to you to ensure the team gets to the finish line.
As a Leader, You Own Your Communications Bubble: The answer is never to micromanage a team if the communications are breaking down or they are not performing. Rather, you need to take a long hard look at the bubble you created and make sure that it has enough insulation for perspective and enough permeability for success.
Learning starts with desire: No new knowledge can enter an unwilling student.
What Distinguishes Great Software Engineers?: This study brings an interesting perspective to this conversation by shining a light on what developers themselves view as distinguishing someone as a great engineer.
What Makes Developers Unhappy?: Developer satisfaction is important for productivity because reduced satisfaction can incur future costs; it follows that companies should be interested in the general well-being of their software developers.
Good Interviewer/Bad Interviewer: Thoughts on the big difference between being a good and a bad interviewer: Good interviewers know they are contributing to a hiring decision. Bad interviewers believe they are making a hiring decision.
How to lead a coding interview: Tips for leading a coding interview that creates a great candidate experience and gathers enough signals to make informed decisions.
Most People Won’t: Most people won’t. Which means those that do change everything.
CULTIVATING HOSPITALITY: Treat every new hire like they've been there the whole time.
Remote first, Async second: Explain the difference between maker’s and manager’s schedules.
Death to Dependencies: Dependencies are a creation of our structure. If we build silos and divisions between teams that do the work, there will be dependencies. The more isolated our teams are, the less coordinated they become. The more that planning is its own silo, the more people doing the work will lack the details they need to do a professional job.
80/20 is half-ass when the value is logistic: 80/20 thinking is half-ass when it’s an excuse to be lazy. But used thoughtfully, 80/20 is a valuable decision-making heuristic for situations with power laws and diminishing marginal returns.
Being Swamped is Normal and Not Impressive: Being swamped means probably not getting enough rest, making things more complicated than they need to be, wasting time on petty decisions, and not thinking deeply about important decisions.
Getting Big Things Done: Notes on how to organize big things in order to complete them.
Slack and the Imaginary Economy: In post-industrial work, concentration is the main input unit. Creative work takes time, but more time does not necessarily equal a more valuable output. The best ideas come up when smart people are allowed to focus — on their own or with a small group.
Better/Sooner/Cheaper/More: Interesting ideas demystifying old-school thinking about software development.
The Truth Curve and the Build Curve: The key lesson is that we always need to be looking at our actions with a certain amount of skepticism even as we drive forward with action. Is this experiment worth running? Is this feature worth building? Is this startup idea worth years of my life?
RxSwift to Combine: A complete guide for migrating a RxSwift codebase to Combine.
Mobile App Refactoring Initiative by Slack: Some thoughts on the 3 Slack articles about stabilizing, modularizing, and modernizing their mobile apps.
iOS at Scale @Artsy: Are you opening code only for your benefit, or are you doing it for the sake of everyone?
Async/Await, Combine, Closures: The era of completion handlers is over for good, the future is bright. Reactive programming and async/await both let you write cleaner, less error-prone code (when applied correctly) and provide more features. Choosing between them is up to personal preference, the need for certain operators, and the specific problem at hand.
One year ago I launched an iOS dev blog. I'm glad that I did: Thoughts a year later.
Implementing Password AutoFill for an iOS application: Easy way to add a nice feature to the password fields.
Introducing MarkCodable: Interesting project that converts Codable objects to Markdown tables.
Side Projects: 10 Tips for being successful: Great tips to avoid procrastinating on side projects.
Improve numbers readability with underscores: In Swift, Numeric literals can contain extra formatting that won't affect the underlying value of the literal.
Five Tips for Swift Package Plugin Development: Exactly what the title says.
The Modern way to Scan Texts, QR Codes, and Barcodes in Swift: How to scan texts and machine codes for your users.
Advances in Swift Package Manager's dependency access control: Explains the advances in transitive dependencies with SPM.
A Micro Auto Layout DSL: Simple AutoLayout mechanism but it’s lacking functionality.
Probably the best guide to Swift Timer: Agree with the title.
Swift 5.7 Released: Release notes for Swift 5.7.
Published properties in Swift: The @Published property wrapper is one of the core aspects in Combine when it comes to UI development specifically — as it lets us easily set up reactive data bindings between our models and our UI.
@Published risks and usage explained with code examples: You can use the @Published property wrapper to observe property changes inside any class. Any new values will be published from the willSet method meaning that we won’t get the latest value when accessed directly.
Property Wrappers in Swift explained with code examples: Property wrappers are a great way to remove boilerplate in your code. Plus a great UserDefaults example.
Lock screen widgets in SwiftUI: Easy guide to implement widgets.
Efficiently Develop Cleaner SwiftUI Views Using A View Model: Shows how to break down a SwiftUI View into smaller components sharing the same view model.
@StateObject vs. @ObservedObject: The differences explained: @StateObject and @ObservedObject have similar characteristics but differ in how SwiftUI manages their lifecycle. Use the state object property wrapper to ensure consistent results when the current view creates the observed object.
New in SwiftUI 4: Expanding Textfield.
New in SwiftUI 4: Gauge View, represent values within a range.
New in SwiftUI 4: Share Sheet with Share Link.
New in SwiftUI 4: Grid view to create table like designs.
Dynamic dates with monospaced digits in SwiftUI: Quick way to display relative dates in SwiftUI.
Introducing XCTUnimplemented: Define XCTest assertion helpers directly in your application and library code.
Verifying VoiceOver: Accessibility Inspector.
How To Notify Users About App Updates: Small chunk of code to check if a new version of your app is available.
Accessible text: library to make it easier to support accessible text in UIKit.
Modify a value during iOS debugging in Xcode: Using expression in the console to modify the value.
The View Debugger in Xcode: The View Debugger is a valuable tool to figure out bugs and problems in the user interfaces of your apps. Even if there is no problem, you can us it to get insight into how the view hierarchy is constructed.
Keeping master green at scale: Paper written by Uber on how to scale backend services.
Use release trains for increased speed and efficiency: Key takeaways and best practices shared by product managers and engineers using the mobile release train approach to help you improve and optimize your release cycles and make more informed decisions about your app releases.
A Pragmatic Approach to Cross-Platform: How a company built their core libraries using C++.
Uber Engineering: Building an Intelligent Experimentation Platform.
Spotify’s New Experimentation Platform: Moving from plain feature flags to backend-driven UIs for experiments.
IOS Developer Roadmap: A nice roadmap artwork for people entering the iOS development world.
Third-party libraries are no party at all: Lyft’s take on adding third-party libraries to their apps.
It’s All A/Bout Testing: The Netflix Experimentation Platform: Really detailed explanation on how Netflix approaches A/B testing.
Twitter experimentation: Technical overview.
Using Feature Flags to Enable Nearly Continuous Deployment for Mobile Apps: Another post explaining how to use feature flags for production apps.
The Hidden Costs of Your Dependencies: If you don’t limit the number of your dependencies, you may end up getting consumed by them and all of the costs associated with bringing them in.
Why Developers Are Building So Many Side Projects: Whether it’s the desire to create, learn, or get rich, it all comes down to a fundamental change happening with how developers view their projects. You used to put side projects on a CV to land a career in tech. Now, side projects can be your career in tech.
Scaling Mobile development: Some generic high-level ideas with some personal opinions on how to scale for mobile development.
Thoughtful Dependency Adoption: We should be thinking about how we bring in our dependencies and take steps to protect ourselves from them.
Engineering Principles: at Artsy.
Duplication: Duplication exists when there’s a single behavior that’s specified in two or more places.
Share Swift Code Between Client App and Vapor Server: Ways to use SPM to share code between a Swift App and a Vapor Server.
John Lewis IT Software Engineering Principles: Some great engineering principles based on the Accelerate book.
What is Continuous Delivery: the ability to get changes of all types—including new features, configuration changes, bug fixes and experiments—into production, or into the hands of users, safely and quickly in a sustainable way.