Blog 4

This page features brief overviews for my projects both in-progress and completed. For more detailed information, including code, checkout my GitHub.

Pointless Programming Reference

The Pointless Programming Reference is a programming language reference document that expresses programming concepts and their implementation in a number of languages.

It currently features 1,875 solutions to 400 common programming tasks in 7 languages*.

Go there now and check it out!

Lispy – A Simple Scheme-like Interpreter in C

****************************************
**         _   _                      **
**        | | (_)________  _          **
**        | |_| (_-< _ | || |         **
**        |___|_/__/ __/ _, |         **
**                 |_|  |__/          **
**           Version 0.01             **
**                                    **
** Use ctrl-c to exit                 **
****************************************

Lispy is a very simple Scheme-like interpreter with support for Python-like comprehensions and polymorphic basic procedures.  The main goal of Lispy is to provide a simple implementation that illustrates the concepts behind programming language constructs without focusing at all on efficiency or error handling.

Lispy is not RnRS compatible and it never will be.  Though it takes a lot from Scheme it also mixes in features from other languages that make it incompatible.  Lispy is garbage collected and should be relatively stable, provided you input correct code.

Lispy comes with a test suite that can be used as a reference and is also featured in the Pointless Programming Reference.

pyTrade Stock Charting and Paper Trading

pyTrade is a stock charting program and portfolio management tool.

pyTrade provides a "Paper Trading Mode" to allow you to learn how to trade or
test new strategies.  The paper trading mode sends you back in time and lets
you buy or sell stocks.

pyTrade is currently pre-alpha software so expect bugs and changes. Screenshots here.

Lispy in Scheme

Lispy in Scheme serves two purposes. It is an implementation of Lispy in Scheme, as well as a step-by-step tutorial for creating an interpreter in the style of An Incremental Approach to Compiler Construction (pdf).

The interpreter created for the tutorial series is a general purpose interpreter that is suitable for building almost any Scheme-like language. The main purpose of this interpreter is to provide a platform to test the implementation of different language constructs.

Lispy in Scheme is part of the Lispy project. For now the code can be found in the Lispy git repo under the LiSpy folder. Lispy in Scheme is the future of the Lispy project, at some point in the future it will be broken off the Lispy in C project.

Scheme in Python

The Scheme in Python project is a port of the Lispy in Scheme project. The goal is to implement a small subset of Scheme as an interpreter written in Python.

There are a number of goals for this project. First, implementing Scheme in Scheme allowed us to "cheat" a bit by having access to the Scheme reader and data structures. Using Python as the implementation language will force us to code the reader by hand and create new data structures where there isn't a one-to-one mapping from Scheme to Python.

There are also two auxiliary goals to this project. Using Python should make this more accessible to programmers who are interested in language development, but are unfamiliar with Scheme. Also I'm using this project as a way to familiarize myself with branching and merging in git, so each post will correspond to a branch in the repository.

All the code for this project will be hosted on GitHub. The code is licensed under a BSD license if you are interested in forking it for any reason.

This series will focus on building a very simple interpreter for the purpose of learning the steps involved in building one. For this reason there will be no/very little error checking or optimization. This port will be slightly more complicated than Lispy in Scheme so if you are interested in an even simpler interpreter look here.

Evo

Evo is an evolutionary search based function optimizer. It provides an interface for defining new modules and functions as well as an evolutionary programming based method for optimizing those functions. Evo does not use the standard generational approach to GP, rather it uses “gene pools”, that contain functions of indefinite life, from which new functions can be evolved and tested one at a time.

When defining an Evo function you can choose to optimize it for speed, space or code length. Each function can have multiple gene pools that are each optimized for a different purpose. Using gene pools instead of a single population generational approach helps to avoid stagnation within the population as is a common occurrence with the standard generational model.

The original intent of Evo was to be coupled with Lispy to create a distributed self-optimizing program by example programming language. Evo and Lispy are both very ambitious projects for a single developer and I have not yet been able to finish them. Each project, however, is at least somewhat usable on its own and so I'm releasing them in hopes that someone else will become interested and contribute.

I will be writing more about Evo and will do some more development on it in the future. The Lispy project is currently eating the majority of my development time and until I have the chance to integrate the two projects I will likely be concentrating on Lispy.