Essays at the intersection of culture, software, technology, and engineering

Musings on Programming

Intro

I’m having a lot of fun these days with the enterprise Java software project at my current workplace (General Motors) here in Austin (Texas), and have had scarce little time for doing functional programming lately. In this essay, I’m doing something of a context switch: By the way, my reference to the term context switch (i.e. the process of storing and restoring the state of a process or thread so that execution can be resumed from the same point at a later time) will likely reveal my roots in embedded systems programming, which is where I got my start as an application programmer, with Schlumberger Corporation in South Carolina, circa 1995.

The Aim

With that, my hope with this essay—and those to follow—is to share some musings on programming in the large. I continue to get a kick out of crafting computer programs to solve hard problems! And this is the venue where I will share my ever-evolving understanding (grokking, if you will) of crafting software-intensive systems… Since we’re on the subject of functional programming (FP), I would like to put on the virtual stack the context of my most recent forays into FP, which I undertook during my spare time (evenings and weekends) over the past two years or so, coinciding with my career at eBay and PayPal.

Functional Programming (FP), You Say…

Scala and Clojure were the two primary languages that served as the vehicles for doing FP. And of all the FP books that I’ve read, here are my top picks:

Brilliant and inspiring. Having read a fair amount of his writings, I can see without hesitation that pretty much anything by Fogus is good! Check out his pithy writings and Github contributions (I’ve lost track of the projects on which Fogus is a committer). Also, check out his other book, Functional JavaScript: Introducing Functional Programming with Underscore.js.

This is a really nice collection of recipes to experiment with Scala on your REPL… I couldn’t resist the temptation to add that Alexander is a fellow Texas A&M alum; needless to say, he’s got to be good, right? Universty of Texas’ Longhorns, please take note 😉

Types and Programming Languages, by Benjamin C. Pierce

This book from The MIT Press is a bit tough-going in places, but well worth the effort if you can stomach the mathematical machinery (lambda to its core) presented in the book, and which serves as the vehicle for quintessentially delivering the ideas. I’ve read portions of this book so far…

Practical Common Lisp, by Peter Seibel

My route, a bit meandering, I confess, through the FP terrain took me from my first stop—Clojure and, BTW, look no further than the CounterClockwise plugin for Eclipse for hacking Clojure—to the second stop, i.e. Common Lisp, then a bit of Scheme thrown in, and finally arriving at Scala, which is a language showing every sign of surviving—and thriving—as a viable FP language that’s eminently suitable for corporate development. And IntelliJ IDEA 13 is my IDE of choice. A message here to the JetBrains’ team, if somehow we can funnel this sentiment to them: Why are you not providing the same level of support for Clojure, the loveliest Lisp around, a gift from Rich Hickey, and a language that meshes seamlessly with the JVM ecosystem, and then some?), whereas other Lisps—notwithstanding Common Lisp and Scheme, of course—have fallen by the wayside, like the husks of computer science projects. Anyhow, of the books on this list, this is one of the two that is both brilliant and inspiring!

Scala in Depth, by Joshua D. Suereth (Manning)

This is Scala straight from the horse’s mouth. Suereth is a virtuoso of type theory, the Scala tool chain and, come to think of it, everything Scala… I can highly recommend Scala in Action, by Nilanjan Raychaudhuri (Manning) as an excellent first book leading up to Scala in Depth.

A bit of a boat anchor, weighing in at 850 page-plus, ahem (and evidently the motivation and rationale for the emergence of another concise book that’s titled, rather tongue-in-cheek, I would say, Scala for the Impatient, by Cay S. Horstmann), but straight from the horse’s mouth. This one’s a keeper, too.

This is an eminently readable, instructive, and wide-ranging coverage of all things Clojure.

Functional Programming Patterns in Scala and Clojure: Write Lean Programs for the JVM, by Michael Bevilacqua-Linn (The Pragmatic Programmers)

This one has turned out to be a gem of a book, replete with advice on using Scala and Clojure to solve in-depth problems, and seeing how familiar object-oriented patterns can become more concise with functional programming and patterns—This one has a very high Signal-to-Noise Ratio (SNR) of ideas-to-pages 🙂

Post navigation

Hi there, my name is Akram Ahmad. I’m a Principal Software Engineer in the Research & Innovation Group at Dell Technologies. I am based in Austin (Texas). My focus continues to be on architecting, designing, and developing applications as well as infrastructure for distributed systems. I’m passionate about Java, Go, Scala, Reactive Programming, AI, and perfecting the fine art of programming. Oh, and I’m really into writing, too.

Search for:

Blog Stats

32,754 hits

Recent Posts

Recent Posts

Follow Blog via Email

Enter your email address to follow this blog and receive notifications of new posts by email.