Mobile System Design: Tactical Engineering

This book is being written. Preorders are not yet available!
To receive updates, please follow me here.

Mobile System Design is an upcoming book made for mobile engineers of any level that helps you become a better developer.

This book offers ways of thinking which enable you to deliver features faster, with fewer bugs, while keeping the ability to easily change (or even delete) parts of it. We will walk a fine line between taming complex abstractions, keeping everything as simple as possible, and being able to deliver and update code quickly.

Ultimately, app development work is focused on delivering code and features, and that is the main driving force in this book.

In this book we assume you are already an app developer. But perhaps you still struggle with over-engineered code at your work, or you need to make code reusable, but you might have trouble finding the right abstractions.

Maybe you've seen coworkers struggle to decouple code from UI, or it could be that they're not sure which patterns to select. Perhaps you occasionally face difficulty explaining why it's better to test at certain locations versus testing, or not testing, at others.

This book will help you define which techniques you can more effectively apply at various stages of the development process.

We'll cover mental models and considerations in depth for an entire feature-development process; From receiving a design and aligning with coworkers, to delivering a multi-domain application with various abstraction layers, testing considerations, UI flows, and pitfalls at every stage.

Book Cover

Table of Contents (subject to small changes)

• Intro
• Turning a briefing into a strong plan
• Holistic-Driven development; Turning a plan into code
• Testing methodologies in the mobile environment
• Reasoning about UI
• Taming abstractions while keeping complexity low
• Creating flows
• Sane dependency injection without fancy frameworks
• Applying the methodologies to your own apps

How this book works

Even though you may have already made a bazillion features in your career, this book aims to teach you new tips and tricks at every step.

The book will help you go over the process from beginning to end. But instead of explaining "how to make a viewmodel", it offers different and fresh considerations at each step of the development process that aren't easily found elsewhere, based on real-world experience.

For example, we will receive UI designs to make a feature. But instead of 'just making views and a network call', we will cover in the book how to get more out of the screens, how we can renegotiate what's important to make first, and how to align better with a designer and backend developer.

Then further in the book we will start implementing certain components. During this process we often have to think about abstractions. We have to keep code simple, yet reusable. But it's a dangerous path and can lead to overengineering.
But how do we know if we're overengineering or not? It's perhaps easy to say at the end if something is over-engineered, but will we know so during the process? The book will go in-depth about this and offer different solutions to these problems.

After some implementations we cover a lot more considerations, such as rethinking the role of testing in a mobile context. Because even though testing warrants its own books, there are a few important things left unsaid that apply really well in a mobile-development world. Instead of a "this is how you test, just add a few protocols or interfaces", this book will instead focus on what to test, and why adding protocols can actually be harmful for your release process.

In the end you will have delivered a feature consisting of a variety of components across various domains (data, UI, subdomains), and they might all use different abstractions. The feature will be kept as simple as possible, not be over-engineered, yet reusable and ready for scaling up if so desired.

A strong focus on keeping it simple

The book has a heavy focus on keeping it simple. It will show you how in a real-world setting you can get a way with a lot of regular, vanilla, code that developers of all levels can understand.

For instance, the book will demonstrate how to handle Dependency Injection on a large scope, without using fancy tricks or frameworks.

About the Author

Tjeerd in 't Veen is the author of Swift in Depth, published by Manning.

He is currently a staff engineer at Twitter, former iOS tech lead at ING, and has a background in product development inside startups, agencies, and enterprises.

FAQ

When will this book be available?

This book is being written and will be available in 2023. Please follow me here to receive updates.

What is System Design, is it UI related?

System Design is about technical design. It's about coming up with all the bits and pieces necessary to make a system work, or an app in this case. This book will cover the technical design of various components across multiple abstractions and domains.

Is there UI in this book?

The book does cover how to connect glue code to UI, from both a declarative-UI as a imperative-UI perspective.
The book also covers design systems which is a UI focused-library. But it's not a UI book otherwise. It's about how you can take any feature, and make it work with your custom UI components, but the book won't show you how to make your UI components.

Is this book focusing on interviews or building an app?

It is meant to help you with either. In this book we'll go over the processes of turning ideas and UI into a robust app. Along the way you'll learn mental models that you can apply to your own application and interviews.

This book is not a template to common approaches however. The books' aim is to give you tools so you can solve any problem, not pre-rehearsed problems.

Is this book for Android or iOS engineers?

Both! The book uses iOS and Swift as a vehicle to explain concepts and best practices. But it's not a code-heavy book. With some Kotlin knowledge you'll be able to understand the Swift code examples.

The book explains specific Swift keywords where necessary.

Is this an ebook or printed book?
This product is an ebook. Offered in both EPUB and PDF formats.

Is this a programming book?

Sort of but not really. We will go over the process of developing for a mobile application. However, it's not a "code book". We will use Swift to show concepts and how to implement something. But we won't make a complete app from scratch.

We will use code as a vehicle to explain ways of thinking and how to get things done. But this book is more about mental models and avoiding pitfalls. It's about making better choices at every step of the process. From a requirement to a full-fledged, tested, implementation.

What does the subtitle "Tactical engineering" entail ?

Developing a mobile application has a wide range of topics, from building a small view to maintaining a giant modularized application using a variety of tooling. The term "system design" can encompess even more, from continuous integration, integration tests, to shared code solutions such as hybrid, a Rust core layer, or Kotlin Multiplatform.

With Tactical Engineering we refer to a very common, yet local, process in an app codebase, which is 'getting requirements and having to deliver a sort of feature and various components'.

The book focuses on what we do the most as app developers. Whether we join a new team to build a feature, or when working on new (or updating older) features at your current work.

If I already make apps, is this book for me?

Absolutely. In this book we'll assume you're already a developer working on app(s). It will offer relevant information for developers of all levels, ranging from SWE I to Staff level.

I have never even made an app, is this book for me?

The book is aimed at people that have at least some experience in the app-development world. Having said that, if you've never made an app before, this book will show you what the process entails.