NetNews Usenet Archive 1992 #16/NN_1992_16.iso/spool/comp/lang/ada/2234

Text File | 1992-07-30 | 3.5 KB | 68 lines

Newsgroups: comp.lang.ada
Path: sparky!uunet!ftpbox!mothost!lmpsbbs!mcil.comm.mot.com!davidk
From: [e-mail] (David Kramer)
Subject: Re: Review of "Ada & C++: A Business Case Analysis
Organization: Motorola Communications Israel Ltd., Tel Aviv
Distribution: usa
Date: Thu, 30 Jul 1992 08:42:43 GMT
Message-ID: <[e-mail]>
References: <[e-mail]> <[e-mail]> <[e-mail]> <[e-mail]>
Sender: [e-mail] (David Kramer)
Nntp-Posting-Host: 145.9.71.22
Lines: 54

In article <[e-mail]>, [e-mail] (Matthew Jones) writes:
|> C (and C++) is not an operating system, real time or other. There are many
|> real time operating systems available, usually tied to the hardware
|> (ie VxWorks or OS9 for the 68k family...). This way seems much more sensible
|> to me than the Ada "we can solve everyones real time requirements on
|> all hardware with one paradigm."
If you have something against the Ada implementation you are always free
to use direct system service calls to the operating system just like
you do in C. Meanwhile there are projects that have used Ada tasking
very successfully, and have thereby left the option open to port
their application to some new super-chip in the future without major
changes to their application.

But the main point I wanted to make is that currently you can't implement
a distributed C++ application (whether real-time or not) with the compilers
of today without significant effort.

|>                                  Also you might consider that many
|> people have found the Ada tasking model to be implemented very
|> poorly by the Ada vendors.
This is very unfortunate. However, there are vendors that *have* implemented
tasking properly. When purchasing any item you have to be sure to buy the
product that satisfies your requirements. Ada compilers are no different.

|>                              Finally you might consider that Unix
|> (and the myriad of real time knockoffs) have plenty of (real time)
|> interprocess features and since C is often developed for some sort of
|> Unix (or real time) box there is a default standard of sorts.
Ada tasking is a real-time paradigm. Unix is not a real-time OS, it is
a multi-user (hence multi-process) OS - there is a very big difference.
As far as I know, although there are a couple of companies that have
extended unix for real-time, there is no default standard. And it is
certainly true that the vast majority of real-time applications are
not written for those unix extensions.

|>                            exceptions can cause errors by making the structure
|> of the code more complicated, because exceptions are kind of like a nonlocal goto
|> (Exception handling reminds me of the use of the Unix C library function setlj,
|> in terms of lodgic flow).
To the contrary, I believe that Ada exception handling makes the code less
complicated. The logic flow is simple - if there's something wrong - break out
of this block and handle it. It is better than a goto because the exception
handler is always in the same place (at the end of the block of code).
In my opinion setting some flag that triggers termination of some loop is
a sloppier implementation.

|>                                       Also I think a POSIX real time
|> extensions standard will benefit everyone, C and Ada a like.

I fully agree.

--
[  David Kramer    INTERNET: [e-mail]  ]