In software I can control everything about my development environment. I can make tools that have a compounding effect on my ability. I can simulate physics, chemistry, biology, all the natural sciences, and and I can test hundreds of thousands of solutions to problems on massively parallel architecture. I can instantly remix work that others have done, rapidly iterate upon designs, and I can collaborate with large groups of people from all across the world. I can create content and services at scale and present it to millions of users for a couple bucks a month. And I can do it all while being thousands of miles away from my cloud provider.

I like solving the kind of problems that don’t have clear answers. I place intuition above rationality.

My favorite language is Clojure, it is a Lisp, and is also my strongest language.

Here is what Clojure looks like:

  (defn raytrace [this elements]
    (lazy-seq
     (cons rayorigin
           (let [[closest distance-to] (get-closest this elements)]
             (if (infinite? distance-to) [(second (rayproject this 400))]
                 (let [[V0 V1] (rayproject this distance-to)]
                   (trace (->Ray V1 (reflect raynormal (normal closest V1)))
                          elements)))))))

Why I like Clojure

I feel powerful behind a Clojure interpreter because the language is defined entirely by how I choose to use it. I don’t feel the same with Python or Typescript. Lisp lets you think outside the box. It gives you complete freedom. As far as specifics go, Clojure has:

• A REPL (not a python REPL, a real Lisp REPL): allows interactive code development, and eliminates the perpetual halt->edit->restart cycle. You can edit programs while they are running.
• Declarative Code: immutability means your program has no state. It’s a perceptual shift from representing variables as volatile containers existing in the time domain, to representing them as fixed points in a cause and effect pipeline.
• Macros/Homoiconicity: the crown jewel and major distinguishing factor of Lisp. Every other lispy feature can be adopted in [insert x language here]. In Lisp, code is data is code. It is the defining feature.

In my opinion, the reason why lisp is largely unused, is because the language gives people too much freedom. Languages with a lot of structure, like Python, Rust, Java, etc, allow people to think the same way and collaborate easily. There is a clear ‘right’ and ‘wrong’ way to do things. With lisp, ‘right’ and ‘wrong’ becomes more of an aesthetic preference. Collaboration becomes a lot harder, as there’s no one right way to do things. Iterating on software becomes more of a challenge. It is worth noting that there are also hundreds of dialects of lisp. Paul graham has what I consider to be a really incredible take on this topic. If you’ve gotten this far, you should probably read it.

I also like these things:

• Replacing the global financial system with software that nobody controls.
• Rich Hickey’s talks
• George Hotz’s streams
• Mathematical Optimization & Heuristic Search Algorithms (like genetic programming)
• 3D Printing & CAD

Blockchains are sovereign entities that transcend the state. I think they are one of the most defining inventions of our lifetimes:

How I made this site:

• I use hugo to generate static content from .md files.
• I use a theme called cactus, which has generously been provided for free.
• I host this site on AWS for pennies.
• To update it, I run $ git push

Written and Maintained by George Mourginakis

trbetr.zbhetvanxvf@tznvy.pbz (My ✉️ in rot13)

• My Github
• My Cults3D Profile, for 3D printables.
• My Artstation, I make digital art sometimes.
• My NFTs, I collect NFTs as well (sometimes)