The CommonsBlog


How You Can Help!

This week, I released two new books, focused on “second-generation” Android app development, using Jetpack/AndroidX along with Kotlin. Those books are works in progress — they should reach 1.0 status sometime early in 2019.

Eagle-eyed observers will notice that my pace has slowed a fair bit. Ordinarily, I would have done point releases of those books long before now and might already be to 1.0 versions.

Unfortunately, I have fewer subscribers than I used to, and I have fewer training customers than before. To make ends meet, I took on some longer-term consulting work. While that has been wonderful, it limits how much time I have to devote to the books.

If you would like me to be able to work faster on the books, spread the word! The more interest there is in what I do, the more time I can spend working on that.

If there is anything in particular that I can do to help you or your organization, reach out!.

Dec 07, 2018


Where Things Go From Here

This week, I released two new books, focused on “second-generation” Android app development techniques: Jetpack/AndroidX, particularly using Kotlin.

The other four books in the Warescription, at present, cover “first-generation” techniques: the Android Support Library, particularly using Java.

Of course, the material in those books is not obsolete at this time. Only some developers have moved over to AndroidX, for example, in part because those libraries only shipped in a 1.0.0 state a couple of months ago. “Jetpack” is a brand, and I have been covering most of the Jetpack pieces for quite some time. But, inevitably, the material in those four books needs to get upgraded to second-generation approaches, before it actually does become obsolete.

Beyond continuing my work on the two new books in the Elements series, my top upgrade priority is Exploring Android. I started that book this year as a replacement set of hands-on tutorials. I got through most of what I wanted… but then Jetpack/AndroidX were released. Plus, I wrote those tutorials in Java. So, starting early next year, I will work on rewriting Exploring Android as a second-generation book.

The “odd duck” of my first-generation books is Android and GraphQL. I wrote this book as the Architecture Components were rolling out, but I incorporated little of them in the book. So, this book is further behind than is Exploring Android. Also, it is more of a niche title, as GraphQL has its fans but is not dominating the Web service space. But, it has the advantage of being a small self-contained book. Eventually, I will rewrite this as a second-generation book, but it is not a priority.

This leaves Android’s Architecture Components, and, of course, The Busy Coder’s Guide to Android Development.

The problems with The Busy Coder’s Guide to Android Development are its size and age. It will take me a few years to upgrade everything in that book to second-generation approaches, in part because I cannot only do that — I need to cover new material as well. The transition from second-generation material back to the first-generation stuff would be fairly jarring in one (large) book. For example, ListView is not that critical anymore, having been supplanted by RecyclerView, but a lot of my older examples still use ListView. So while the early chapters of a revised book could skip ListView, I would still need it somewhere, just so people have the material to understand all those other samples. Compounding the problem is that I should be blending in parts of the Architecture Components into new introductory material, rather than having it all be in a separate book.

This is why I started the Elements series, particularly Elements of Android Jetpack. And it is why, in early 2019, I will be publishing one final update to The Busy Coder’s Guide to Android Development and Android’s Architecture Components, to correct some errata. Beyond that, I will not be updating those titles, and they will remain first-generation books.

The Android material, though, will get rewritten, so long as there is interest in my work. It just will go into Elements of Android Jetpack or other second-generation titles. So, rather than try to monkey-patch these two first-generation books, I will replace them with newer, better books. Similarly, coverage of new Android versions, new tools versions, and new library versions will go into second-generation books.

This is one of the reasons why I want to offer full-text searching across all of the books. That way, it is easier for you to tap into the knowledge base in The Busy Coder’s Guide to Android Development for particular topics, while I progressively offer updated material on those topics.

This is a major change, and one that I take with quite a bit of trepidation. I think it is the best answer for my subscribers, and I can only hope that I am correct in my assessment. If you have concerns about this plan, please let me know.


I mentioned “so long as there is interest in my work”. Tomorrow, in my final post of this series, I will explain a bit more what I mean and how you (yes, you!) can help.

Dec 06, 2018


Read Online!

Elements of Kotlin (announced Monday) and Elements of Android Jetpack (announced yesterday) are my first two second-generation Android development books. Like my previous books in the Warescription, subscribers can download these books in PDF, EPUB, and Kindle/MOBI editions.

They can also read them directly online.

The Warescription site offers both download and “read online” options. The latter brings up the book directly in the browser. The reader offers:

  • Forward and back navigation through the major sections of each chapter

  • Drop-downs to navigate between the chapters and books

This may prove useful directly to some of you. It is also a stepping-stone towards offering online full-text search across all of the books, which I hope to have up and running in early 2019.

I will be making the first-generation books available for online reading as well, but I wanted to start small at the outset.

If you are a subscriber and you run into problems with the online reading option, let me know!. The more bugs I can get fixed now, the smoother it will be to offer full-text searching in the future.


Tomorrow, I’ll talk more about those first-generation books, and what my plan is for them.

Dec 05, 2018


"Elements of Android Jetpack" Version 0.1 Released

Subscribers now have access to Version 0.1 of Elements of Android Jetpack, in PDF, EPUB, and MOBI/Kindle formats. Just log into your Warescription page to download it, or set up an account and subscribe!


As I noted in yesterday’s Elements of Kotlin release, I am working on books for the second generation of Android app development:

  • First-generation techniques revolved around the Android Support Library and were mostly based in Java

  • Second-generation techniques center on the Jetpack and AndroidX libraries, with more code written in Kotlin

Elements of Android Jetpack is an introductory book for Android app developers, with Version 0.1 covering up to some basic UI construction (widgets and ConstraintLayout). Over the next several months, I will expand it to cover much of the core pieces of Android app development, as the table of contents illustrates.

Compared with The Busy Coder’s Guide to Android Development, Elements of Android Jetpack:

  • Features parallel samples in Java and Kotlin, to help ease the transition to developers new to both Android and Kotlin

  • Focuses on the Jetpack components, including relevant bits of the Architecture Components (e.g., ViewModel, LiveData, Room)

  • Employs the AndroidX libraries, as opposed to the Android Support Library

  • Drops most of the legacy stuff: very little on RelativeLayout, ListView, etc.

(of course, a lot of this is still to be done, as this is merely Version 0.1)

Elements of Android Jetpack is my long-term introductory book on Android app development… and I’ll talk more about what that means for The Busy Coder’s Guide to Android Development and Android’s Architecture Components on Thursday.

If you are already a subscriber, and you have already worked through the core chapters of The Busy Coder’s Guide to Android Development, Elements of Android Jetpack is not for you… yet. Give me a few more months, and there will be a few topics that might be new for you, such as the Navigation library (if it ships in final form).


In addition to the two new books, subscribers got something else yesterday: a new way to read the books. I will talk more about that tomorrow.

Dec 04, 2018


"Elements of Kotlin" Version 0.1 Released

Subscribers now have access to Version 0.1 of Elements of Kotlin, in PDF, EPUB, and MOBI/Kindle formats. Just log into your Warescription page to download it, or set up an account and subscribe!


This is my initial book for what I have been calling “second-generation” Android app development:

  • First-generation techniques revolved around the Android Support Library and were mostly based in Java

  • Second-generation techniques center on the Jetpack and AndroidX libraries, with more code written in Kotlin

While there are other books on Kotlin out there, I wanted to ensure that subscribers had access to one. As the book evolves, you will see that I’m also taking some different approaches towards covering Kotlin.

Part of that is because while I appreciate Kotlin as a programmer, as an educator I find Kotlin to be very “busy”. It has lots of keywords, lots of syntax rules, and lots of specialized capabilities.

From what I can tell, most of that complexity is there to allow simple Kotlin to be as simple as it is, and to allow library developers to offer similarly simple APIs. This is wonderful for experts, and the results are wonderful for everyone. However, the vast majority of developers are not writing libraries — they are the consumers of sophisticated APIs, not the producers. As a result, a lot of Kotlin seems to fall into YAGNI (You Aren’t Going to Need It) for ordinary developers.

But, along the way, they may wind up seeing aspects of complex Kotlin and have to make sense of it.

For example, the kotlinx.html library offers a DSL for HTML generation. With that DSL, you can do stuff like this:

val docs = "https://kotlinlang.org/docs/reference/operator-overloading.html#unary-prefix-operators"

val div = document.create.div("my-css-class") {
    p { 
        +"This is preceded by a unary plus operator. "
        a(docs) { +"(no, seriously)" } 
    }
}

Is having a unary-plus operator (+foo) unreasonable? No. Is offering operator overloading unreasonable? No. Is allowing the unary-plus operator be overloaded for String unreasonable? No.

But the result (+"huh?") winds up being something that an ordinary developer is likely to to respond with “Kotlin, WTF?”. As an educator, I dread languages that make learners go “WTF?”.

(plenty of things in Android app development cause developers to say “WTF?” — I don’t need a language adding to the pile of sources of “WTF?”)

My objectives with Elements of Kotlin are:

  • Help developers be able to read any Kotlin that they might encounter

  • Help developers be able to write ordinary Kotlin

  • Help curious developers discover what some of that unusual syntax or keywords are called, in case they wish to dive more deeply into how to use it for their own work

Some of this will involve finding ways to help developers find out the terms behind some of this syntax. Searching Google for kotlin +, for example, does not help much.

Right now, in Version 0.1, the book covers a lot of the core Kotlin syntax and features. There are a few core items that I need to get into, such as coroutines and Java interoperability. But a lot of what remains is covering the “WTF?” — I am expecting 40+ short chapters on things like:

  • Why is a certain generic declared out? Is this a baseball thing?

  • What is reified? Does that imply that originally the code was only ified, and we did something a second time to make it be reified?

  • Is crossinline some form of 1990’s “eXtreme” type of inline? And what does inline skating have to do with Kotlin, anyway?

  • And so on

Over the next several months, I will build to a Version 1.0 that covers everything in Kotlin 1.3. After that, updates will proceed largely based on new Kotlin releases.


Subscribers will also notice a few other new things in the Warescription. I will be explaining what else is new, and the plan for the Warescription, over the course of this week.

Dec 03, 2018


Older Posts