Advanced Swift: Deeply technical book covering a lot of topics of the Swift programming language.
Atomic Habits: Amazing framework to start thinking about daily habits and how they can influence your life.
The Hard Thing About Hard Things
On Building a Fluid User Interface: Great article on how instagram built their own UI systems.
How to Design Better Checkbox, Radio and Toggle Buttons?: Basic and important points of UX.
Intro to the 8-Point Grid System: Great basic guide for creating consistent spacing on a design system.
How the 60-30-10 rule saved the day: 60% is your dominant hue, 30% is secondary color and 10% is for accent color.
The Curse of Knowledge Bias: Is a cognitive bias that occurs when an individual, communicating with other individuals, unknowingly assumes that the others have the background to understand.
We Don’t Need More Designers Who Can Code: If you empower your team to focus on their strengths as well as do some work to gain empathy for their teammates, then you don’t need Swiss Army knives. Instead, you have a toolbox full of experts that now work better together.
How to become a UX Designer: 5 tips to new joiners in the UX world.
The 3 design principles for creating flow: Superhuman principles for creating flow in apps.
How to design for iOS 15. Everything you need to know from Apple’s WWDC21: Focus mode and privacy are the main things to consider on iOS 15.
How Apple’s super-secret Industrial Design team really works
UX analysis: Apple Music vs. Spotify’s artist page: Fun to read UX analysis.
10 lessons learned over 20 years of working in UX design: Key lessons to take into account in UX design.
Git unfuck-it-up: Simple explanation on two powerful commands: reflog and bisect.
On Writing a Great Pull Request: Excellent article with tips to create efficient PRs.
Understanding Rebase (And Merge) in Git: Easy explanation on how rebase works.
Pull Request Checklist for iOS Developers: Really nice checklist to read before sending new PRs.
Creating Basic GitHub Actions For Testing Xcode: Quick guide to add a basic Unit test run github action to a Swift project.
Test and deploy an iOS App with GitHub Actions: Using Github Actions to test and deploy an iOS app. Really well step-by-step explanation.
Mastering Github Actions for iOS: Introducing some cool ideas to get the most out of github actions for iOS.
Why your huge tech team isn’t delivering: Interesting to share with management people, cool ideas that could be worth exploring.
One-on-one catchups with your team: Amazing article to help running 1:1s.
The Various Ways of Combining iOS and Android Development Together: Good breakdown of the current alternatives to Native development.
Unusual tips to keep Slack from becoming a nightmare: Really helpful Slack tips for growing companies.
This 90-Day Plan Turns Engineers into Remarkable Managers: Amazing article, with a go/no-go 90 day plan to try the individual contributor to manager transition.
A MANAGER’S BILL OF RESPONSIBILITIES (AND RIGHTS): Concise bullet points on Manager's responsabilities and rights.
Why it’s difficult to build teams in high growth organisations: Good breakdown on possible scenarios for hyper-growth teams.
An incomplete list of skills senior engineers need, beyond coding: Great bullet points of senior engineers' skills.
My Leadership Document — 2021 Edition: Great read, some good points about leading tech teams.
Encourage Teams To Take Risks: Two big points to focus on while leading engineering teams.
Finding Collective Ownership of the Codebase: Team ownership spreads around knowledge, context, and ability to change the code. Software engineering is a social activity, not an individual activity. Enabling that social element is key.
Failed #SquadGoals: Spotify doesn’t use “the Spotify model” and neither should you.
The Limits of Optimization: Fun article to read describing how Baseball has evolved due to data-driven events over time.
A Manager’s Guide to Holding Your Team Accountable: Concrete guide with example questions on how to provide feedback and hold your team accountable.
Better coordination, or better software?: Don’t unify tracking tools. Don’t make coordination smoother. Make delivery smoother! by strengthening boundaries.
Rituals for hypergrowth: An inside look at how YouTube scaled: Historical article on how Youtube scaled between 2008 and 2014. It has deeper articles to continue reading.
The Problem with Prioritization Frameworks: Explains two main problems with prioritization frameworks:
- Prioritization frameworks outcomes are somewhat arbitrary.
- Prioritization frameworks solve the wrong problem.
The 25 Micro-Habits of High-Impact Managers: Amazing article detailing a lot of tips on how great managers do their work.
I trust you, make the callmight be the six most powerful words you can hear from a supervisor.- Think of yourself as the team captain, not the head coach.
- The best managers "ask" more than they "tell".
- “Share a story where you've failed personally or professionally and what you learned as a result. It sheds light that we're all human and on the same level. It allows team members to share their concerns and feel like it's okay to fail”. This can also be done with funny stories instead.
- Setting up specific 1:1 monthly meetings with each team member, where the report reflects on the three things that went well the past month, and three things they’d like to go differently in the next month. Then share your own 3x3. Then finish with asking: What are you most hopeful about as you think about the next month?
- Resist the urge to multitask. You must be present on your meetings. “The best managers I've worked with always make the time to talk to you, no matter how busy they are. They realize that five or 10 minutes invested immediately not only addresses the topic in question, but it also shows the employee that their needs are a priority”.
- The best managers are incredibly consistent — they’re almost always on time, follow-up, and close the loop on open items. The diligence and consistency seem straightforward but are rare in a leader.
- Don't forget the humans behind the company's goals.
- “Early on, my manager told me,
I don't want you to mess up. But if you mess up, I will have your back.This instilled in me that my manager trusted my decisions, was willing to help me through potential failure, and subtly applied pressure to live up to that trust. He said it once, but it was impactful enough that I still think about it when I face a new decision in my role”. - A great manager praises in public and reprimands in private.
- Look for opportunities to praise in the moment.
- Great managers do small things to help their teams have fun and take the work seriously while not taking themselves too seriously.
- Each individual person’s strengths are superpowers that lead to an all-star team. Find moments to recognize specific ways that each person’s superpower shines and encourage team practices around sharing gratitude for each other.
- Celebrate moments outside of the office, too. “My manager has twice now sent me a thoughtful gift out of the blue — once over the holidays and once when my son was born. Neither was work-related, but it was a wonderful reminder that he cared enough to remember the important occasions in our lives and it brought us closer together”.
- The best leaders understand that great folks will move on from your team or your company for different opportunities — and take key steps to bring those hazy, long-term goals into clearer focus.
- Great managers openly recognize this role is just one stop on your journey and are clear about wanting to help you figure out and get to what's next.
- “Awesome managers are active rather than passive in pursuit of their reports' well-being. They go beyond asking,
How are things going?and ask what the best and worst aspects of the job are. They normalize and make space for change so that no one feels stuck or boxed in”. - “One of the best pieces of advice I've gotten from a manager is about
periodically sharpening the arrows in your quiver.This means checking in on the craft skills that make folks in your role exceptional and considering how they might grow, whether internally or through external training”.
The Indispensable Document for the Modern Manager: Amazing article showing a manager's guide to work with him. Will be really interesting for anyone to write his own guide. "To grow the company and as a leader, every manager at a startup needs to scale herself. At the end of the day, writing a user guide is an exercise in self-awareness. What teams want from their leaders more than anything else is predictability and authenticity. This leads to trust. With trust, you can be unstoppable."
Warning: This Is Not Your Grandfather’s Talent Planning: Explains how to build and maintain great teams, also details the differences of the players on your team and how to work with each one of them.
How to Work Hard: There are three ingredients in great work: natural ability, practice, and effort. You can do pretty well with just two, but to do the best work you need all three: you need great natural ability and to have practiced a lot and to be trying very hard.
Are Pull Requests Holding Back Your Team?: Hot take on the PR process and their drawbacks for commercial teams.
How to Give Positive Feedback to Colleagues – with Examples!: Explains how to give positive feedback using the SBIR framework.
- Situation: State the specific situation where you observed the behavior.
- Behavior: Explain the precise behavior you saw.
- Impact: Describe the exact impact the person’s actions had on you.
- Request: State the explicit request you would like to make of the person.
Leadership Philosophies: Empowering the Internal Team: thougths and ideas on how to manage teams.
Guiding critical projects without micromanaging: Forcing every team into a single process, whether it’s classic Agile-type two week sprints or Scrum or whatever is optimizing for uniformity of process at the likely expense of the needs of the teams themselves. Being outcomes-driven (is the work getting done, with good quality, in reasonable time, without burning out the people involved) is the only way I know how to work.
Shipping fast and safe: Building a culture of low-risk learning: Intercom's take on how to ship fast, really interesting points and a few valuable tips.
The Art of Not Taking Things Personally: Helping people to label their situations and giving them the space to be seen and heard can reduce the intensity of the negative emotions that led to their behaviours in the first place. When it comes to emotional reactions, listening might just be the best medicine.
How to Influence Without Authority: Simply put, we can say that influencing without authority is the ability to make others act, behave, or think without having any power or right over them. The article explains the Atlassian's way of encouraging people to influence without authority.
Good People, Big Dreams: How Lemonade decided to hire junior people and train them.
What Makes a Great Leader?: An introduction to the Adult Development Theory, and how it applies to leadership in tech.
Want To Build An Incredible Product? Strive For The Delta Of “Wow”: Good article on how to stop thinking about MVPs (Minimum Viable Products) and start thinking abot MLPs (Minimum Lovable Products).
Five rules for building products: Nice set of rules to keep in mind. And to know when to break them.
🎨 To get extraordinary results, you need to break some rules. In the words of Pablo Picasso: “Learn the rules like a pro, so you can break them like an artist.”Doing things that matter: Really interesting take on the trade-offs between working on small easy things vs large impactful things on a day to day basis.
Secrets to be at the top of my game: Similar takes to mine's on how to be productive at work.
💡 Make it work first then make it nice. Those are two different problems and trying to solve both at the same time is setting up for failure.No code reviews by default: A really particular take on not having code reviews to improve development speed.
A Reasonably Detailed Guide to Optimizing Your iPhone for Productivity, Focus and Your Own Health: An amazing guide, full of tips and tricks to improve your productivity with the iPhone.
BLUF: The Military Standard That Can Make Your Writing More Powerful: BLUF stands for Bottom Line - Up Front, it’s designed to enforce speed and clarity in reports and emails. Put the most important details first. Investing time to make your communication as clear and efficient as possible is important because founders and C-suite executives are extremely busy people. In some ways, the trick to writing good content is assuming your own readers are equally as busy.
How to stop procrastinating by using the Fogg Behavior Model: Behavior = Motivation + Ability + Trigger. The key is that we need to have all three at the same time in order to act.
Build up your motivation by reinforcing personal, meaningful reasons to do something.
Break down complex tasks into simple parts and plan them through time by creating a simple timeline.
And define a concrete trigger that will help you start your work.
How to find your zone of genius: Great exercise to make the most out of your time at work (Takes some time to see results).
The SPACE of Developer Productivity: Productivity is about more than the individual or the engineering systems; it cannot be measured by a single metric or activity data alone; and it isn't something that only managers care about. This article explains a Framework for understanding developer productivity called SPACE.
20 Reasons To Quit Social Media: Really powerful points to start thinking about how we consume social media.
HackerNews: Social news website focusing on computer science and entrepreneurship.
Beat the bystander effect with minimal social pressure: Useful tips for remote decision taking in large groups.
The Most Precious Resource is Agency: Learning is naturally the consequence of doing.
Taming the Mammoth: Why You Should Stop Caring What Other People Think: Must read article, it clarifies the thought process of people and how it hasn't changed that much over the last 50,000 years.
THE IMPORTANCE OF DEEP WORK & THE 30-HOUR METHOD FOR LEARNING A NEW SKILL: The Law of Productivity: High-Quality Work Produced = (Time Spent) x (Intensity of Focus). When performance psychologists began to explore what separates experts, in many different fields, from everyone else, the single coherent answer was: deliberate practice.
How to Start a Startup: 20 lesson videos from successful start-up creators.
Why you feel uncertain about everything you make: Getting others’ opinion can be valuable, until it’s not. So we must choose carefully when and how we get it. And realize that ultimately, our own opinion is what makes our work original.
Life Is Pain: Really interesting thoughts on how life can be seen nowadays. "Discipline and hard work are the only things that will help feel good in your own skin.".
The greatest resume I've ever seen: Inspiring story on how to get your first job in the cloud business.
Every engineer should do a stint in consulting: While consulting is stressful and has weird incentives, it’s also a shortcut to getting very senior, very fast.
MVC Architectural Pattern in Android – Part 1: Google's approach to MVC for android development.
App Development Complete Roadmap -2021: Tips for Android beginners.
Introduction Video: Amazing tutorial on the basis to start making apps with flutter.
Generating Flutter app icons automatically: Lib for automatically generating app icons for iOS and Android.
Top 30 Flutter Tips and Tricks: 7 minutes video with 30 great tips for building apps with Flutter.
Top anime shows Flutter app: Creating a basic flutter app that fetches information from the internet and display it in a table.
What gives Flutter the edge over its other alternatives?: You have a good performance, you have a lot of power, a lot of things you can configure, you have full control over how you want to build your user interface.
Top 10 Trending Flutter Packages In 2021: 10 useful and liked by many users libs for Flutter apps.
How iOS 15 will improve accessibility: New features and API’s in iOS 15 that will improve accessibility on iPhone.
iOS Custom Accessibility Actions: Nice VoiceOver trick.
How to set up iOS environments: develop, staging, and production: Amazing article to set up environments/schemas.
How to better structure your Xcode projects: Demystify the structure of Xcode projects and gives you a few ideas for how to better optimize your own apps.
How to implement MVVM pattern with Swift in iOS: Basic guide on how to implement one of the most common design patterns for builiding iOS apps.
Responsible code sharing using the power of protocol extensions: Great post explaining why using protocols is better than adding functionality via extensions.
Protocol-Oriented Programming Tutorial: Basic tutorial to get started with Protocol-oriented-Programming.
Implementing Feature Flagging in iOS: Basic article about feature flags with interesting ideas on how to use them for having more confidence in the production app.
VIPER-Architecture for iOS: Good article explaining the VIPER architecture, however the code used is messy and form retain cycles.
View: The responsibility of the view is to send the user actions to the presenter and shows whatever the presenter tells it.
Interactor: This is the backbone of an application as it contains the business logic.
Presenter: Its responsibility is to get the data from the interactor on user actions and after getting data from the interactor, it sends it to the view to show it. It also asks the router/wireframe for navigation.
Entity: It contains basic model objects used by the Interactor.
Router: It has all navigation logic for describing which screens are to be shown when. It is normally written as a wireframe.
SOLID: Is a mnemonic acronym for five design principles intended to make software designs more understandable, flexible, and maintainable.
Single-responsibility principle: States that every module, class or function in a computer program should have responsibility over a single part of that program's functionality, and it should encapsulate that part.
Open–closed principle States "software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification"; that is, such an entity can allow its behaviour to be extended without modifying its source code.
Liskov substitution principle: States that, in a computer program, if S is a subtype of T, then objects of type T may be replaced with objects of type S (i.e., an object of type T may be substituted with any object of a subtype S) without altering any of the desirable properties of the program (correctness, task performed, etc.)
Interface segregation principle: States that no client should be forced to depend on methods it does not use. ISP splits interfaces that are very large into smaller and more specific ones so that clients will only have to know about the methods that are of interest to them. Such shrunken interfaces are also called role interfaces. ISP is intended to keep a system decoupled and thus easier to refactor, change, and redeploy.
Dependency inversion principle: States:
- High-level modules should not depend on low-level modules. Both should depend on abstractions (e.g., interfaces).
- Abstractions should not depend on details. Details (concrete implementations) should depend on abstractions.
Adapter Pattern: Is a software design pattern that allows the interface of an existing class to be used as another interface. It is often used to make existing classes work with others without modifying their source code. An adapter allows two incompatible interfaces to work together. This is the real-world definition for an adapter. Interfaces may be incompatible, but the inner functionality should suit the need.
Chain of Responsibility Pattern in Swift: Implementing a Chain of Responsibility using protocols in Swift.
The sane way to choose the architectural pattern for your iOS app: Explains the differences between MVC/MVVM/VIPER and the reasoning behind choosing one.
iOS: using App Store Connect API with fastlane: Great guide to automate AppStoreConnect uploads bypassing the 2FA.
OSLog and Unified logging as recommended by Apple: Interesting, OSLog looks pretty similar to the way we are using the Logger. I don’t think we will need to use it for the time being, but could be a good mini-refactor to add this functionality into the Logger.
Make Debugger Console Output Stand Out: Great tip for making the console output stand out.
A few useful lldb tricks: Some cool commands for lldb, like e for expression.
sort-xcodeproj: Script to sort Xcode project files and groups alphabetically.
Snapshot testing: Actively maintained snapshot framework in Swift.
MondrianLayout: AutoLayout framework for declarative UI (Simil to SwiftUI).
SwiftTips: Amazing Swift tips and tricks.
Kintsugi: Resolve Git conflicts that occur in Xcode project files.
Start emulator and simulator from macOS terminal: NPM package to open mobile simulators
Attabench: Benchmarking framework for Swift in where you can set up the code you'd like to measure, accompanied by a GUI app.
ViewAnimator: A library for building complex iOS UIView animations in an easy way.
Most Important iOS Libraries in 2021: A good summary of the most used libs for iOS development.
URLSession: Common pitfalls with background download & upload tasks: Interesting article about download and upload with URLSession in the background.
JSON Parsing in Swift explained with code examples: Really great article on how parsing JSONs works in Swift.
Async / Await in Swift: Easy to follow with a lot of examples on differences between async/await and the old closures.
Modern Concurrency in Swift: Introduction: Introduction to a series of articles explaining async/await APIs.
Understanding async/await in Swift: Great article to start diving into the new async/await features on Swift 5.5.
Converting closure-based code into async/await in Swift: This article explores how to bridge from callback-based code or delegate-based code into async/await using checked continuations.
Structured Concurrency in Swift: Using async let: The introduction of async let for concurrent execution explained. It also talk about the Task tree and how cooperative cancellation works.
Structured Concurrency With Group Tasks in Swift: Task groups allow us to execute dynamic concurrency, such as when needing to download a variable amount of images from a loop.
Introduction to Unstructured Concurrency in Swift: This is useful when we want to have more control over the tasks. Being able to cancel tasks when deemed necessary can help improve the experience of our users, specially if very long-running tasks are involved.
Unstructured Concurrency With Detached Tasks in Swift: detachedAsync is not too hard to understand once you understand Task {}. They behave almost the same way. The main difference is Task.detached will not inherit anything from the parent context. You can cancel both manually. They are great to run related by non-dependant tasks at a given time.
GraphQL + iOS introduction: Introduction video to perform basic GraphQL queries in a SwiftUI project.
Testing URLSession with Swift: A series of 3 articles. The first one talks about how to mock URLSession and URLSessionDataTask by using protocol-oriented-programming. The second ones explains how to make asynchronous code testable in a synchronous way. And the last one explains how to stub network responses in the UI tests.
Inspecting HTTP Traffic With Instruments: Not really useful in the state it's right now, since the UI is not intuitive and it only works when running on a real device.
Stacksift: New crash reporting service: Still in the very early stages, the proposal is interesting, will have to see how it evolves.
Strategies For Asking Users to Rate Your App: Really good do's and don'ts for asking users to rate apps. Apple will only show you the prompt a maximum of 3 times per year to a given user, so be careful on when to call it.
Record iOS Simulator video as mp4 and GIF with Xcode: From Xcode 12.5, we can record the simulator using Command⌘+R.
How to build better command line apps and tools using Swift?: Tips on how to build CLI tools using Swift.
12 hours of Apple material to learn iOS development: Apple free material for getting started with UIKit and SwiftUI.
Linting vs Formatting: A Swift Guide: A guide describing how to set up SwiftLint + SwiftFormat + Running checks on CI using Danger.
Designing for Productivity in a Large-Scale iOS Application: Nice article describing some of the techniques that AirBnb used to keep development productivity high on a really large iOS app.
Fileprivate vs private in Swift: The differences explained: Great and short explanation on the topic.
What's new in Swift 5.5?: Amazing article on all the new things that are coming to Swift.
Higher-Order Functions in Swift: Easy explanations on the most common high order functions work in Swift.
Variadic Functions in Swift: Interesting take on how to reduce the repeated code using variadic functions.
Weak Self vs Unkown Self: Easy to follow explanation on a complex topic.
Introduction To Swift Memory Layout: Great semi-deep explanation on the differences between Reference Types and Value Types in Swift.
Avoiding problematic cases when using Swift enums: Great for designing features using enums.
A trick to keep the Struct's Default Memberwise initializer in Swift: Quick trick to have multiple inits for structs.
5 Complex Algorithms Simplified Using Swift’s Higher-Order Functions: By using the higher-order functions, we can highly reduce the complexity of our code, thus making it less error-prone. Most importantly, it makes our code much easier to maintain.
Unwrap or throw: Exploring solutions in Swift: Pretty smart solution to throw when finding a nil value using a custom operator: ?!.
typealias: What is it and how to use it: Type alias allows us to “define” custom types that are based on already existing types. We don’t really define the types, but name a new type that aliases another type. This way we can use the methods provided by the referenced type, without re-writing code or using boilerplate.
How to use throwing properties to catch failures in Swift: Throwing properties in Swift is a great tool for catching unhappy flows without defining methods for simple accessors. We can apply the same technique for custom subscripts, allowing most of our code to be throwable. Being careful to pick between throwing properties and methods makes sure our code is predictable as possible.
CS193p - Stanford iOS development course: Full iOS course on how to create SwiftUI application. Lesson teached at Standford university that gets updated once every year.
Face ID and Touch ID in Swift: Examples of how to use the LocalAuthentication API.
Swift's Documentation Markup: Really cool usages of Markup in Swift comments.
Simplifying iOS UI Testing with Page Object Model: Excellent article on how to implement the PageObject pattern for UI tests on iOS.
Measure scrolling performance on UI Tests: Quick method that fails if the scrolling performance isn't good enough.
Unit testing: the pragmatic guide on where to start: Good guide to start unit testing legacy apps.
Observing in XCTests using XCTestObservation: XCTests Observation provides a very easy way to handle Test Listeners the same as other Testing Framework. However, you need to add your own logic to generate report and logs which are more suitable for you.
Detecting memory leaks via tests: A unit-test base class to detect memory leaks.
Resolver + DI: Learn how to use Resolver to implement dependency injection in your Swift apps to achieve easily readable and maintainable codebases.
Dependency Injection in Swift using latest Swift features: Nice guide on setting up basic DI without third party dependencies.
Behavior-Driven Development (BDD) in iOS using Swift: Implementing BDD using Quick and Nimble frameworks.
Xcode Test Plans: Useful guide explaining how to use Test Plans in your Xcode project.
Unit Testing in Swift: Very basic guide on how to add unit tests to your app. Only useful for test beginners.
Unit Testing View Controllers and Views in Swift: View controllers and views can and should be unit tested. This contributes to the app quality a lot since view controllers make up a large part of the codebase.
Unit Testing Best Practices on iOS with Swift: A handful of good practices for writting unit tests (useful for any language).
How to Test Private Variables in Swift: Clever usage of Mirror to get read-access to private properties in the tests.
Prefer functions to protocols: A different take on making things testable by using function inits instead of protocols.
Warning macro: Macro to trigger warnings in Xcode projects.
Improving Your App's Performance: Apple's take on how to make apps more reliable.
How to handle keyboard behavior in iOS apps: Great small class to handle keyboard behavior across all the app.
Building Better iOS App Animations: Good article explaining animations using UIViewInteractors.
Taking UIKit’s new button configuration API for a spin: Great article on the new changes introduced to UIButton.
Table and Collection View Cells Reload Improvements in iOS 15: The reconfigureItems(_:) method is just one of the many improvements Apple made on diffable data source.
Towards a Design System in iOS: Colors: They overenginnered a solution to port colors from Figma to Xcode.
iOS 15: Notable UIKit Additions: Custom size presentation sheets, CLLocationButton, UIKeyboardLayoutGuide, UIToolTipInteraction, and ImageDecoding.
Creating Slick Color Palette APIs: Easy to follow guide to add support for multiple color palettes.
WWDC Notes: Shared notes from developers on WWDC videos.
The iOS Developer’s guide to WWDC 2021: Really cool guide to read before WWDC.
Make blazing fast lists and collection views
Seven Xcode Tricks Every Developer Should Know: Pretty standard tricks, good video for junior developers.
Xcode Keyboard Shortcuts: All Keyboard shortcuts.
Xcode Column Breakpoints: New addition of Xcode 13, column breakpoints.
Rerun without building: Control + Command + R.
What Everyone in Tech Should Know About Teaching and Learning: 40 minute YouTube talk; raises topics relevant to onboarding new team members and potentially to designing UI flows that help clients learn about crypto/our products (Reducing cognitive load, for example).
How necessary are the programming fundamentals?: Really great article covering why the FAANGs use their interview process, and how important are programming fundamentals.
Semantic Versioning 2.0.0: Explanation behind the most used versioning system.
On Coding, Ego and Attention: Great article to read once in a while about ego.
How I got to 200 productive hours a month: Great article on productivity, talkind about the Environment, the Body, and the Mind.
Refactor or Rewrite? Tackling Legacy Apps: Nice article on refactors vs rewrites.
On Code Review: Good points for reviewers and submitters to make the PR process more smooth.
Writing pull requests your coworkers might enjoy reading: I find that discussing changes ahead of time, keeping them small, and connecting the dots for your readers is worthwhile. Going the extra mile to help people reviewing your pull requests will result in faster turnaround, more focused feedback, and happier teammates.
Heuristics for Effective Software Development: A continuously evolving list: 26 bullet points about effective software development.
Simple Systems Have Less Downtime: By relying on simple over complex systems, a couple of good things happen. 1) Proficiency takes less time. 2) Troubleshooting takes less time. 3) There are more alternative solutions.
The complexity unlearning curve: Making something simple and maintainable is actually harder than adding complexity. There’s underappreciated skill in making simple things.
Rethinking Best Practices: The article explains why the term "best practice" might have been largely missused in the last couple of years. "The trouble associated with a phrase like best practice is that we’ve become so enamored with assuming there’s a “one true way” that it can leave little room for flexibility."
The Persistent Gravity of Cross Platform: Some digging into the trade-offs of going cross-platform in big products (think Slack of Figma) and why it's not as simple as only considering Cheap vs Pollished UX.
The Builder’s High: Consume or create? Concise but powerful article that makes you think about daily decisions.
Writing Effective Software Development Notes for Future You: Interesting approach for coding, writing down everything you do while you do it. Can provide a lot of context in the future.
5 Things a Developer Should Do Apart From Coding: Exercising frequently, creating a comfortable working environment, eating nutritious foods, engaging in new hobbies, and socializing.
20 Things I’ve Learned in my 20 Years as a Software Engineer: Good tips from a really experienced guy.
Should every if statement has an else clause: Good reasoning about what to put in the else statements.
Programming Paradigms for Dummies: What Every Programmer Should Know