This is coming out late on its release date, and to those who actually care (as few in numbers as those people may be), I’m sorry about that. I had taken most of the week off of work in order to work on stuff like this blog and finishing the peripheral parts of my book, so of course I wasted all away all that time with things that didn’t really matter 😛
Anyway, this post is a list of my favorite programming books that I read this year! They’re grouped into categories for your convenience (and my OCDness).
Python was my main focus at the beginning of the year, which slowly turned more heavily to Kotlin. Nonetheless, it’s still one of my favorite languages, and thanks largely to the book I’m writing, it’s still the most used language by me 🙂
- Functional Python Programming: In some ways, it seems to be teaching you how to not be functional, since it talks about using stateful objects (iterators) and loops instead of recursion, but those are more so nods to the limitations of the language than dislike for functional programming. It goes very deep into teaching how to generally avoid OO by using tuples and lists for data and using nice transformations for everything else. Also introduces the PyMonad library – a very powerful library for functional programming in Python.
- Mastering OO Python: This book lives up to its name, and is a very good manual for learning nearly everything there is to know about OO as it pertains to Python. It includes a lot about serialization and persistence, but surprisingly little about descriptors (which is obviously a topic near to my heart, considering my book). It’s also a little out of date in that it doesn’t include anything about the async objects that are included in Python now, which isn’t really a big deal, since most people won’t be creating their own async iterators of context managers.
Not a whole lot of reading for Java this year. I’ve largely been expanding my knowledge base of other languages as well as starting to try and find broad-range topics to study up on. For instance:
- Learning Reactive Programming in Java 8: This is largely just an “introduction” to RxJava. I say “introduction” with quotes because it is an introduction, despite how much they throw at you. There is so much that this library can do that a typical book can’t convey it, and yet it still does one thing. It seems quite useful, and I hope to get a chance to use one of the ReactiveX libraries soon.
- Pragmatic Unit Testing in Java 8 with JUnit: I talk more on this book below in the Unit Testing section.
There is only one officially recognized book written for Kotlin at this point (one more that has an early access that I just started reading), so almost anything and everything out there is just blog posts and videos that go through the feature set, over and over again. As annoying as it is to not really get anything new and exciting about Kotlin lately, that didn’t stop me from rereading the entire reference again recently. I needed to catch up on all the changes and make sure they were properly locked in my head, plus I hadn’t really looked at a few of the aspects of the language in my first time reading through it (and they’re also the least reiterated things out there). Nonetheless, the other book for Kotlin is a fairly refreshing read:
- Kotlin for Android Developers: This was a very good read for Kotlin. It introduced some little known built-in extension functions, such as with(), apply(), and let(), which have similar, but usefully different abilities for cleaning up your code. It also teaches it in what is probably the most useful way possible: by using it to develop a program, specifically an Android app. This was made even more useful by showing the really helpful extensions and helpers that are provided with Kotlin’s Android library, KAndroid. Note: does not teach you how to make Android apps.
I really enjoy unit testing and TDD, but I don’t have a ton of practice with it, so I like to keep reading on it in order to make sure I understand all the best practices. Very recently, I started looking a little more closely at BDD. I’ve liked BDD for a while, but most of the implementations of it really just bug the heck out of me. I’ve found something that I think I like, and I’ll keep a little more updated on that, along with telling you about my personal Matcher library that I wrote as a substitute for Hamcrest.
But enough about all that, let’s look at my favorite books in unit testing that I read in 2015.
- Working Effectively with Legacy Code: This is a classic; an oldie but goodie. The early chapters are about the importance of testing, TDD, and refactoring legacy code to testable code. It even makes its definition of legacy code to be any code that doesn’t have tests. I believe I heard that this is the original source of that statement, which has been slowly making its rounds on the internet. The later chapters are more of a reference for how to do specific refactorings to fix specific legacy code problems.
- Pragmatic Unit Testing in Java 8 with JUnit: This is a pretty specific title for a testing book, and it almost didn’t even live up to its name, largely because there’s so many facets of its name it needs to live up to. Specifically Java 8; Specifically Pragmatic, Specifically JUnit. But it does live up to it, and it even touches on Hamcrest Matchers.
- Interface-Oriented Programming: While its name inspires the idea that it’s a whole new way to look at programming (the way Object Oriented Programming was), it’s more of a practical look at designing the public APIs of your classes with a sharp eye, discussing several different “paradigms” of interfaces, such as APIs that do pushing instead of pulling of the data.
The more I read, the more I want to try and make more of my code functional. I still always want to leave it semi OO, but I consistently want it more functional. My next project will be an attempt to follow what it talked about in this talk, Boundaries. In it, the speaker mentions a functional core, but using OO at the boundaries for IO.
Anyway, here are some books that are tugging me to the functional side.
- Functional Python Programming: this was discussed already in the Python section.
For every good book out there, there are some duds. Here’s my list of the least favorite books I read.
- Functional Thinking: It mostly just compares the functional features of Scala, Groovy, and Clojure. It attempts to teach functional thinking, but Becoming Functional did a much better job of that.
- Advanced Python: Not advanced at all, really.
- Java Performance: The Definitive Guide: Not terrible, but kind of lacking in helpfulness for a “definitive guide”
This is a decent book that I read this year that didn’t fall into any decent categories, but I feel it deserved a quick shout out.
- IntelliJ IDEA Essentials: Pretty much what the title says. I’ve been doing a massive migration away from Eclipse into the Jetbrains brand of tools, so this was a bit helpful.
So yeah, I do quite a bit of reading… It actually scares me a bit when I look back over it. Let me know of any great programming books you’ve read that you like; my list of books I want to read is finally starting to shrink, and while that means I might finally start reading more fiction books again, it does mean I’ll be doing less actual learning. Also point to any cool blogs you know of. Or podcasts. Or youtube channels. Whatever. Have a great week, faithful readers!