I finally feel like I *get* Lisp and functional programming and found a few tools that really fit my brain like a glove. I struggled throughout the year and nearly turned in my keyboard and rode off on my touring bike to live a life without technology but getting into functional programming and some old and somewhat unpopular ideas about computing lead me to rekindling my passion and starting fresh for 2017.
I started reading some HN threads about designing and implementing high-assurance computing systems which lead me to spending many weeks studying the work of Niklaus Wirth. He was on a mission to replace complex languages and methods with ones simple enough for both teaching the fundamentals of computer science and building reliable production systems. I started programming with Visual Basic, C, and UNIX shell scripting skipping the Pascal that Mac users at school were getting into.
I started the new foray into computer science by seeing what made AdaCore's SPARK good for building reliable and secure operating systems and applications to run on them. SPARK lead me to examine the origin and evolution of the Wirth way of structuring your code, using a type system, coding using contracts, and so on. I spent some time with the modula languages, tried out the oberons, and eventually installed a copy of the BlackBox Component Builder (a Component Pascal).
Somehow from Component Pascal I ended up reading up about the Amiga OS and the ideas of Carl Sasenrath resulting in me installing Rebol 2, Rebol 3, and Red. Rebol grabbed my attention and I quickly took to the languages and Carl's ideas for how you can write performant software that was reliable, easy to understand, could be written rapidly, and that could even have cross-platform graphical interfaces without the nightmare you find in writing GTK code in C++. However, as much as I saw the future where we would all be writing elegant code in Red and spending all of that extra time we weren't writing code actually enjoying the money we made from our career the community was divided between the three language generations and wasn't delivering on Red anytime soon.
Rebol lead me to a few bloggers who had went from using Rebol for all of their programming projects (personal and professional) to a Lisp-like language called newLISP. I had written a bunch of code at the end of 2015 in Clojure, Chicken Scheme, Racket, Javascript (Node) and F#. I began starting to integrate more and more functional techniques into my code in other languages (Python, Ruby, PHP). I also took another look at Rust after a disappointing few months with Go.
Then one day after reading through a bunch of newLISP code, the newLISP manuals, every blog post I could find about newLISP, and every Github repo that had newLISP as the dominant language I started to get it. I understood "code as data". Without the cloud of odd function names that were hard to remember (Common Lisp) or all of the new syntactical elements that Clojure added it was just a short time until the parens didn't bother me. newLISP made it possible for me to start writing code and experiencing the bliss of working with small composable functions, fewer data structures, and with batteries pretty much included. There was no build tool, dependency manager, project scaffolder, or anything like that creating mental friction and making me run back to Python.
I started reimplementing old failed projects and was suprised at how quickly I was able to surpass the progress made in languages that I've used for years. In three days I was able to implement at least twice what I had accomplished with Python in several months and I attribute it mostly to programming being fun again because I wasn't struggling with remember language syntax, function protypes and class hierarchies.
Next I started using newLISP as a means for exploring other ideas like the different types of OOP and different approaches to web frameworks. I started to understand concepts that made no sense when trying to learn them at the university in C# or Java because I could focus more on experiencing the ideas as I very rapidly explored things in the REPL and with the flexible lack of syntax.
Then I started seeing how I could simplify the code and make things easier to maintain by using macros to generate some of the repetitive bits and to craft simpler ways to represent the intention of the code. DSLs made sense in Ruby from the perspective of the guy using them but I hadn't the slightest clue as to how they were implemented.
It also sank in deep just how benficial it was to stick to a single language (or language family) throughout your career and just adapt it using the techniques learned from Lisp and FP to add new syntax, new control structures, new data structures, and so on. You don't need to learn a new language when you can experiement with the new technique in the language that fits your brain best.
Now I feel like I'm capable of solving any problem with the tools installed on my machine so long as I understand the problem domain. Front-end techniques starting making more sense too through the eyes of functional programming (FRP, MVC, etc).
I created a massive backlog of projects to work on over the year as I was trying to dump all of the tech from my mind and move on. 2017 will be the year to knock implementing a ton of them off and release useful code as quickly as I can.
I've been off to a start so far by contributing to the Chromebrew package manager for ChromeOS. I've made more commits and had more pull requests merged into the project this month of December than I did over the last few years in total!
I'll be adding a blog to this site and hopefully starting to post regularly about what I'll be working on including: