[E-devel] A new E17 module called emu.

[David S. <on...@gm...>]

After a somewhat heated debate in #edevelop yesterday, I decided to
start writing my first E17 code, a module that I like to call emu.  Emu
will be developed in two, maybe three stages.  While I may be
duplicating, or at least appear to be duplicating, some effort, raster
seemed to think stage one was a good idea, and that's good enough for
me.

Emu will eventually be a generic scriptable E17 module who's purpose in
life is to allow people to write E17 modules in whatever random
programming language they like.  Emu supplies all the E17 gooey
goodness, and the random programming language supplies the backend
logic.

The first version will just be an interface to arbitrary e menus, using
a brain dead, god awful, just off the top of my head text based
stdin/stdout protocol. The second version may use a better protocol
and/or a better IPC method. The final version will use a well thought
out IPC protocol to all things moduly.

Last night, during TV commercial breaks, I made a start.  The boss is
currently on my back to get some work done, so I will not be doing emu
stuff quickly for the moment.

Some issues that I would like more experienced E17 hackers to help me
with have arisen though.  So I will now commence to ask stupid
questions.

Current plans are to start with stdin/stdout and forking the random
programming language program as the IPC method.  Since I am trying to
support random programming languages a lowest common denominator IPC
approach seems more feasible than an ever expanding set of language
bindings approach.  Unix philosophy is that you should write small,
generic single job only things that use stdin/stdout to talk to other
such things, thus it is the lowest common denominator.  With this
approach, I don't have to care what random programming language is used
as the backend, they can all be forked, and handle stdin/stdout.

Someone suggested that I should use the built in ecore IPC to start
with and be done with it.  I know nothing about ecore, this little
project of mine is the start of my E17 learning exercise.  Can ecore IPC
be used with random programming languages, or are individual language
bindings required?

Then there is my big unanswered question.  How to pass the command used
to start the random programming language backend to emu?  Or maybe do
it the other way around, backend starts/finds emu then starts talking
to it.  At the moment, I have no clue.  Can modules have an arbitrary
string config element?  Will ecore IPC be the way to go?

Then there are the multiple copies of the same module running at the
same time issues that I know nothing about.  To be useful, emu will
have to cater for that.