Hi all,
Here is a copy of Étoilé Technical Overview in its current shape, it
has been created to provide a specification for Étoilé underlying
foundation.
It's available encoded in UTF-8 inside Étoilé repository here :
<http://svn.gna.org/viewcvs/*checkout*/etoile/trunk/Etoile/
Documentation/Developer/EtoileTechnicalOverview.txt>
For convenience, I have also pasted the whole document below (the
markup is in restructuredText).
Feedback welcome :-)
=========================
Étoilé Technical Overview
=========================
Étoilé System Presentation
==========================
What We Want?
-------------
Apart everything… :-)
We already have:
- Stability
- Security
- Performance
But we would like also:
- Flexibility that would allow
- Transparent Distribution
- Components
Most of OSes widely distributed these days have ridiculous support
for such evolutions. They basically don't do the deal (when you
aren't considering only performance and stability at a lesser
extent), that means they don't provide interesting abstractions to
build a user environment… The two most important points:
- no reflexivity
- no unified domain/object space support or similar interaction model
support (everything is a black box)
Let's Write Yet Another OS
--------------------------
Hmm… No.
Writing OSes is a pain that involves a huge amount of problems:
- hardware support (drivers etc.)
- software support
- stability
- performance
The World Has Been Linuxed
--------------------------
Solutions:
- Hurd or similar
- Squeak
Well, no…
Let's start being realistic:
- That's impossible to fix
- What are the solutions?
The world has been linuxed, we have to deal with this fact until the
splashy comeback of Hurd & Smalltalk happens one day or never. We
must investigate an intermediate approach.
Very Rough System Classifications
---------------------------------
- Virtual Machine (Squeak is THE example)
- Monolithic system or kernel (that uses a two layers approach
between kernel space and user space)
- Composite or aggregated systems (that includes microkernels,
exokernels, programming languages as kernel or system etc.)
Return of the Black Box
-----------------------
VM, Kernel and Interpreter, when run in a layered manner, result most
of time in the same black box syndrom we encounter with other
applications.
The particularity of these systems is when you run one on top of
another one, the hosted system is always running in a black box. Most
of time, there is a one-to-one mapping between host system
'task' (taken in a very large sense) and the client system (relying
on the capacity of the host system to directly or not present itself
as virtual system). I say most of time because that wouldn't be true
for recent JVM (at a lesser extent, we could have similar objections
with dynamic language VM/Interpreters)
To summarize in the shortest manner, we could state the host system
is always acting like a virtual machine.
Make a Wish
-----------
Étoilé system should be quite different on this matter, because we
are set on a middle approach.
In more concrete words, Étoilé system is multiplexed with its host
system, most of tasks when they are run are mapped to host system
tasks and parts of Étoilé system components are mapped to host system
primitives. Because Étoilé are components are provided in separate
modules and relying on objects model, you can easily use inheritance
to tune performance of a basic Étoilé system, by adding support for
more host system primitives.
Étoilé Middle Way
-----------------
Eureka: Put a "virtual" microkernel on top of the host system.
Microkernel looks to be what we want, but they are usually put under
the main system (Linux on Mach or L4 are common examples) whether it
is monolithic or not. By doing the reverse, we obtain most of
microkernels benefits we need to build a really advanced desktop
environment, without its main downsides performance and hardware
support.
A virtual microkernel would be a microkernel stripped down to the
following facilities:
- name service
- messaging support
- task/thread API
Optionally we could include:
- persistency support (though storage is delegated to the host system)
Early Conclusion
----------------
If we build a light and relatively thin system layer which is easily
portable to many OSes and circumvents their most drastic limitations,
it is basically a win-win situation. A major problem will remain
though: OS integration. That's one of the point Linux Desktop has
failed to fix for many years, it's done yet, but it seems possible to
achieve now (look at FreeDesktop and Ubuntu, Mandriva distributions
for example, they are on this path).
Diving in the Virtual System
----------------------------
In what sense Étoilé is a system?
1. Virtual Operating System
Étoilé Virtual System is a very simple microkernel-like system
oriented with high-level features in mind rather than low-level
integration with hardware. It is written to be run on top of other
kernels or systems, unlike usual microkernels (which are able to host
monolithic kernels or systems as sandboxed servers).
2. Virtual Object System
- Everything is an object (Spring philosophy)
It is combined with a Virtual Object System (basically similar to
Spring domains, VFS in Plan 9 and Hurd or SoFS in SOPE), it is
powered by an object server ('name server' referencing, routing and
returning only objects).
Virtual Object System Inspiration
---------------------------------
A bit of history:
- UNIX -> Most of things are files (or mapped to)
- Plan 9 -> Everything is really file a this time (finally)!…
- Mach
- Hurd
- Vanguard -> Every servers is an object
- Spring -> Everything is an object (or mapped to)
Étoilé System Layers
--------------------
- We take care of:
- name server
- system messaging (IPC)
- daemons (start, restart, stop, monitor etc.)
- persistent data semantic (FS)
- host system interaction
- We delegate to host system:
- memory primitives
- task/thread primitives
- scheduling
- memory allocation
- drivers
Why uses GNUstep and not… ?
---------------------------
- Squeak (Smalltalk environment)
- No solid framework to develop applications with a graphical UI
- Probably one of the worst UI you can think of
- No roadmap or vision (the development process looks messy)
- Run in a complete black box (specially when you consider VM
relationship to the OS)
- Io (looks more promising than Smalltalk right now)
- Io environment (desktop + server)
- Flux (previously named Ion), Io AppKit inspired framework is
still quite limited and not in a really good shape right now
- API very unstable (though 1.0 release is approaching, things
should improve)
- No environment ecosystem with features like bundles, gpbs,
gdomap etc.
- Community smaller than GNUstep/Cocoa
- Not matching Objective-C in term of facility with OS integration
- No development environment (especially thinking about Gorm or
Interface Builder)
Note that Etoile was not created with the aim of "being a GNUstep
desktop" but rather, after looking to underlying solutions to
implement it, GNUstep looked like an obvious choice to start with.
The decision to base Étoilé on top of GNUstep is a question of
opportunity: GNUstep gives us excellent frameworks for dealing with
graphical and non graphical components, as well as distributed
objects. As such, Étoilé is for the moment mainly done in Objective-
C, but we expect in the future to work on even higher level
environment based on languages such as Io, Smalltalk, or Ruby.
Ultimately they are really strong points in favor of Io:
- Language itself
- Pure OpenGL backend for graphics
- Run on many platforms like Linux, Mac OS X, Windows etc. (yes,
Flux included)
- Moving forward quickly
- Growing community
Because of these points, Io will be supported and installed by
default on Étoilé.
Overriden GNUstep stuff (1)
---------------------------
Deprecated API in Foundation
- NSFileManager
- NSPipe
- NSFileHandle
- Parts of DO
- Services API
Compatibility will be kept with these APIs, but GNUstep software
relying won't be considered Étoilé native (and may not benefit from
all Étoilé features and transparent integration with native programs).
Migration path:
- NSFileManager -> CoreObject or WorkspaceKit (more featured API for
AppKit based applications)
- NSPipe, NSFileHandle, DO -> CoreObject
- Services API -> CoreObject and PickDropKit
Here is a memento about DO classes:
* NSDistantObject
* NSDistantObjectRequest
* NSDistributedLock
* NSDistributedNotificationCenter
* NSSocketPort
* NSSocketPortNameServer
* NSPort
* NSPortCoder
* NSPortMessage
* NSPortNameServer
* NSMessagePort
* NSMessagePortNameServer
Overriden GNUstep stuff (2)
---------------------------
Possibly deprecated or rather reworked API in Foundation:
- NSTask
- NSThread
Well, that's still to be considered. It would be to introduce a more
object oriented feeling (less Unix influenced).
Deprecated API in AppKit
- NSWorkspace (not initially ?)
- Few more to come like Pasteboard related stuff:
- NSServicesRequests
- NSInputServiceProvider
- NSEditor
- NSEditorRegistration
- NSDraggingDestination
- NSDraggingInfo
- NSDraggingSource
Migration path:
- NSWorkspace -> WorkspaceKit
- Pasteboard related API -> PickDropKit
Examples of Eventual CoreObject Tuning
--------------------------------------
To take two examples:
- ObjectServer could be replaced at system init by HurdObjectServer
(then Étoilé would use rather highly tuned Hurd name server for its
own purpose)
- InteractionDispatcher when Étoilé is run on DragonFlyBSD, could use
DragonFlyBSD messaging primitives with an object
InteractionIPIDispatcher
Quick Birdview of CoreObject
----------------------------
CoreObject and its object server should provide two fundamental
features:
- host system and Étoilé system interaction through a merged
representation (in term of domains)
- distribution support (based on our beloved Objective-C DO) between
- processes
- hosts
- languages
At a later point may be:
- orthogonal persistency in some cases
Note: Read CoreObject Presentation to learn more about it.
What's happen when Étoilé System starts up?
-------------------------------------------
Here is the sequence…
- Host system boots
Then either manually or automatically:
- Étoilé system server (aka etoile_system, init process taking care
of daemons/servers à la launchd) is started
Note 'root' privileges will be mandatory, at least initially. This
process is similar to Darwin launchd (by being both a kernel-like
init process and a daemonizer)
Any other servers is now started by etoile_system itself. At this
time, other Étoilé core servers are started in the following order:
- Security Server (aka etoile_securityServer)
- gdomap
- gdnc
- Object Server (aka etoile_objectServer)
- talk (aka etoile_talk, tailored command line playing the role of
the shell for the Object Server)
gdomap will probably have to be integrated in etoile_objectServer for
performance and code simplicity reason.
When the user wants a GUI environment, few other servers are started:
- Window Server (aka etoile_windowServer, which will be initially
nothing more than an X11 launcher)
- Azalea (X11 related WM, may evolve in future)
- Étoilé Identity UI Server (aka etoile_identityUIServer, security
helper in charge of the login window)
- Étoile System UI Server (aka etoile_systemUIServer, helper
providing various System UI panels not specific to a particular
service/application)
Next servers or services are now started with user privileges:
- gpbs
- Security UI Server (aka etoile_securityUIServer, helper that
handles various System UI panels, specially authentication panel for
AppKit processes when they need special authorizations without
raising their privileges)
- Shelf (aka etoile_shelf)
- Menu Server (aka etoile_menuServer)
- Workspace (aka Workspace or Openspace, playing the role of the
User File/Object Manager)
- User Session, surely ?
- Project Session, probably ?
Time to play now!
TalkCenter shell
----------------
TalkCenter is nothing more than a shell directly interfaced with
CoreObject and bundled with a set of tools to manipulate objects
referenced by the objects server or within TalkCenter child
processes. By default, it relies on Io language but would support in
fact any languages registered in the object server (that suppose the
corresponding CoreObject language bundle is installed on the system,
such bundle would provide a bridge specific to one language)
When you start Étoilé system without UI servers, the virtual system
starts and supposing your are in a Unix shell, you are immediately
offered TalkCenter prompt (the Étoilé shell). You won't quit this
shell until you exit Étoilé system itself.
That's in part why Étoilé is not a desktop environment but a user
environment. It uses would scale from text console to full GUI support.
That means TalkCenter application is mostly a GUI wrapper around
'talk' tool (as it is already the case with usual Unix and GUI-based
terminal application).
---
That's it.
Cheers,
Quentin.
--
Quentin Mathé
[EMAIL PROTECTED]
_______________________________________________
Etoile-dev mailing list
[email protected]
https://mail.gna.org/listinfo/etoile-dev
