Goal of this journal

While having kept another journal for some time, about problems and solutions, it is probably time to start a journal more specific about the implementation of SSIM-2.

At this point in time, I do have the following available :

- Simulation of certain simple system consisiting of :
- a 32-bit ISA
- A keyboard
- An output device
- A simple system front-end
- An assembler
- A basic software architecture consisting of
- A simple raw memory allocation and control layer
- A definition of basic data types
- Some higher level object factory and garbage collection
interface

What I will be starting on is the implementation of this library using assembler and the call conventions which should be generated by default from the compiler in the future.

The problem is a little bit the same as with Linux. Development consists of a binary image which can be loaded into memory and which takes over the complete system. Before it is finished there will probably be some changes along the way in the assembler, because it should be possible to add these predefined functions as parts of the Lisp symbol table (packages or obtable).

In the meantime, I have obtained some more experience with Common Lisp, and one of the things I learnt is that an image can be enhanced by loading the necessary packages and then dumping it. This obviates the problem of always initialising the standard version of Common Lisp used with the necessary packages.

This means that a development image can be set up which contains :

- a 32-bit ISA
- A keyboard
- An output device
- A simple system front-end
- An assembler

and that these can be accessed and used at will, while always returning to the CL REPL when finished. Ah, well, one problem remains, that is raw input and output must be enabled externally, and if this is done, then normal input is not available.

Currently the main purpose would be to read and assemble the system definitions, having the possibility to load them into the simulator, run them and have the possibility that the system itself formats and displays its output.

It would also be wise to have a standard procedure to rebuild the image when the definitions of the above building blocks change.

Introduction

This is my attempt at a public blog about a project that I basically started a couple of years ago. Publishing a blog, as far as I know, is like writing. I like to read a good written book, and I like to publish my ideas the same way. So this blog is an attempt to become a better writer, but also an attempt to get people interested in my project : designing and building a computer system and use an adapted Lisp as system language.

The things I currently have built are :

• A 32-bit ISA with 32 registers
• A simulator for the above ISA
• A Lisp like assembler
• Lots of documentation

I am currently busy on a compiler for an s-expression based language, which is to become the system language for the system. This language currently only supports 32-bit variables, no arrays and no structures.

When this compiler can be used to start writing system software which can be run on the simulator, it becomes time to learn FPGA design and buy a board which can accomodate the minimum things needed for implementing a computer system : keyboard, console, memory and storage. Using this, it should be possible to move from the simulator to a real, FPGA based, computer system.

And that describes somewhat the bounds of the project.