My Stack

Some notes on my technical setup, and things I play with.

Tools I Use All The Time

  • Neovim
    • Helps me focus on my task
    • Marks make navigating through code fast
    • I enjoy the modal style
  • tmux
    • Swap between my processes really easily without having to juggle terminal tabs/windows
    • Being able to ssh in and continue from where I was is fantastic
  • VSCode
    • Helpful for me to look at/skim projects with a big picture view
  • Git
    • I version everything :-)
    • I self-host a git server as a project store/offline backup
  • Figma
    • Figjams are one of my favorite mind-mapping/collaborative tools
    • Helps with understanding big/new concepts and requirements
  • Notebooks (the physical kind)
    • I write/draw/braindump a lot on good old fashioned paper
    • It helps with big/nonlinear problems since I can draw lines and write all over.
  • Docker/Containers
    • I never want to install MySQL on a personal machine again
    • I use it to enable developing systems that would normally be distributed across machines on a single one instead
    • Convenient deployment vector once the work is done

Programming Languages

Here is my breakdown of programming language experience, along with a blurb about each for context.

Languages I Prefer To Use

This list is really commentary on what I find valuable in my tools and what languages or features have served me well in an abstract sense. I realize that not every project will require or merit such consideration, and I am very comfortable working across languages to achieve the desired result.

Rust

If I'm going to be writing in a systems level language, I would take Rust any time. Many of the painful errors that I have experienced in C++ such as data races and nullability are caught at compile time. Furthermore, an actual package management system (cargo) makes managing projects much easier.

However, those are some of the basic arguments for Rust. Here is an example of why I want to use the language.

It's not always rainbows and butterflies, but I believe that the expressiveness and guarantees that rust provides outweigh its cons.

Anything with explicit error handling

Non-exceptional error handling removes a massive set of logical errors due to oversight or implementation errors. Exceptions are part of an interface, but we often do not have the tools required to adequately guarantee that that interface is correctly used. Explicit error handling through the type system gives a much clearer and stronger contract, which in my experience leads to far fewer errors.

Anything with strong typing

Unless the project is truly small or a one-off script, I prefer to have explicit types - no duck typing! There are certainly advantages to dynamic languages when prototyping certain types of applications, such as not having to define a JSON schema up front. However in my experience types serve to not only document the interface and related data, but also hugely reduce mental overhead thanks to support from tools like LSPs.

Languages I Have Built Complete Projects In

C++

I am very comfortable with C++, having written a fair amount in both embedded and desktop environments. I enjoy the ability to be close to the hardware and develop highly efficient programs, despite the challenges that come with explicit memory management. The inclusion of smart pointers, as well as support for other high level language constructs, makes it a much safer and more compelling target. The primary reason I don't include it in my "preferred" list is because the tooling and related project management overhead are not as uniform or streamlined as other environments.

Javascript/Typescript

I have written extensively in this language, building many tools and products in both browser (React, Solid, jQuery, vanilla) and server (Node.js) contexts. It is a very convenient language for rapidly putting something together, but it suffers the same flaws as any dynamically typed language when projects begin to scale and interfaces become more complex. Typescript, while an improvement over Javascript when it comes to refactoring and LSP integrations, falls very short thanks to its duck typing and limited support for true interface definitions.

Python

I've used python to develop with NLP as well as server-side web applications. It's not my preferred style (I dislike the choice to have whitespace being significant) and sometimes the lack of explicit typing makes following data transformations harder than it should be. However, I've used it to great success both in production and research contexts and its scientific packages are very powerful and expansive.

Swift

I've used Swift to produce iOS and WatchOS applications, as well as implementing some audio processing CLI tools. It has many lanaguage features that I enjoy using, such as pattern matching and optionals. It's developed a fair amount since I used it last, so I may have some catching up to do to get up to speed on the latest features.

Stuff I'm Exploring

  • Go

    • Interested in using it to replace Node.js for lighter server/middleware tasks
    • Static typing + ease of concurrent/parallel execution
    • Benefits of compilation
      • Much higher performance ceiling
      • Ships statically linked binary, so no additional runtime requirements

  • OCaml

    • I want to learn more about purer functional style, without diving to Haskell
    • Its type system is as rich, or richer, than Rust's
    • Has garbage collection to remove the mental overhead of managing lifetimes in Rust
      • Looks like solid compliment when absolute performance isn't required

  • Applied Machine Learning

    • Speech to text
      • Tested Mozilla's Deepspeech and OpenAI's Whisper
        • Found OpenAI's offering to be significantly more aligned with my requirements, given fairly limited testing
        • Exploring wrapping it into a tool to help me transcribe and manage my audio notes
    • Stable Diffusion
      • I'm not a great artist, so having a tool that lets me approximate the image in my brain has been fantastic
      • It makes for good test art with my eInk displays
    • Large language models
      • My current interest lies in leveraging an LLM as a frontend against a backing knowledge base
      • E.g Documentation explorer, Wikipedia assistant
    • Vector databases
      • Exploring uses for vector encodings for efficient information retrieval