[racket] Finndesign Liitin: Computing rethought

Hi all,

after about a decade's development work, we (Finndesign) are about to
release something that we feel very exited about. It's a network OS called
Liitin and it uses Scheme (Racket) as built-in language. BTW, Liitin means
'connector' in Finnish and is pronounced like "Lee tin".

Rational:
There are lots of great free software and snippets out there, but due to
incompatibilities and overall complexity to setup a working environment,
they are often out of the reach of most of us. Or it's just not worth the
trouble. Often data disappears or keeps changing without warning, so
eventhough you know it's out there, it's an unsure and tedios task to
actually utilize it (let alone to build something on top of it).

Liitin tries to address these problems with some of its key principles:
- The environment is kept static and uniform, so when you create an object,
anybody else can use it instantly without worrying about compatibility.
- Development and dynamicy is done by Liitin objects. You can create an
infinite number of objects and use and share them on the fly. That is,
object are located in a global database, and you can refer to any object
directly without requiring a different set of libraries case by case
(provided that these functions are placed into Liitin once, naturally :).
- Liitin objects can be anything (data, functions, GUI...), and - thanks to
Eli Barzilay's help - you can use them just like Scheme's built-in objects.
For example:
  (gaia:fibonacci 10) >> 55   i.e. user Gaia has created a public object
fibonacci.
  (mirko:eliza "i feel like singing") >> "do you often feel like singing"
  (liitin:script-manager) >> opens a new window that manages scripts
  (liitin:object-properties 'gaia:fibonacci) >> opens the source code of the
object for viewing/editing
- Each user has his own namespace, so eventhough you can view/execute/modify
all public objects as you like, you can only do so within your own
namespace. Private objects are also available.
- Persistency is enforced, so that any object ever saved/published, is
always accessible thereafter.
- You can choose whether to call the latest version of the object, or any
earlier version.
- Updates are instant; the author updates the object once and everybody else
will receive the latest version the next time they call the object.
- Best of all, there's nothing to setup, just log into Liitin

There are many potential ways to utilize Liitin, such as:
- Personal desktop
- innovating new functions or combining existing ones into something new
(visual programming and hardware control on the roadmap)
- Educational usage: teaching, learning, research, final thesis...
- collaborating work: use all the power of existing effort and work on new
projects simultaneously around the globe.
- Building ontologies with built-in functionality (~semantic web)
...
>> Consider accumulating not only the knowledge of humankind but also
methods (instantly at hand :)

The main goal is not to build the fastest system out there, but rather an
enabler. Instead of weeks of work, you can create something in hours or
minutes. Instead of not having something done at all, you can and feel like
having it done.

A lot still needs to be done but we already have a prototype running the
basic functionality. Before passing this into hands of a wider audience
(incl. non-schemers), we would be anctious to hear how you like this kind of
idea?  I could also provide a limited number of test accounts over Internet
to allow first hand experience (preferably core Racket developers at this
point). For test account requests, please email me directly.

So, how does this sound to you?
Possibilities, limitations, threats, questions, ideas? Cool/ not cool?

br, jukka


|  J U K K A   T U O M I N E N
|  m a n a g i n g   d i r e c t o r  M. A.
|
|  Finndesign  Kauppiaankatu 13, FI-00160 Helsinki, Finland
|  mobile +358 50 5666290
|  jukka.tuominen at finndesign.fi  www.finndesign.fi