- My Setup
- Note Taking
- Some Things I Like
- Other Links
- My Mixed Opinion of LISP
- The infinite voxel editor and walking simulator in Common Lisp. Create and explore intricate procedural shapes that stretch on for hundreds of thousands of miles.
- Uses model-view-controller, flood fill, convolutions, vector algebra, frustum culling, and others.
- lem [Contributor]
- Find and fix some minor bugs, such as scrolling and job processing.
- Implement an interactive frontend that allows dragging to resize windows, double and triple clicking, and dragging and dropping files.
- Created a simplified version in the spirit of microemacs.
- Persistent key-value storage for Common Lisp objects.
- Create, Read, Update, Delete.
- Use either sqlite or a directory of files as storage.
- Optionally use transactions to make it faster.
- A tiered cache system for voxels.
- 3D array that can pin memory.
- An LRU cache.
- The disk, or database.
- I took a lot of notes over the years but they were scattered everywhere, across google docs, google keep, Samsung notes, evernote, apple notes, custom locations, and emails, so it became extremely difficult to reflect and review progress. This system consolidates all of it into a single file sorted by time.
- Makes extensive usage of timestamps as well as XML and HTML parsers.
- I fed the output file into GPT-2 which created an eerie caricature likeness of me. GPT-2 Also seems to have come up with some legitimate original ideas by remixing my own words, although most of it was less coherent.
- Prototype of a C parser in Common Lisp, that is generated from Lex and Yacc specifications. It is correct, but very slow.
- A job system.
- Similar to the API of Unity’s job system.
- Created because there were no Common Lisp job processing systems where the task itself was an object that could be queried or stopped.
- Implementation of the basic OpenGL functions and a thin layer that provides compatibility across GLSL versions and OpenGL versions.
- Similar in spirit to ANGLE. I have not checked the benchmarks.
- Compatibility layers created so many people could use sucle.
- GPU accelerated grid-of-characters user interface.
- Similar to alacritty, the GPU terminal emulator.
- Very dense data transfer to the GPU, each character is just 4 bytes.
- Compared to the naive polygon with texture and color attributes, which is 4 vertices with 2 texture coordinates each and 2 colors each.
- 128 bytes = 4*((sizeof(float) * 2) + (sizeof(float) * 3 * 2)). 128/4= 32 times less data transfer.
- A simple 3D collision system.
- 3D rasterization of lines.
- An object serializer and deserializer for Common Lisp.
- A simple implementation of the wavefunction collapse algorithm which is a constraint solving system used for n-dimensional texture synthesis.
- Extremely slow for voxels.
- Turns out procedural content generation is hard and requires a lot of compute, whether that be on the cloud or in the minds of many creators.
- Use the Telegram web API to poll for updates and send messages.
- cl-nbt [Fork]
- Add system to deal with
.mca files and make the algorithm simpler and more general.
- Solutions for the freeCodeCamp course.
- Markdown sprinkled with HTML.
- Uses Jekyll.
- lisp-in-small-pieces [Fork]
- A very tiny Turing complete language which is easy to extend and implement.
- Basic compiler from s-expressions to assembly using LLVM.
In i3, I’ll divide my desktops according to what task I’m doing.
Each desktop is split into two halves, and within each half is multiple i3-tabs.
- Desktop 1: Programming
- Left side tabs:
- Emacs running SLIME using SBCL
- Some Emacs buffers
- Right side tabs:
- Multiple Emacs buffers
- Dekstop 2: Note taking
- Left side tabs:
- Right side tabs:
- Desktop 3: Schoolwork
- School website
- Desktop 4: other
- Drag files from pcmanfm on the left side to the right side where there is:
- Open the terminal from pcmanfm on the left side, upon which the terminal is moved to the right side.
- Edit code on the right and on the left:
- Test the code in the REPL
- Look up libraries/documentation/algorithms for the code
When putting the computer to sleep I open a random terminal and put it to sleep. I rarely ever turn my computer off, last time I checked it was on for 60 days straight.
After testing many different systems and services, struggling, and looking up what systems others used, I converged upon the system I use currently:
- One-off notes/graphical: Pen, copy paper, and clipboard.
- Try to write the date on the paper.
- Put the paper in a dedicated pile when finished.
- Paper is scanned later with a portable scanner or phone camera.
- Whenever a random thought strikes me
- Open my phone and type it in.
- Google Keep is currently the least evil service.
- Evernote has this wacky HTML/XML format that I had to write a custom printer for.
- Samsung notes and Apple notes are the most evil. Vendor Lock-In, no easy way to export. Dealing with these was extremely tedious.
- Longer more in-depth ideas: pcmanfm, SmartGit, Emacs, SBCL, SLIME, local-time
- A single file called
linear.lisp. It is alternating
local-time:timestamp objects and Common Lisp objects. The
local-time:timestamp objects delineate the boundaries of each note. Usually there is just a single string between
- When adding a new note, run
(local-time:now) in the REPL, paste the result at the end, and create a new string following it.
Using Google Keep:
- Download google archive with Keep notes
- Run it through KeepToText
- Run it through the custom
notes system I created that integrates it with my other notes.
Some things I like:
My mixed opinion of LISP
LISP is not economically or socially viable because it is the most rapid prototyping language available.
It is indispensable if you:
- Enjoy programming itself
- Have a unique problem at hand with limited computing power.
LISP is the essence of unbridled individualism.
I, being an American, was raised on rugged individualism. Thus, LISP appeals to me and it saddens me that this cherished art is dying.