Projects

On this page are a few of my personal projects which I am both particularly proud of as well as think other people may find of interest. With that said, other projects of mine in addition to this found here can be located on my Github.

Programming Languages

Owlscript

Owlscript is my dynamically typed and lexically scoped, garbage collected scripting language developed with support for procedural and functional paradigms in mind. Some noteable features include dynamic object creation via struct types, an integrated list type with a plethora of supporting operations including map/sort/filter, as well as first class functions with lambda expressions and closures. Owlscript also sports first class strings with support for concatenation, interpolation, and regular expression matching.

This rich combination of features combine to result in a language that is both at once familiar, and also fresh and new. The following code samples highlight some of the features just mentioned.

                def fib(var n) {
                    if (n < 2) {
                        return 1;
                    } else {
                        return fib(n-1)+fib(n-2);
                    }
                }
                def main() {
                    let fibs := map([5,6,7,8,9], fib);
                    println fibs;
                    println filter(fibs, &(i) -> i % 2 == 0);
                    println first(fibs);
                    println rest(fibs);
                }

                max@thinkpad:~$ owlscript -f fib.owl
                [ 8, 13, 21, 34, 55 ]
                [ 8, 34]
                8
                [ 13, 21, 34, 55 ]
                max@thinkpad:~$
            

In addition to running scripts from files, Owlscript features an integrated read-eval-print loop (REPL) for interactive development sessions:

                max@thinkpad:~/owlscript$ owlscript
                 Owlscript(0)> let multiplyAndIncrement := &(i) -> 3*i+1;
                 Owlscript(1)> let count := 1;
                 Owlscript(2)> while (count < 10) { println multiplyAndIncrement(count); count := count + 1; }
                  4
                  7
                  10
                  13
                  16
                  19
                  22
                  25
                  28
                Owlscript(3)>
            

Owlscript is in continuous development and is constantly evolving. Its main purpose is to facilitate my personal exploration of compiler/interpreter implementation and programming language design. I am currently in the process of extending the tree walking interpreter to include a pcode compiler, though this is still in the early phases of development.

mgcLisp

What language geek hasn't implemented a lisp interpreter? After a long weekend spent at a friends lake house reading through The Structure And Interpretation of Computer Programs I decided it was time to give it another whack with this being the result of that effort. Anyone interested in implementing a lisp interpreter in C/C++ or similar language may find it of interest.

                max@MaxGorenLaptop:/mnt/c/Users/mgoren/Documents/GitHub/rlisp$ ./mgclisp
                  [mgclisp repl]
                  mgclisp(1)> (define fib (lambda (x) (if (< x 2) 1 (+ (fib (- x 1)) (fib (- x 2))))))
                   fib
                  mgclisp(2)> (fib 6)
                   13
                  mgclisp(3)> quit
                max@MaxGorenLaptop:/mnt/c/Users/mgoren/Documents/GitHub/rlisp$
            

Utilities

mgczip

Lossless data compression! mgczip supports compression using either huffman coding or LZW to compress and uncompress files. Depending on the algorithm chosen and the file being compressed, many files can be reduced in size by 40 - 50%.

                max@MaxGorenLaptop:/mnt/c/Users/mgoren/Documents/GitHub/ThompsonsConstruction$ mgczip -cl parser.hpp
                  Starting size: 6260 bytes
                  Ending   size: 2994 bytes
                  0.521725 compression ratio.
                max@MaxGorenLaptop:/mnt/c/Users/mgoren/Documents/GitHub/ThompsonsConstruction$ mgczip -ch parser.hpp
                  Starting size: 6260 bytes
                  Ending   size: 3349 bytes
                  0.465016 compression ratio.
                max@MaxGorenLaptop:/mnt/c/Users/mgoren/Documents/GitHub/ThompsonsConstruction$
            

In the above example, I compress the parser header for my regular expression engine. Using the LZW algorithm to compress the file results in 52% reduction in space. Huffman coding is then used on the same file and reaches a slightly less but still respectable 46% compression ratio.

CodeBlahger

CodeBlahger is my personal blogging platform/content management system and the application used to serve the site you are currently viewing! Not satisfied with the PHP based ecosystems of Drupal and Wordpress, not to mention the seemingly never ending security updates that accompanies a self-hosted instance of one, I decided to take matters into my own hands and created CodeBlahger.

I wanted to use a similar tech stack to what I use professionally as backend software engineer and so decided to develop CodeBlahger in Java using the Springboot framework and MySQL for the backend. The front end is rendered using the thymeleaf templating library and HTML5, CSS, and some light javascript. Being a backend developer by trade, creating CodeBlahgers layout took me far longer than id like to admit, but I'm happy with the result.

CodeBlahger features an integrated WYSIWYG editor for creating and editing blogposts, syntax highlighting on code examples, and comment moderation. Additionally, posts can be browsed by category as well as featuring full text search on all posts. Thanks to containerization via docker, deployment is a breeze. Once deployed, CodeBlahger requires remarkably few resources, able to run comfortably on a relatively low-spec VPS.

Data Structure & Algorithm Visualization

VizSort

Visualize the way different sorting algorithms move data during sorting to gain a deeper understanding of how they work! Developed in C++, VizSort depends on the SFML library for graphics rendering. With a wide selection of algorithms to choose from, its easy to become immersed in following the rearrangemnet of data, as if "peeling open" the algorithm to visually inspect how each algorithm works.

Binary Tree Visualizer

This is a simple tool developed in C++ using SFML to generate the images of the various types of binary search trees that I discuss in my posts. It was particularly useful when I decided to deep dive the various types of Red Black trees.