This post is really just a bookend for this blog.

2018 marked the end of my academic career and the start of my journey as a software engineer.

Some intentions for this year

Writing more

Last night while I was figuring out how to blog again, I was pleased to find that I really do enjoy maintianing this site. This is perfect because I plan to use it more to capture things I learn on a weekly basis. Really, I just plan to use it more in general.

The schedule and format of it all is still up in the air right now. That might come back to bite me in the butt as far as accountability goes, but we can deal with that problem if/when it gets here.

Reading more

Thanks to a nice perk at work, I have grown my library of technical books a bit. Ideally I would be able to read them all this year. That doesn’t seem like a very attainable goal however, so I’m starting small.

Here’s the list:

• Design It! From Programmer to Software Architect by Michael Keeling
• The Go Programming Language by Alan A. A. Donovan and Brian W. Kernighan
• Getting Clojure by Russ Olsen
• Fluent Python by Luciano Ramalho
• The Rust Programming Language by Steve Klabnik and Carol Nichols

While these are the ones I’m actively trying to read this year, I’m sure others will sneak in or some of these may be dropped.

The Whys

As I’ve learned while working on projects at work, documenting the reasoning behind a decision is more important than documenting how something is done.

The writing

The past has shown that I’m pretty bad about sticking to a writing schedule. While this is just another attempt at finding something that works for me, I am also interested in capturing my professional growth over time. There’s so much that I’m learning at work and it’s hard to keep track of it all. A trick I picked up in undergrad though, is to reflect on the new piece of knowledge you just acquired and that helps it to stick in your memory. Just a few sentences about it documenting questions or comments and hopefully in a year, I can see the evolution of my understanding of a variety of topics.

The reading

Design It! calls itself a good introduction for people new to software architecture. Being a topic I have very little familiarity with, that’s a good enough reason for me to just pick up a book and see what it’s about. In general, I’m not a fan of doing things without a little background knowledge first. So when I read the book’s introduction, I was convinced this book would at least give me the vocabulary to communicate effectively at work.

Fluent Python is aimed at people wanting to be proficient at Python 3. It’s a giant book, but I’ve learned quite a bit from it already so I’m excited to continue chipping away at it this year. I’m hoping this book is the first step in my journey to becoming a Python guru. It’s a really cool language, but it’s tainted by people dragging over their habits from other languages.

Getting Clojure intrigues me because of a stellar review from a coworker. I’m roughly half way through the book already and I’m a fan of the author’s writing style. One of my favorite lines is in the intro: “This book is for people with some programming experience… who want to learn Clojure. Notice I didn’t say learn to program in Clojure**. This book really feels like a conversation with Olsen as opposed to a dry introduction to functional programming ideas and Clojure syntax. The most important reason I picked up this book is because Python and Clojure are the two main languages at work. So I want to at least be familiar with Clojure sooner rather than later.

Go has intrigued me for a while now. There’s a story that I vaguely remember hearing when I first heard about its existance; something like a group of (well known) engineers at Google threw together a language because they were unsatisfied with the ones they were using. Plus they had some downtime while a project was compling, so a faster language was needed. I have no clue if any part of that is true, but it’s cool enough that I want to learn more about Go. On top of that, since I’m using Hugo to generate this site, I thought it would be neat to learn a bit about what happens under the hood. I was actually reading the first chapter yesterday and it’s been a pretty good read so far.

Rust is very much related to C++ in my head, which I’ve been feeling out of touch with lately. It’s hard for me to think outside of Python and I really want (and should and need) to change that. So to see more of how languages do things differently and to get back in touch with working with a lower-level, compiled language, I picked up this book (and the Go book).