Jimmy Hartzell#

Hello!

Professional programmer, amateur writer, temperamental opinionator.

I work at Savant Power as a Rust programmer. This is a personal blog; my opinions are my own and not my employer’s.

Please see also my GitHub, Twitter, and Reddit accounts. Not looking for a job right now, but here’s my resume for the curious.

Writing and Opinionating#

This blog is a programming blog and also my personal blog. Neither of these use cases are prioritized. Currently, the programming use case is receiving both more effort and attention, but the blog is for both. These use cases are not cleanly distinguished.

I have a bad habit of strewing my opinions all over social media; this has led to trouble for me, as it turns out that social media is the wrong place for these discussions. Therefore, take note: In addition to an outlet for things I want to explain about programming, this is a vent space for all the personal essays and thoughts that I’m compelled to write down and share, some of which have to do with programming, and some of which don’t. Please enjoy the output of this compulsion!

Finally, fiction. I started getting back into fiction after posting this on Facebook and getting a shocking number of likes. The past two years (2020-2021) have been very stressful, so I’ve been on and off the fiction wagon, but after I’m done moving house, I’m going to try and get back into it.

I would ideally like to write fiction at a level where it would be publishable, like by real publishers, but I think this is more of a lifetime, next-few-decades type of goal than a “right now” type of goal. In the meantime, some of it gets posted here. Please enjoy!

This is my blog, and so I realize I can just put links to things I like, so I will.

Here’s a few such things:

Here are a few links to materials that helped me get my bearings in Rust, and understand it deeper.

Many of these are bog-standard, and the same materials others would recommend. This is a good thing. Rust is an extremely well-polished programming language with an excellent community. Trust them about the idioms. Trust the programming language. If you don’t understand why Rust made a certain decision, know that there is almost certainly a well-considered, important reason, and that includes its choices of commonly-recommended documentation.

Beginners:

  • Of course, The Book is the absolutely indispensable canonical reference for the programming language.
  • O’Reilly’s book is also well worth reading
  • For those who like exercises, Rustlings is incredibly well-done.
  • For those coming, like I did, from C and C++, Learn Rust the Dangerous Way is a great resource.
  • Rust has a relatively small standard library. Some external dependencies are practically standard, and have their own tutorials and documentation. Among these are Tokio, Serde, and log.

Intermediate:

  • Rust for Rustaceans is a nice “second semester” course in Rust, covering all the things that every advanced Rust programmer really should know, and no longer has to learn the hard way. This contained a lot of especially useful information for the serious software engineering and dependency management considerations involved in maintaining a library and publishing a crate.
  • There are a lot of misunderstandings about unsafe in Rust, but most can be cleared up by reading the Rustonomicon. Even if you don’t personally have occasion to use unsafe, it is an essential part of the language, and the crates that you depend on – whose source code you should be reading – will use it.
  • Faster than Lime, as far as I can tell, straddles beginner and intermediate.
  • Learn Rust With Entirely Too Many Linked Lists is a project to teach Rust by programming the data structure it is perhaps least well-suited to.

Recommended articles (I expect this to get a lot longer over time):

Essential resources:

Recommended articles:

Classics, for the vibes:

Programmer Bio#

I learned to program as a child in the 90’s back in the era when PCs came with sample games like QBASIC Nibbles, with included code for hobbyists and learners to play around with. It was sheer luck that this random interest of mine turned out to be a marketable, employable skill.

My personal story plays into the narrative of the driven young autodidact, usually male, usually socially awkward, who has that “genius” to be a “real programmer”, perhaps at the expense of other qualities. But this is not my take-away. Anyone can learn how to program, even if they don’t write a line of code – or even touch a computer – until arbitrarily late in life. And unlike other forms of math and logic, it is accessible even to young children, and should be taught in schools alongside other subjects.

I was very fortunate that my uncle and godfather encouraged me in programming from an early age, and also got me into Linux and open source software. I quickly developed an interest in operating systems and systems programming, running FreeBSD and trying to learn the Unix systems call API and the differences between the Unix flavors. I still feel most at home in systems programming languages, such as C; C++; and in our modern era, Rust (but more on that later).

After an embarrassing period where I got deeply into dynamically-typed OOP, Smalltalk, and Objective-C, I was introduced to functional programming and static typing at my university’s functional programming course (then called CS312 and in SML), and I quickly understood the benefits. My friends soon introduced me to Haskell, which I digested with enthusiasm. It is still my favorite GC’d language and applications programming language.

My career proceeded in the C++, systems side of things, as I worked as a low-latency programmer and later as an instructor at Tower Research Capital, but I never forgot my affection for Haskell and powerful static type systems. I excitedly embraced “modern C++” and C++11, and tried my best to use C++’s features to maximize safety and expressiveness.

After Tower, I wanted to avoid finance and low-latency programming altogether, and took a job at Obsidian, one of the largest Haskell consultancy shops, to work on a mix of embedded C projects and Haskell projects in Reflex, Obsidian’s open-source framework for “Functional-Reactive Programming,” a revolutionary up-and-coming paradigm for GUI programming.

But my interests in strong typing and in systems programming could not fully be reconciled until I joined Savant Power, my current employer, and discovered Rust. As I learned more about Rust, it overcame my initial skepticism, and it became clear to me that Rust was finally achieving what modern C++ had been striving for for so long: A high-performance systems programming language that was also type-safe, ergonomic, and composable. And that is where I stand to this day.