/awesome

My own personal awesome list in a variety of topics.

Nate's Awesome List Awesome

My own personal awesome list in a variety of topics.

Software Engineering / Architecture

  • A Few Thoughts About Path Coverage

    • Some interesting thoughts on what it means for a code-base to really be thoroughly unit-tested.

  • Unit testing isn't enough. You need static typing too

    • An interesting case study showing the benefits of static typing. Also interesting to me is the fact of how the Python projects studied could essentially be translated more-or-less directly into Haskell -- there were not any dynamic typing idioms that the Haskell type system was "too restrictive" to handle.

  • 3 tribes of programming

    • Incredibly elucidating analysis of the cultural divides within the software engineering community. Also, explains why I really like Rust. :)

  • Sum Types are Not a Silver Bullet

    • This is something I wrote -- but I think it's an incredibly important lesson when trying to architect applications and systems in a functional style.

  • Abstraction: Not What You Think It Is

    • People in the software engineering community (especially in the context of object-oriented programming) often talk about code as being "too abstract" -- but is that really the issue? This post gives a fascinating analysis of the different things that people mean when they talk about "abstraction" in software engineering, and forces you to define your terms (and maybe ask others to define their ters) for clearer discussions.

  • No-code, no thought Substrates for simple programming for all

    • An interesting take on the "no/low code revolution" that will inspire you to think of ways to make your application more flexible and your capabilities for customization more discoverable -- or at least that's what I got out of it.

  • The future of software, the end of apps, and why UX designers should care about type theory

    • Applications of type theory? Democratization of software development? Making it easier to glue together functionality without a lot of boilerplate, rather than sandboxing everything into black-box "apps"? Yeah -- safe to say this hits a lot of "awesome" points in my book. Also, I feel like this is very similar in theme to the above post by Petricek.

  • Knowledge as Code

    • An interesting perspective on the advantages statically typed functional programming could have on your organization.

  • Execution in the Kingdom of Nouns

  • Developer tools can be magic. Instead, they collect dust

    • Why settle for lackluster developer tooling? This post has some excellent examples of innovative developer tooling that (unfortounately) are currently rather bitrotten, and has some discussion of why this is currently the case.

  • The Lost Elegance Of Computation

    • Interview with Conal Elliott, one of the progenitors of Functional Reactive Programming. Includes an explanation of his radical approach to software design based off of denotational semantics, thoughts on the current state of PL research, and his general philosophy of Computer Science.

  • Boundaries

    • Excellent talk on how to design your system to be testable.

  • Functional architecture: a definition

    • What is meant by functional design/architecture? Mark Seemann gives a simple, falsifiable definition.

  • A Modern Architecture for FP

    • Another approach to functional architecture.

  • Parse, don’t validate

    • An introduction to an idea I consider a core tenant of good functional design/architecture -- which is applicable across many different languages.

  • Functional Design and Architecture

Functional Programming

  • The Misunderstood Roots of FRP Can Save Programming
    • A bit of a grandiloquent title, but a fascinating read nevertheless. You'll learn about the roots of functional reactive programming, and see how many modern iterations of the idea (such as rxJava) are far removed from its roots. You'll also learn about "denotative programming", an alternative and somewhat more specific characterizaton of the "functional" and "declarative" paradigms. My favorite quote from it:

Denotative languages better convey the global structure of a program. We can fully understand an expression by its subexpressions, and their subexpressions, recursively. There are no spooky action-at-a-distance side-effects that can manipulate things from afar. We don’t have to read the entire codebase to ensure we understand a single piece; we must merely read its subexpressions, recursively. This allows us to quickly rule out what we do and do not need to read, saving us a lot of time in large codebases.

  • Another Look Through Optics

    • Really interesting perspective (and potential application) of profunctor optics by looking at them through the lens of the profunctors themselves.

  • Monadic profunctors for bidirectional programming

    • Another really interesting application of profunctors that I don't think has been fully explored.

  • Sum Types In SQL

    • Interesting ideas on how to encode functional data structures (such as sum types) in relational databases. This is also the only place I've seen that discusses application of normal forms in relational database theory in a wider context (functional programming).

UI/UX Design

  • 7 GUIs

    • Finally! An at least somewhat systematic approach to evaluating the various GUI toolkits out there. You can finally put your React/Angular debates to rest (haha, like that will ever happen).

      But in all seriousness, this is a fantastic approach -- and I honestly think that more projects in this strain to evaluate even more aspects of the different UI/UX frameworks, with potentially different criteria depending on your particular interest would be very helpful.

  • Slint (formerly SixtyFPS)

    • Like QML's older and better put together older brother. This is just a pleasure to work with. Embedded support too!

  • Monomer

    • Nice Elm-like way to build simple GUIs for Haskell.

  • Indigo

    • An Elm-like engine in Scala for pixel art games. A lot of interesting work has been done here on optimization. Functional indie game devs rejoice!

  • Reflex FRP

    • I don't know if this is my favorite GUI framework, and it's definitely not the easiest to use (whether or not it could be with more polish, I'm not sure) -- but just for the experience of learning it (like many people say about learning Haskell itself), I'd reccomend playing around with this. It will change the way you think about reactive programming and GUI development. I can say in my experience it has taught me how to use more mainstream frameworks like Kotlin flow more effectively.

  • Purescript Refract

    • An interesting variation on TEA (The Elm Architecture) making good use of lenses to compose components. Indigo does something similar.

  • Eve

    • A fascinating project testing the depths of how user-friendly we can make UI/App development. Fantastic DX/Debugging concepts and experience. Unfortountely the project was canned, but I can only hope future projects learn some of these same lessons.

  • Fudgets

    • Very early (perhaps the earliest?) approach to a truly functional approach to UI design, dating from the early 1990's.

CS Papers

Programming Languages

Research (Or just cool) Languages

  • Koka

    • Really innovative optimization (reuse analysis) that in many cases can convert functional style code to runtime-less C that mutates in place.

  • MarkovJunior

    • A language that somehow combines the work of Andrey Markov Jr. (think the Russian School of constructive mathematics), and (by way of a probabalistic interpretation of Markov Algorithms) Andrey Markov Sr. (Think Markov Networks, Hidden Markov Models). This is unbelievably nerdy cool. Also, look at those example gifs! If I don't use this some day (or something similar) for procedural generation of game worlds, I'll be dissapointed in myself.

  • Refal

    • A language nearly as old as Fortran and Lisp, built on a completely different paradigm (Markov Algorithms) than anything I've ever seen. Why does no one talk about this?

  • Ante

    • Very promising looking language which tries to bridge the gap bewtween low-level languages (like Rust) and high-level languages (like Haskell, OCaml). Has a very interesting memory management model -- looks to me kind of "like Rust, but less hand-to-hand combat with the borrow checker". Also has refinement types with type inference.

  • Flix

    • A proper Hindley-Milner ML for the JVM with logic programming capabilities and an effect system. Potentially of interest to Android devs as it can target earlier Java bytecode -- but I'm not sure what the FFI story with Java is like.

  • Genus

    • A language expounding upon the ideas of JavaGI.

Haskell

Kotlin

  • Kotest

    • Very nice testing framework for Kotlin, supporting everything from property-based to non-deterministic testing.

  • Arrow

    • Collection of utilities for functional programming in Kotlin -- including support for optics.

  • Http4k

    • Simple HTTP framework based on the idea of a server request/response handler as a function.

  • KotlinGrad

    • Type-safe automatic differentiation in Kotlin.

Rust

Math

Category Theory Papers

Math History

Urbanism

  • Large Scale, Small Scale
    • An interesting look into of the importance of relatively "large" urbanist buildings like locally-owned town hotels had historically in small towns, and why new construction like this might seem out of place today to NIMBYs. Hits close to home for me because the small town I currently live in had a small, locally-owned hotel just like this that regrettably closed during covid.