Senior Software Engineer Learns Functional Programming

This was one of the better books I’ve read recently for actually changing how I think about programming. It combines domain-driven design, test-first development, and functional programming into one coherent story, which is pretty rare, since most books only tackle one of those at a time. Unlike some of my other recent reads, the Kotlin itself was well-structured and idiomatic throughout, not just functional-flavored Java. ...

Better than initially assessed: Chapter 2 introduces collections, good variance coverage (with a Pet hierarchy), covers extensions and their role in the stdlib, two lambda/HOF chapters. Unusual ordering: generics before lambdas. map/filter/fold deferred to lambda chapters. Coroutines appendix exists but dated. Head First Kotlin uses the usual Head First spiral approach - introduce a concept lightly, let it sit, circle back with depth later - which meant it deferred anything not strictly load-bearing to the appendices. Labeled breaks and enum classes, both things I’d consider core language features, got pushed all the way to Appendix C rather than covered in the main chapters. That appendix is even honest about it in the title: “The Top Ten Things (We Didn’t Cover)” - ten separate topics, including packages, visibility modifiers, sealed classes, and object declarations, that never made it into the twelve main chapters at all. ...

Brief summary: math/computational projects (Euclid, Sieve, Fibonacci, physics sims, fractals, sorting, A*), no extension functions, limited language features in intro chapters, good for drilling val instincts. Not idiomatic Kotlin. Good typing practice and some genuinely interesting math/algorithms, but disappointing as a source of good Kotlin code. Chapters 1-2 covered language fundamentals in almost as much depth as all of Head First Kotlin, but that depth never returned. Nothing past chapter 2 touches generics, sealed classes, delegation, or coroutines. Chapter 3 was a whole detour into JavaFX I didn’t ask for and won’t need for Android/Swift, though I don’t regret typing it (the Stage/Scene boilerplate turned into a genuinely cool spiral, and the Gradle multi-module setup fights taught me more about the build system than the book itself did). ...

1177 BC is far less a final verdict than I would’ve preferred. Apparently, historians have discussed the Bronze Age collapse for at least 100 years, but this book mostly calls into question the traditional simple ideas and makes a case for a combination of earthquakes, revolts, and, to a much lesser extent than originally thought, the sea people invading, plus maybe some type of disruption of the trade networks, which again could be caused by the sea people or other unknown maritime raiders. ...

Sometimes it’s fun to read easy books, and this was an easy, fun book. It didn’t go into as much depth about Python as the Python Tutorial on the Python website, but it covered the basics, then went on a romping overview of using all sorts of libraries to perform tasks you might need to perform. Some of the tasks were pretty relevant, like loading an Excel file, working with JSON, or sending yourself an email; others were cool and could be put to creative uses, like driving a web browser with Playwright or working with a SQLite database; and some were kind of niche topics that I’d look back up if I ever needed to deal with them, like working with XML, OCR, or speech recognition. They were all kind of fun to play with, so I enjoyed reading this book. ...

Go’s tooling is what stuck with me the most. gofmt is flawless, even on case statements, no matter how hard I try to trick it, it always formats the file correctly. Cross-compilation with GOOS/GOARCH is excellent, shipping a single self-contained binary is genuinely nice to hand off, and the command line tooling is great too. I like that the implementation stays transparent instead of hiding behind framework magic, and I prefer simple structs with methods over deep inheritance hierarchies. Head First Go gave me real confidence with the language, and Powerful Command-Line Applications in Go taught me a lot about building command-line apps, even in languages other than Go, like how easy it is to write a markdown previewer when the standard library gives you so much for free, and to always check out a new language’s argument-parsing frameworks early. Even // comments felt natural to me. ...

This was a good way to see a number of non-trivial applications in Go. It tackled real projects like a Markdown Previewer and a Port Scanner and used production-grade libraries like Cobra for command-line arguments and Viper for configuration settings. The Markdown Previewer was probably good enough for me to consider using it. Honestly, Cobra and Viper were good enough libraries that it makes me start looking at what my options are for command-line parsing libraries early when studying a new language now. A lot of the examples were big to type, but that is good since it made me feel more comfortable with the language. They were also complicated enough that I made mistakes and got to deal with error messages from the compiler. I will say I was disappointed multiple times that Go’s compiler points out the first error it finds and then stops, so when you fix it you might just be greeted by another error. It’s not like Java or Kotlin where the compiler spits out 10 errors and 5 are probably caused by the earlier errors but the other 5 need to be corrected. The pomodoro app was actually quite usable after I got past the fact that it wouldn’t display correctly in tmux. That was a hard debugging session wondering what was wrong with my output from typing up the code before I finally pinned the blame on running it in a tmux session though, since having a tmux session is just getting so normal to me. Not only did I learn a lot about using Go for small to intermediate-sized projects, but I learned a lot about writing good command-line apps that I can take with me to other languages. ...

Overall, it’s what I expect from a Head First book. It was a perfectly serviceable introduction to the Go programming language. Although it’s a Head First book, I feel like it treated me like an experienced programmer and didn’t waste a lot of time explaining how an if expression worked. Unlike Head First Kotlin which never got to a lot of things that it had to toss into Ten Brief Topics in the Appendix, it felt like it covered all the main topics that needed to be covered to understand Go. It even includes coverage of automated testing and a couple of chapters on web apps. ...

So, I haven’t been blogging for about ten years. To tell the truth, I spent all day programming, so when I got off work, I spent my time reading history or philosophy or anything else not computer related. I can see from my previous posts that I was experimenting with video and had started reading Agile Web Development with Rails. Well, I’m still a full stack web developer, so I could do worse than looking back at the web framework that really started it all. So I will read Agile Web Development with Rails 8 and get a taste of convention before configuration. That doesn’t really fit with the new title of the blog, but it’s still something I want to do, so I will get it done. I was interested in functional programming and different approaches to web development 10 years ago, and have never fully explored either, so I’m picking up where I left off with a slightly updated approach. ...

This time I’m working on reinforcing some of the Spring and Spring Boot knowledge I’ve picked up from other videos, while seeing if I can learn a couple of new tricks while at it. I’m watching Spring Framework Essentials through my Safari Books Online membership. It’s presented by Ken Kousen, who often hosts the Groovy Podcast. He has a series of three Groovy videos in Safari Books Online that I wouldn’t mind going through sometime in the future. The video series runtime is 5 hours, 14 minutes and it has a five star rating from 35 reviewers. Not bad, let’s see what it covers. ...