Re: Embedded Keynote Speaker Mentions Ada

["Warren W. Gay VE3WWG" <ve3wwg@cogeco.ca>]

Benjamin Ketcham wrote:
> In article <upt4emx9k.fsf@no.email.thanks.invalid> Anders wrote:
>>"Warren W. Gay VE3WWG" <ve3wwg@cogeco.ca> writes:
>>>Benjamin Ketcham wrote:
>>>
>>>>How long does someone who actually knows Ada (not me) think it
>>>>would take to translate the kernel to Ada?
>>>
>>>I think this process is the wrong way to put something into
>>>Ada. Ada can be made to look like a C program, but I don't
>>>see any benefit to that.
>>>
>>>Only by redesign, in Ada terms (not C ones), does such a
>>>project have any useful outcome. For this you toss away
>>>the C code, and design from the requirements.  And what
>>>I am suggesting is that you don't need the Linux kernel
>>>to dictate your requirements.
..
>>Couldn't a useful outcome be the learning process that 
 >>comes out of a study where you rewrite a piece of code

A personal learning project is certainly one goal that
a person could aspire to. I am not knocking that.

    - but -

The discussion beforehand suggested to me that the
"useful outcome" was to arrive at a kernel rewritten
in Ada. This implies more than a personal learning
venture. After all, why arrive at a completely
rewritten kernel and keep it to yourself (or keep
a secret).

Therefore, the "useful outcome" seems to imply a
result that can be used by the interested public.

 >>in Ada, first as a so called line-by-line translation
 >>and then as a programming project where you do it from
 >>the requirements?

Most people that have worked with Ada longer than one
semester will tell you that this is bad advice.

This is just my opinion, but I think many others
on this list will second it: if you do a line-by-line
coversion of Linux in Ada, nobody but yourself will
use it. Why?

   1. Linux/UNIX people will hate it because its Ada
   2. Ada people will hate it because it looks and
      smells like C (and will not enjoy the most of
      the Ada benefits).

Will Lisp people embrace it? I doubt it ;-)

The bottom line is why do the job twice?

>>The first mentioned step will certainly raise a bunch 
 >>of questions about the differences between the
 >>[programming language] way and the Ada way. The
 >>questions are then answered while doing the second step.

Designing something from scratch will definitely raise
enough questions of its own. You don't need a line-by
line conversion to raise the right questions.

Where I see the existing kernel providing value is in
answering questions like:

  - How'd they do that? On Intel? On PA-RISC? MIPS?
  - What design trade-offs did they make on this point?
  - How well do those trade-offs work in practice?
  - VM handling (Linux/*BSD/etc.)

By designing from requirements, you are not stuck
re-implementing things the same "as they did". You
can pick and choose from all available sources, not
just one.

> But there's another benefit I'd expect in addition to the "polemic"
> benefit.  That is, I suspect there would be real interest in an Ada Linux
> kernel (or other familiar, high-popularity software item: a version
> of, or competitor to, Apache would have a very similar effect, IMO),

I didn't rule out an Ada POSIX-like platform, which is what
you seem to be implying. If there is enough enthusiasm
for that I welcome it - bring it on. OTOH, there is no
reason to not look at the lessons learned from UNIX, and
design something newer (this move is bolder, but may
provide some chance of appeal).

> from many quarters where reliability is perceived to be especially
> important.  

Definitely, but Ada that in C terms won't provide those
benefits.

> If there are real benefits to Ada, they should apply even for a "dumb"
> rewrite.  

I don't think many will agree with this. There may in fact
be more hinderances than advantages.

> If there are only benefits given a ground-up redesign,
> without even matching the same "API" as an existing program, then
> are these benefits really due to Ada, or just due to generic software
> engineering, and the obvious fact that almost anything can be improved
> by a redesign? 

Let's try this another way. You live in a house, apartment or hut,
right? You win the lottery and you get the chance now to
rebuild. Would you build exactly the same house, but with
materials from a different vendor? I don't think so.

You intimately know all of the faults and weaknesses of your
current home. Given the change, you would eliminate them
with a redesign rather than build them all again. If you
had low water pressure before, you'll take steps like using
larger pipes the next time around.

Chances are your new home will look completely different too.
Who wants to rebuild something that looks the same as the
40 year old styled house you lived in before?

Who wants to use the new O/S in exactly the same way they
were used 15 years ago?

I see many reasons to put the same effort into new design
than mimic existing ones.

The most important thing however is to learn from other
works and projects. This requires research (experience
also helps). The status quo is not the answer for new
development unless it has been generally agreed that
the technology has reached perfection in design, but
is lacking in implementation. I don't think we have
that yet.

>>The Linux kernel is of course a too big piece for such a project.
> 
> Obviously I disagree here.  

I agree with both of you on this one ;-)

It will be too big for some people, and not for others. I don't
think I have the energy or the time to consider such a project,
though there is much internal enthusiasm in my mind for it.

However, with the right mix and teamwork, it is possible for
something to be achieved. The biggest challenge as I see it
is that you have to draw from a smaller community of
Ada developers, unless you can enlist and experience others
in Ada95 (that can't happen overnight).

> know or care.  If a whole kernel, or webserver etc., is written in Ada,
> it opens up potential exposure to and interest in the language, to
> a much bigger world of programmers.  And the opportunity to directly
> compare performance and reliability between the Ada and C versions,
> seems seductive to me.  Are people afraid of that comparison?
> 
>>Anders

Projects like AWS and others are doing their part in this
direction.

For an Ada O/S, I would suggest starting with an existing
microkernel, and build on top of that. Once you achieve some
level of critical-mass, you can then start replacing things
underneath the hood as time goes on. I believe there are
a number of sources available for existing microkernels, in
varying levels of maturity.
-- 
Warren W. Gay VE3WWG
http://home.cogeco.ca/~ve3wwg