Kinetic: The console

For the past two years, only my “real life” friends have known about Kinetic. Now that I’ve put stuff online, I’ve started getting comments and emails from the greater population. This is quite neat!

Development on Kinetic is very stop-and-go for me. I typically only work on it when I have an extended break from the rest of my life (say, during Winter break, or otherwise slow quarters at school). I do spend most of the year thinking about the project, though.

Most recently I have been thinking about models for the shell. At this point in the game, the shell is not especially important. However, having some basic UI is quite useful for interacting with the operating system, which is vital for testing.

While I’ve started work on a GUI (with a driver for the VMWare graphics adapter), I’ve lately been thinking of dropping the GUI and focusing on a console-based shell instead. The advantages are clear:

  1. Takes less time to develop
  2. Does not require any particular graphics adapter
  3. Can be replaced with a GUI later if I need to

This isn’t really sophisticated stuff here.

I’ve got a kinda goofy idea for where to go from there. I was thinking about having a Haskell interpreter for a shell, where you browse packages instead of directories, and where files are just Haskell variables. From this perspective, programs are just functions, which naturally plays into the goal of having typed programs.

I know it’s not exactly brilliant, but it’s cute enough that I want to see how it works out.

Leave a comment


  1. Matthew

     /  4 September, 2007

    This is interesting. Filesystems invariably suck – the fact that a file is barely 2D and probably just 1D and directory structures are horribly limiting etc etc. It’s not a good situation.

    A file system should be a database. The haskell module system isn’t really very powerful – I’m sure you can come up with something a bit cooler than than. Have you looked at the NixOS stuff [] – they’re doing rather interesting stuff too. And of course, the “proofs” attached to java applets are an interesting comparison to the proofs you’re trying to extract from compilation of user programs.

  2. mgsloan

     /  4 September, 2007

    Definitely go for a haskell interpreter shell.

    This may be relevant:

    I would recommend something like a shell monad, which manages the state (buffer and history), and if you go with a traditional filesystem, current directory. So, basically the shell would be within an implicit ‘do’. It would be cool if it had some sugar for auto-lifting functions.

  3. guest

     /  4 September, 2007

    good idea to wait on the GUI, Xmonad would be a good reference though

    where is the source? or the image to run?
    how can other get involved?

Leave a Reply

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

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

Google+ photo

You are commenting using your Google+ 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 )


Connecting to %s

%d bloggers like this: