Introduction and misc ideas

[Cyril Hansen]

Hi all,

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 
summarizing things..)



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 
instability.
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 
communicate.



The ideas:

- 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, 
they must
  be taken from everyday life. They could be :

  * A World model (an ontology) defining and organizing all objects and 
concepts
  * 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 
existing code.
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 
of use
  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...

Regards,


Cyril Hansen