## My Projects

These projects are generally ordered by when I made them, from newest to oldest. Since I've mainly been teaching myself to code, the code in some of the newer projects might be a little better put together than in the older ones. I seem to tend to work on projects which are visual in some way, and that perhaps have some kind of chaotic behavior.

## A Few Projects on the Wolfram Community Page

Here are three recent projects I posted to the Wolfram Research community page, a program for visualizing the effect of wells on lake levels in Wisconsin, a project involving finding the shortest program that leads to each integer, and a project involving finding patterns in the evolution of a certain type of system called “combinators.”

## Cellular Automaton Tiles

A Dr. Paul Harrison has found a way to make universal cellular automaton tiles, here. His tiles can emulate any of the 256 elementary cellular automaton. I, however, found a smaller set of tiles with a smaller number of types of sides that emulates just rule 110. And it's prettier ;-) Here are some images of some tiles I printed out on magnetic paper and put on my refrigerator:

Here is a link to the source code for a project I am working on which will allow one to play around with the tiles on a computer. Eventually I am thinking of making it into a mobile app.

https://github.com/esopsis/Rule110Tiles

And here is the vector graphics file with which one can print their own tiles out on magnetic paper with a regular inkjet printer (office supply stores often carry it.) I recommend opening the file with a vector graphics program like Inkskape. You can also arrange the tiles using that program, but it's not QUITE the same as my own Python program I don't think ;-)

## Invented Font

This program is designed for coding and decoding the roman alphabet into and out of a character set I made up. My characters are all made up of either one or two of a set of four different character parts which can be combined in different ways to get a total of 30 new characters. Here's the translator in action:

And here's a familiar English phrase I wrote with the characters by hand:

Here's the code for the translator:

https://github.com/esopsis/Ericbic

## Base Infinity

Base 2 has 2 symbols, base 10 has 10 symbols, so, logically, base infinity has an infinite number of symbols, one for each non-negative integer. Here is a video showing an interpretation of base infinity that I made:

And here is some code I used for making these symbols:

https://github.com/esopsis/BaseInfinity

## Cannibalistic Explodey Guys

Here's a video of a simple "mindless fun" kind of "game" I made. You click on a guy and he explodes, then his little friends come and eat him. Exciting.

And here's the code:

https://github.com/esopsis/ExplodeyGuys

## Physical Cyclic Tag System

Here is a program for creating “Rube Goldberg” style contraptions consisting of balls, levers, ramps, and ropes. One advantage this program might have over others is that the balls move in discrete jumps, so one can more easily get the behavior one desires, possibly without having to go through as much trial and error.

I made this program primarily to show how it would be possible to make a “physical” system which emulates a kind of simple program called a cyclic tag system. This idea was first presented by Stephen Wolfram in his book A New Kind of Science, but without an actual implementation. Below is an implementation of system d on NKS page 96. See pages 96 and 895 at the NKS book link for more information.

Here is the code:

https://github.com/esopsis/CyclicTag

## Binary Evaluator

Here are a couple of programs which simply turn a binary sequence into a series of left and right turns. In the first case, if two paths would overlap, the program shifts over and begins drawing again. In the second case, the program attempts to avoid hitting itself, in such a way that different binary sequences always produce a different pattern (not necessarily the case in the first program.) Both are working with the first 123 digits of pi.

Here's the code:

https://github.com/esopsis/BinaryEvaluator

## Self Avoiding Hexagonal Branching

Here's a program I wrote which starts with a single branch and continues drawing branches at the ends of each previous branch. Going clockwise, branches are added except when a branch would collide with the end of an existing branch . I came up with this one while doodling in class. It made an interesting pattern on paper, so I implemented it on the computer. This is one of the first programs I wrote in Mathematica, but I also wrote a Python version before that.

Here's the code in Python:

https://github.com/esopsis/Branchles

And here's a demonstration I posted, using Mathematica (the code can be found on this page):

http://demonstrations.wolfram.com/SelfAvoidingHexagonalBranching/

Here's a program which interprets the evolution of a rule 110 cellular automaton as a bunch of different colored triangle-oid shapes. A randomizing element runs slowly from right to left on the screen, to keep the evolution from dying down.

Here's the code:

https://github.com/esopsis/CAColorRandomizer

## Reversible CA

Here's a program which runs a reversible cellular automaton, Wolfram's Rule 37R. The program colors three different kinds of patterns in the overall pattern in different colors, to help visualize them better. A second version draws borders between these patterns. The code is a modified version of a program by Kwanghyun Pek.

Here's the code:

https://github.com/esopsis/ReversibleCA

## The Beginnings of a 4D Battle Tank Game

Here are two programs, one which takes 2D slices of a 3D terrain, and one which takes 4D slices of a 3D terrain. I intend to make these into some kind of battle tank game eventually.

Here's the code for both: https://github.com/esopsis/3DSlicer https://github.com/esopsis/4DSlicer

The 4D version uses code from a tutorial from nehe.gamedev.net, namely lesson 34 which shows how to make a 3D terrain from a shaded 2D bitmap.

## Word Frequency Sorter

Finally, here's a simple project which just takes both a list of words, and a list of expected word frequences, and puts the words in order of how much more, or less, they are found in the first list as compared with the second list of expected values.

https://github.com/esopsis/RelativeWordFrequencies