Teaching new tricks to an old dog (C++ -->Ada)

[Turamnvia Suouriviaskimatta]

I 'm following various posting in "comp.lang. ada, comp.lang.c++ ,
comp.realtime, comp.software-eng" groups regarding selection of a
programming language of C, C++ or Ada for safety critical real-time
applications. The majority of expert/people recommend Ada for safety
critical real-time applications. I've many years of experience in C/C++ (and
Delphi) but no Ada knowledge.

May I ask if it is too difficult to move from C/C++ to Ada?
What is the best way of learning Ada for a C/C++ programmer?

"Falk Tannhäuser" <fa************ *@crf.canon.fr> wrote in message
news:d0******** **@s1.news.olea ne.net...

Perhaps the closest way you can get to this in C++ is

std::vector<foo _type> Data;
...
std::for_each(D ata.begin(), Data.end(), DoSomething);

where "DoSomethin g" evaluates to a so-called "function object"
having an "operator() " accepting a (reference to) "foo_type".

OK. Try this in straight C++.

type Index is range -800_000..12_000 _000;
type Decimal_Fractio n is digits 12 range -473.0 .. 2_000.0;

type Vector is array (Index range <>) of Decimal_Fractio n;

V1 : Vector ( -47..600); -- note the negative index range
V2 : Vector (-1.. 10); -- also a negative index range
V3 : Vector (42..451); -- index starts higher than zero;
............... ............... .

function Scan (The_Vector : Vector ; Scan_Value : Decimal_Fractio n )
return Natural;
-- This function can process any of those vector instances
without modification
............... ..............
-- possible implementation of the function
function Scan(The_Vector : Vector; Scan_Value : Decimal_Fractio n )
return Natrual is
Scan_Count : Natural := 0; -- Natual begins at zero
begin
for I in The_Vector'Rang e -- No way to index off the end array
parameter
loop
if The_Vector(I) = Scan_Value; -- looking for an
exact match
Scan_Count := Scan_Count + 1; -- increment the count
end if;
end loop;
return Scan_Count; -- return required; never an implicit
return
end Scan;
............... ............... ............... ........

I submit this in response to the observation someone made about the alleged
added
difficulty Ada imposes on the programmer in flexibility of expressiveness. In
my
own experience, Ada is far more expressive of a larger range of idioms than C++.
Note my use of the word "expressive ." We can express any idea in any language,
but some languages are more expressive of some ideas than others.

This is just one example of Ada's flexibility in managing arrays. I could fill
many pages with
more examples. Of interest, here, is how easy it is to have an array index
that begins at
a value other than zero, and how easy it is to create a function that will
accept any array
of any range defined for that index. Yes, I know you can do this in C++, but
from my
perspective, it is not nearly as easy, expressive, or readable.

Counter examples to expressiveness can be illustrated in C++. For example,
many
programmers prefer the += to the x := x + 1 syntax. This is a minor
convenience
compared to the final program in Ada.

Richard Riehle

Disclaimer: I did not compile the code
before submitting it so there
might be some minor
errors. RR

[Ioannis Vranos]

ad******@sbcglo bal.net wrote:

OK. Try this in straight C++.

type Index is range -800_000..12_000 _000;
type Decimal_Fractio n is digits 12 range -473.0 .. 2_000.0;

type Vector is array (Index range <>) of Decimal_Fractio n;

V1 : Vector ( -47..600); -- note the negative index range
V2 : Vector (-1.. 10); -- also a negative index range
V3 : Vector (42..451); -- index starts higher than zero;
............... ............... .

function Scan (The_Vector : Vector ; Scan_Value : Decimal_Fractio n )
return Natural;
-- This function can process any of those vector instances
without modification
............... ..............
-- possible implementation of the function
function Scan(The_Vector : Vector; Scan_Value : Decimal_Fractio n )
return Natrual is
Scan_Count : Natural := 0; -- Natual begins at zero
begin
for I in The_Vector'Rang e -- No way to index off the end array
parameter
loop
if The_Vector(I) = Scan_Value; -- looking for an
exact match
Scan_Count := Scan_Count + 1; -- increment the count
end if;
end loop;
return Scan_Count; -- return required; never an implicit
return
end Scan;
............... ............... ............... ........

I submit this in response to the observation someone made about the alleged
added
difficulty Ada imposes on the programmer in flexibility of expressiveness. In
my
own experience, Ada is far more expressive of a larger range of idioms than C++.
Note my use of the word "expressive ." We can express any idea in any language,
but some languages are more expressive of some ideas than others.

I think you mean something like:
#include <map>
#include <iostream>

int main()
{
using namespace std;

map<int, double> id;

id[-400]= 7.1;

id[-2500]= -1;

id[10]= 9;

id[-300]= 7.1;

unsigned counter= 0;

for(map<int, double>::const_ iterator p= id.begin(); p!=id.end(); ++p)
{
if(p->second== 7.1)
{
cout<<"7.1 was found at index "<<p->first<<"\n";

++counter;
}
}

cout<<"\n7.1 was found "<<counter< <" times in total.\n";
}
C:\c>temp
7.1 was found at index -400
7.1 was found at index -300

7.1 was found 2 times in total.

C:\c>
I think this is even faster than yours, which scans the entire range.
And a more elegant and with the same efficiency solution:
#include <map>
#include <iostream>
#include <algorithm>
class comp: public std::unary_func tion<std::pair< int, double>, bool>
{
const double searchValue;

public:

comp(const double value):searchVa lue(value) {}

bool operator() (const std::pair<int, double> &arg) const
{
if(arg.second== searchValue)
return true;

return false;
}
};

int main()
{
using namespace std;

map<int, double> id;

id[-400]= 7.1;

id[-2500]= -1;

id[10]= 9;

id[-300]= 7.1;

cout<<"\n7.1 was found "<<count_if(id. begin(), id.end(), comp(7.1))
<<" times in total.\n";
}
C:\c>temp

7.1 was found 2 times in total.

C:\c>


This is just one example of Ada's flexibility in managing arrays. I could fill
many pages with
more examples. Of interest, here, is how easy it is to have an array index
that begins at
a value other than zero, and how easy it is to create a function that will
accept any array
of any range defined for that index.

In C++ you can create whatever you want. Even a container with abstract
conceptual features (you are limited only by your imagination).

Yes, I know you can do this in C++, but
from my
perspective, it is not nearly as easy, expressive, or readable.

I think even better. That said, I like enough Ada too. :-)

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Wes Groleau]

ad******@sbcglo bal.net wrote:

Possibly. However, I have seen more than enough "hacked" Ada to wonder
whether, in the hands of the larger community, the unruly would still run amuck,
even with Ada as their language. Although the default for most constructs in

I don't know how much effort I've put into persuading colleagues
that an Ada access type and a C pointer are NOT always interchangeable .

Or how many times they turned a deaf ear to my recommendation to
think about a warning (that the source and target of an
unchecked_conve rsion instantiation were not the same size).

--
Wes Groleau

He that is good for making excuses, is seldom good for anything else.
-- Benjamin Franklin

[Larry Kilgallen]

In article <d1**********@a vnika.corp.mot. com>, Paul Dietz <pa**********@m otorola.com> writes:

ad******@sbcglo bal.net wrote:

Still, when we hold one development environment (an Ada compiler)
to a higher standard, we need to understand that difference when
making comparions. It costs a great deal more money to produce
a compiler that must pass validation (now conformity) than to
create one in which the defects are intended to be discovered
by the users and fixed in some future release.

If one has a copy of the validation test suite, why is it necessary
to wait for the users to find the bugs? Is it that you have to pay
for the cost of fixing the bugs that the users would never encounter?

One of the costs of fixing defects not reported by a user is the non-zero
probability that making a change will introduce additional defects.

Clearly that is unacceptable if the chance of some user discovering
the original defect can be proven to be zero.

It is required (someday) if the chance of some user discovering
the original defect can be proven to be one.

Unfortunately, most such probabilities lie somewhere in the vast middle.

[Georg Bauhaus]

Ioannis Vranos wrote:

ad******@sbcglo bal.net wrote:

OK. Try this in straight C++. type Index is range -800_000..12_000 _000;
type Decimal_Fractio n is digits 12 range -473.0 .. 2_000.0;

type Vector is array (Index range <>) of Decimal_Fractio n;

V1 : Vector ( -47..600); -- note the negative index range function Scan (The_Vector : Vector ; Scan_Value :
Decimal_Fractio n )
return Natural; for I in The_Vector'Rang e -- No way to index off the

I think you mean something like:
[redesigning the problem?]
map<int, double> id;

id[-400]= 7.1; for(map<int, double>::const_ iterator p= id.begin(); p!=id.end(); ++p) I think this is even faster than yours, which scans the entire range.
Hm. Searching a *map* of entries at numeric keys is different
from scanning an array of values and counting occurences. What
are you trying to do here?
The std::vector is missing an instantiation argument which adds
the guarantee that no index value is outside the range
-800_000..12_000 _000;
std::map<int, double> is a different beast entirely, with
unknown size. Consider Vector ( -47..600);

(How do you make a subrange of double, which is missing from
your example.)

Imagine an array shared between a number of threads. The program's
task is to count the number of occurences of a particular value
in the array. Examples:
1) A shop has 10 unique doors (use an enum). For each door 4 states
can be measured: open/closed, van/no van at the door.
2) A 5-player team, each team is identified by number drawn from a fixed
set of team numbers. An array (an array, not some other data
structure) measures the number of players from each team present in
a room. Count the number of odd-team players in a room.

I hope these example illustrate some points. They are not meant to
trigger a discussion as to whether an array is the best data
structure for everything. (Note that it might be necessary to read
values from the array/Vector using random access in O(1), and to
store and replace values in O(1), another reason to use an array.)

And a more elegant and with the same efficiency solution: A solution to a different problem, I think.

In C++ you can create whatever you want. Even a container with abstract
conceptual features (you are limited only by your imagination).

You can do that using assembly language or SmallTalk, whatever.
I think this was not the point, but I should have Richard Riehle's
message speak for itself.
For example, look here, and reconsider the programming task as
originally stated: Yes, I know you can do this in C++, but
from my
perspective, it is not nearly as easy, expressive, or readable.

Georg

"T Beck" <Tr********@Inf ineon.com> wrote in message
news:11******** **************@ g14g2000cwa.goo glegroups.com.. .

Adrien Plisson wrote:

Ada is also used in particular rockets called missiles, and its job
inside is just to make them fall... but fall gracefully.

Would that happen to include the now-infamous Patriot Missles (the ones
that couldn't hit a barn after they'd been on for a while due to a
bug?)

No. Those missiles were not programmed in Ada.

On the other hand, there have been software failures written
in Ada, just as their have been software failures written in C,
C++, Jovial, Fortran, etc.

The use of Ada does not eliminate to potential for software failure.
No language, by itself, can guarantee there will no defects. The
best we can hope for, in the current state of software engineering,
is to minimize the risk of failure.

Ada is designed to help reduce risk. That is a primary concern when
choosing Ada. Still, we are always dealing with tradeoffs.

A language that allows compilers to generate some kind of result for
every syntactic expression, is likely to also permit erroneous constructs.
This is OK when that language is used in the hands of a person who
never makes mistakes. Of course, as the size of the code grows
larger, and the number of functions increases, human comprehension
begins face more challenges in the management of the complexity.

A language that provides a set of constraints at the outset, such as
Ada, can be annoying for little programming jobs carried out by
one person. As the software product requires more and more
people, more and more code units, and more and more time to
complete, these constraints can be useful because they prohibit
certain practices that lead to unexpected errors.

Software risk management is becoming a more and more respectable
part of software engineering practice. Language choice is only one
part of the risk management decision matrix, and we are not going to
enumerate the many other facets of risk here. However, language
can have an impact on risk.

I have seen software developed in many different languages over a
long period of time. In my own view, and I don't have formal
research to support this, Ada has had value in reducing risk of
failure "when used as directed." C++, and the C family in general,
increases the risk of failure simply because one does not have the
built-in constraints that exist in Ada. A careful programmer can
create excellent, defect-reduced, software in C++. A sloppy
programmer can grind out horrible, unsafe code in Ada (by
relaxing the built-in constraints). All in all, though, I see Ada as
more risk averse than most of its competitors.

What is the cost of being risk averse? That question is open to many
different interpretations . There certainly is a cost. Is that cost worth
the level of risk avoidance we hope to achieve with Ada? The answer
to this question will also vary according to the experience, biases, and
economic decisions favored by those who must make the choices.

Richard Riehle

[Larry Kilgallen]

In article <jR************ ***@newssvr21.n ews.prodigy.com >, <ad******@sbcgl obal.net> writes:

A language that provides a set of constraints at the outset, such as
Ada, can be annoying for little programming jobs carried out by
one person. As the software product requires more and more
people, more and more code units, and more and more time to
complete, these constraints can be useful because they prohibit
certain practices that lead to unexpected errors.

I think there is another figure of merit which should be considered
along with the number of programmers -- the proximity of users to a
single programmer.

To support a hobby of mine, I will single-handedly program in TECO
macros (a strong competitor to APL in the write-only-programming race).
I am the only one who runs the program, and there is nowhere else
to point the finger if it fails.

But for real commercial code (one now at about 200,000 sloc), I use
Ada as a single-programmer, since I want my programming failures to
be evident on my computer, not that of the customer of my customer.

[fabio de francesco]

Ioannis Vranos wrote:

ad******@sbcglo bal.net wrote:

OK. Try this in straight C++. [skip Ada program]

I think you mean something like:
[skip C++ programs]
This is just one example of Ada's flexibility in managing arrays. I could fill many pages with
more examples. Of interest, here, is how easy it is to have an array index that begins at
a value other than zero, and how easy it is to create a function that will accept any array
of any range defined for that index.

In C++ you can create whatever you want. Even a container with

abstract conceptual features (you are limited only by your imagination).

Yes, I know you can do this in C++, but
from my
perspective, it is not nearly as easy, expressive, or readable.

I think even better. That said, I like enough Ada too. :-)

--
Ioannis Vranos

Ciao,

Ioannis wrote a C++ program that in his intentions would had operate
like the Ada code that was provided as an example of language
expressiveness.

Unfortunatelly that C++ code doesn't resembles the Ada one. Have a
closer look at what Richard wrote:

type Index is range -800_000..12_000 _000;
type Decimal_Fractio n is digits 12 range -473.0 .. 2_000.0;
type Vector is array (Index range <>) of Decimal_Fractio n;

V1 : Vector ( -47..600); -- note the negative index range
V2 : Vector (-1.. 10); -- also a negative index range
V3 : Vector (42..451); -- index starts higher than zero;

He instantiated three arrays that contain elements of type
Decimal_Fractio n, each of them is 12 or more digits in whatever machine
the program can compile and each variable of the type is checked to be
in range -473.0 .. 2_000.0.
Each single array has a different number of elements and no array with
more than 12_800_001 elements is permitted to be created.

Furthermore you used a tree (std::map<> is often implemented as a
red-black tree) to be read sequentially in searching the second
element. I don't think this is the most efficient way to implement what
it is better thought to be an array. I mean that if I always have to
read every element from the beginning to the end I would prefer to
insert them in a vector.

Now I remember that you wrote "This is faster than yours scanning the
entire range". Now I can be wrong, since I don't know either enough C++
and Ada too, but it seems that you scanned the entire range too. Is it
not true? Anyway I suppose that Richard attention was to array
declarations and not to function operating on them.

Regards,

fabio de francesco

[Ioannis Vranos]

Georg Bauhaus wrote:

Hm. Searching a *map* of entries at numeric keys is different
from scanning an array of values and counting occurences. What
are you trying to do here?

Just using the appropriate available container. :-)

The std::vector is missing an instantiation argument which adds
the guarantee that no index value is outside the range
-800_000..12_000 _000;

vector provides method at() that performs range checking. Also if you
want a vector that has signed integer subscripts or even floating point,
you can easily write one. However this does not "feel" C++ whose built
in arrays always store elements from index 0 and upwards.
std::map<int, double> is a different beast entirely, with
unknown size. Consider Vector ( -47..600);

(How do you make a subrange of double, which is missing from
your example.)
Do you mean like this?

#include <map>
#include <iostream>

int main()
{
using namespace std;

map<double, double> id;

id[-400.1]= 7.1;

id[-2500.6]= -1;

id[10.43]= 9;

id[-300.65]= 7.1;

unsigned counter= 0;

for(map<double, double>::const_ iterator p= id.begin(); p!=id.end(); ++p)
{
if(p->second== 7.1)
{
cout<<"7.1 was found at index "<<p->first<<"\n";

++counter;
}
}

cout<<"\n7.1 was found "<<counter< <" times in total.\n";
}
C:\c>temp
7.1 was found at index -400.1
7.1 was found at index -300.65

7.1 was found 2 times in total.

C:\c>

You can also check the entire range if you want. Here the previous style
along with your full-range (expensive) style:
#include <map>
#include <iostream>

int main()
{
using namespace std;

map<int, double> id;

id[-400]= 7.1;

id[-2500]= -1;

id[10]= 9;

id[-300]= 7.1;

unsigned counter= 0;

for(map<int, double>::const_ iterator p= id.begin(); p!=id.end(); ++p)
{
if(p->second== 7.1)
{
cout<<"7.1 was found at index "<<p->first<<"\n";

++counter;
}
}

cout<<"\n7.1 was found "<<counter< <" times in total.\n\n\n";
// Checks *each* range from -2500 to 10
counter=0;
for(int i= -2500; i<10; ++i)
{
if(id[i]== 7.1)
{
cout<<"7.1 was found at index "<<i<<"\n";

++counter;
}
}

cout<<"\n7.1 was found "<<counter< <" times in total.\n";
}
"for(int i= -2500; i<10; ++i)" can also be written as

for(int i= id.begin()->first; i<(--id.end())->first; ++i)

if you want this kind of abstraction. But better abstraction is the
iterator approach and the *best* the count family which (iterator and
count family) work with *all* containers.
These are bullet-proof code approaches.
Imagine an array shared between a number of threads. The program's
task is to count the number of occurences of a particular value
in the array. Examples:
1) A shop has 10 unique doors (use an enum).

We can use whatever I like, perhaps strings. What is wrong with "Door 1"
etc? :-)

For each door 4 states
can be measured: open/closed, van/no van at the door.

OK, this sounds easy. What do you think? Since you want an array:
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>

class Door
{
bool open, van;

public:
Door(){ open= van= true; }

bool IsOpen() const { return open; }
bool IsClosed() const { return !open; }
bool IsVan() const { return van; }
bool IsNoVan() const { return !van; }

Door &SetOpen() { open= true; return *this; }
Door &SetClosed() { open= false; return *this; }
Door &SetVan() { van= true; return *this; }
Door &SetNoVan() { van= false; return *this; }
};

class CheckOpen
{
bool open, van;

public:
CheckOpen(bool isopen, bool isvan):open(iso pen), van(isvan) {}

bool operator() (const Door &arg)
{
return open== arg.IsOpen() && van== arg.IsVan();
}
};
int main()
{
using namespace std;

vector<Door> doors(10);

doors[4].SetOpen().SetN oVan();

unsigned counter= count_if(doors. begin(), doors.end(),
CheckOpen(true, false));

cout<<"Counted "<<counter< <" occurrences.\n" ;
}
C:\c>temp
Counted 1 occurrences.

C:\c>

2) A 5-player team, each team is identified by number drawn from a fixed
set of team numbers. An array (an array, not some other data
structure) measures the number of players from each team present in
a room. Count the number of odd-team players in a room.

This is easy too. I do not get your point. This can be done with arrays
as also with other containers. Why should we be restricted to one type
of container?
I hope these example illustrate some points. They are not meant to
trigger a discussion as to whether an array is the best data
structure for everything. (Note that it might be necessary to read
values from the array/Vector using random access in O(1), and to
store and replace values in O(1), another reason to use an array.)

OK.

In C++ you can create whatever you want. Even a container with
abstract conceptual features (you are limited only by your imagination).

You can do that using assembly language or SmallTalk, whatever.
I think this was not the point, but I should have Richard Riehle's
message speak for itself.

I am not talking about assembly. It is not difficult to write a
container getting a signed integer as a subscript and have range checking.

For example, look here, and reconsider the programming task as
originally stated:

Yes, I know you can do this in C++, but
from my
perspective, it is not nearly as easy, expressive, or readable.

I think it is probably more and at least the same. That said, I like Ada
somewhat. :-)

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Ioannis Vranos]

fabio de francesco wrote:

Ciao,

Ioannis wrote a C++ program that in his intentions would had operate
like the Ada code that was provided as an example of language
expressiveness.

Unfortunatelly that C++ code doesn't resembles the Ada one. Have a
closer look at what Richard wrote:

type Index is range -800_000..12_000 _000;
type Decimal_Fractio n is digits 12 range -473.0 .. 2_000.0;
type Vector is array (Index range <>) of Decimal_Fractio n;

V1 : Vector ( -47..600); -- note the negative index range
V2 : Vector (-1.. 10); -- also a negative index range
V3 : Vector (42..451); -- index starts higher than zero;

It isn't difficult to implement a vector that accepts signed ranges too
*with* range-checking, the default ones begin from 0 because this is the
C++ natural feel. vector::at() performs range checked access.
#include <vector>
#include <exception>
#include <iostream>
int main() try
{
std::vector<int > vec(10);

vec.at(12)=4;
}

catch(std::exce ption &e)
{
std::cerr<<e.wh at()<<"\n";
}
C:\c>temp
invalid vector<T> subscript

C:\c>

In other words it does not make much sense to have signed indexes.
Otherwise it is easy and possible.

--
Ioannis Vranos

http://www23.brinkster.com/noicys