My Code

This page is for my projects both in-progress and completed.

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.

 

Scheme Meta-Circular Evaluator

A meta-circular evaluator based loosely on the design in chapter 4 of SICP. This was mainly an experiment to see how much can be removed from the core language and pushed into libraries. The answer was to cheat and implement a method of writing macros in the implementation language (Chicken).

 

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.

 

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.

Comment

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s