Introduction and misc ideas
Sun Jun 2 02:10:02 2002
This is my first post to the Tunes list, so I will try to introduce myself:
I am a french junior software engineer with a background in Java,
Dynamic web pages and recently perl.
Software development is time consuming so I don't have a deep culture in
the research fields.
I try to do my best : my bookshelves are full of docs on different
languages, and recently I read SICP and
a book on Knowledge representation by J.F Sowa. I also had some fun
playing with Haskell and Squeak...
If I understand correctly Tunes is more a place to discuss ideas on
Computing than a development project
stricly speaking. So I just would like to join the party and bring my
dreams on the table. Please excuse
my poor english. Interested people can email me in French. If I get
enough motivation (and encouragements),
I will probably create a web site to describe my project. Let's start..
(And I apologize for the length of the mail, I am probably bad at
The Facts I see everywhere :
Everybody knows them. The software industry is a nigthmare :
Development is hard, takes too much time and still fail too many times.
People's time get lost at learning tools that do not work well and get
updated too often,
at trying to understand existing code and application,
at doing low level work like search/replace changes, optimization and
documentation of hopelessly bad designed code,
or tracing huge amounts of code looking for bugs...
Some organizations have learned to chosen to live with the bugs and
Some people are paid by large companies to patch data inconsistencies in
databases on a regular basis.
As a result IT people have no time listening to their users and
customers, and working software
when it finally exist often does not answer to people's needs.
Needs I feel :
Software should be more efficient and resilient.
Software systems should be smaller and simpler.
It sould be easier to understand how it works (or doesn't).
It sould be easier to modify and test the modification.
It sould be more flexible : It should work on any hardware, with any UI type
It should be easy to reuse modules of existing software.
The more consistent the system are, the better the people could work and
- A unified system (like squeak) seems to be more efficient
for the same complexity and to encourage reuse.
- In order to make the main concepts of the system easy to understand,
be taken from everyday life. They could be :
* A World model (an ontology) defining and organizing all objects and
* Entities (People and computers) able to communicate
* Protocols/Language describing how entities communicate
* Tasks to be performed : (Data manipulation like calculus or search,
concrete action like cdrom ejection, tape rewind,
or communications between entities)
To build a successful system on this base, a community of developpers
must be created.
These community will have to work closer than most of previous
community, as they will work
in the same code base. It can only succeed if the system design make it
easy to understand what
the other's code do. Basically it should be make hard to implement the
same functionality twice.
The existing code should be extended/ refactored/ improved instead. I
don't know if the ST squeak project
would scale well as it is.
IHMO communication is a real problem in IT, and lots of improvements are
to gained on this point.
So my dream system should make it easy for new programmers to understand
So my idea will probably sound very limited to people doing formal
research. Powerful abstraction
could obviously be available but I don't expect everyone to use them (at
least currently, year 2002..)
The idea I would like to follow is to build application by creating
functional models :
- common model of Computing domain (users = people, networks = others
computers, data stored as files..)
This will provide both a data model for usual objects and provide a
structure in which the
available tasks could be referenced.
- models of the application domain ( example for a CD library application: )
CD = Artist, Title, Editor, Date, songs index, Songs are 16bits/44Khz
audio data with title)
Format (8/12cm), Data Track yes/no, cover picture, comments...
-> The storage data model should be derived from this. This should be
the only requirement
to get data persistence.
- Descriptions of the tasks provided by the application (Add new entry,
Edit entry, Delete Entry,
Mark as borrowed by someone, Remind me of the CDs I should get back...)
- Description of the user interface, in a generic manner :
What function goes into the main menu, what are the different contexts
and what functions are associated with them.
How do the different elements (menus, CD lists) do look ?
-> This abstract description of the interface could be use to produce
an actual GUI program
or dynamic web pages, or a GUI adapted to a PDA screen, in a generic way.
I have spend a lot of time on the web looking for similar work. If you
have any pointers to give me
(papers or code), I will gratefully appreciate it.
I fear that the previous description sounds like a L4G. But a L4G is
limited mostly because the framework
is proprietary and fixed. With an open, united system, it will be
possible for advanced programmers to
contribute to the framework if they need to.
My main concern in the design is how to encourage all users to use
existing code instead
of rewriting equivalent functionality. I am playing with the idea of
organizing all code
inside an ontology. To use a software module, one would not identify the
module to use, but
instead describe the functional task needed.
If multiple algorithms were available for the same task, the system
could choose among them according
to some criteria (performance, memory usage...).
I stop there. My email is too long already. If what I say already
exists, please do send me some references...