This book is for both dedicated novices and experienced programmers.

“Novice” because you don’t need prior programming knowledge, but “dedicated” because we’re giving you just enough to figure it out on your own. When you’re finished, you’ll have a solid foundation in programming and in Kotlin.

If you’re an experienced programmer, you can skip forward to Summary 1 and Summary 2, then proceed from there.

The “Atomic” part of the book title refers to atoms as the smallest indivisible units. In this book, we try to introduce only one concept per chapter, so the chapters cannot be further subdivided—thus we call them atoms.


All programming languages consist of features that you apply to produce results. Kotlin is powerful: not only does it have a rich set of features, but you can usually express those features in numerous ways. The combination of these features and the ways to express them can, if everything is dumped on you too quickly, give you the impression that Kotlin is “too complicated.”

It doesn’t have to be.

If you know the features, you can look at Kotlin code and work out the meaning. Indeed, it’s usually easier to understand a single page of Kotlin than it is to understand many pages of equivalent code in another language.

Because you can get overwhelmed, we teach you the language carefully and deliberately, using the following principles:

  1. Baby steps and small wins. We cast off the tyranny of the chapter. Instead, we present each small step as an atomic concept or simply atom, which looks like a tiny chapter. A typical atom contains one or more small, runnable pieces of code and the output it produces. We try to present only one new concept per atom.

  2. No forward references. It often helps authors to say, “These features are explained in a later chapter.” This confuses the reader, so we avoid it as much as possible.

  3. No references to other languages. We try not to refer to other languages, and do so only when absolutely necessary. We don’t know what languages you’ve learned (if any), and if we make an analogy to a feature in a language you don’t understand, it just frustrates you.

  4. Show don’t tell. Instead of verbally describing a feature, we prefer examples and output that demonstrate what the feature does. It’s better to see it in code.

  5. Practice before theory. We try to show the mechanics of the language first, then tell why those features exist. This is backwards from “traditional” teaching, but it often seems to work better.

We’ve worked hard to make your learning experience the best it can be.


When we refer to another atom in the book, the reference has a gray box around it. A reference to the current atom looks like this: Introduction. In the eBook, this hyperlinks to that chapter.


In this book:

Sample the Book

To introduce the book and get you going in Kotlin, we’ve released a sample of the electronic book as a free distribution, which you can find at The sample includes the first two sections, which is large enough that it is useful by itself.

The complete book is for sale, both as a print book and an eBook. If you like what we’ve done in the free sample, please support us and help us continue our work by paying for what you use. We hope that the book helps and we greatly appreciate your sponsorship.

In the age of the Internet, it doesn’t seem possible to control any piece of information. You’ll probably find the complete electronic version of this book in numerous places. If you are unable to pay for the book right now and you do download it from one of these sites, please “pay it forward.” For example, help someone else learn the language once you’ve learned it. Or help someone in any way they need. Perhaps in the future you’ll be better off enough that you can pay for the book.

Example Code & Exercise Solutions

These are available for download from


You can find information about live seminars and other learning tools at


Bruce creates Open-Spaces conferences such as the Winter Tech Forum and the Software Architecture Forum.

Join the mailing list at to stay informed about our activities and where we are speaking.

Support Us

This was a big project. It took time and effort to produce this book and accompanying support materials. If you enjoy this book and want to see more things like it, please support us:

About Us

Bruce Eckel is the author of the multi-award-winning Thinking in Java and Thinking in C++, and a number of other books on computer programming including Atomic Scala. He’s given hundreds of presentations around the world and enjoys putting on alternative conferences and events like the Winter Tech Forum and Developer Retreats. He lives in Crested Butte, Colorado. Bruce has a BS in applied physics, and an MS in computer engineering. He studies organizational dynamics, trying to find new ways to organize companies so working together becomes a joy—read about this at, while his programming work is at

Svetlana Isakova began as a member of the Kotlin compiler team, and is now a developer advocate for JetBrains. She teaches Kotlin and speaks at conferences worldwide, and is coauthor of the book Kotlin in Action.



About the Cover

Daniel Will-Harris designed the cover based on the Kotlin logo.

Previous          Next

©2018 Mindview LLC. All Rights Reserved.