From: Georg Bauhaus on
On 26.05.10 10:55, Ludovic Brenta wrote:
> Yannick Duch�ne wrote on comp.lang.ada:
>> I've never seen [the Ada standard] in an other language than English
>> (my self, in the past, I though about doing a french translation,
>> bug gave up : too much work and time required for strictly no return
>> expected).
>
> I have a copy of the Ada 83 standard in French at home. A real
> collector's item :)

Is there a glossary in it, perhaps listing the "official"
translations of key terms?
From: Yannick Duchêne (Hibou57) on
Le Wed, 26 May 2010 11:24:42 +0200, Georg Bauhaus
<rm.dash-bauhaus(a)futureapps.de> a écrit:

> On 26.05.10 10:55, Ludovic Brenta wrote:
>> I have a copy of the Ada 83 standard in French at home. A real
>> collector's item :)
Sure “collector” is the properly matching word here :)

> Is there a glossary in it, perhaps listing the "official"
> translations of key terms?
If you interested in this, here is a list of such key term by key term
translation:
http://lglwww.epfl.ch/ada/glossaire/glossaire-v1.0.html

note: I don't agree with some of the translations, and this is not an
official translation, while may still be useful


--
There is even better than a pragma Assert: a SPARK --# check.
From: Georg Bauhaus on
On 26.05.10 09:24, Stephen Leake wrote:
> "J-P. Rosen" <rosen(a)adalog.fr> writes:
>
>> In most programming languages, there is a relation between the structure
>> of the language itself and the kind of data it handles best.
>
> This is certainly true.
>
>> For this reason, and others like ease of porting, it is generally a
>> good idea to write the compiler in its own language, safe for special
>> cases like initial bootstrapping.
>
> That does not follow. If I have a language designed for manipulating
> databases, that means is is _not_ a good language for implementing a
> compiler.

A database language may be compiled by itself if the program text
is suitably stored?
Notably, a compiler has tables, relational databases have tables;
when a compiler establishes a hierarchy (a tree), a hierachical
database does, too, a relational database uses ... relations.
Surely the "source text" will be easily processed if it reflects
the structural properties of the database---if it is stored as
relations. For example, when an Ada compiler marks a block such as
a loop with a name written by the programmer, or with an ad-hoc
name that it creates itself, then a database table of loops can
have those names, too. (And they would serve in unique keys.)
Similarly, the database can establish a "byte code table" for
executing a list of CRUD instructions...

Hmm... It might in fact be interesting to store program information
in tables. It is then possible to perform queries like "give me all
loops involving variables of a type in T'Class." ...
From: Yannick Duchêne (Hibou57) on
Le Wed, 26 May 2010 11:58:39 +0200, Georg Bauhaus
<rm.dash-bauhaus(a)futureapps.de> a écrit:
> Hmm... It might in fact be interesting to store program information
> in tables. It is then possible to perform queries like "give me all
> loops involving variables of a type in T'Class." ...
A dedicated ASIS program could be able to do that.

--
There is even better than a pragma Assert: a SPARK --# check.
From: Dmitry A. Kazakov on
On Wed, 26 May 2010 11:58:39 +0200, Georg Bauhaus wrote:

> A database language may be compiled by itself if the program text
> is suitably stored?

I think that is likely possible. Interestingly relational "languages" are
usually non Turing-complete. My wild guess is that it is the conversions to
a relational representation of the source code and the conversion of the
intermediate "relational" code to the machine code, which were impossible
to accomplish. No matter how trivial they might be in a language like Ada.

> Notably, a compiler has tables, relational databases have tables;
> when a compiler establishes a hierarchy (a tree), a hierachical
> database does, too, a relational database uses ... relations.

Any directed graph is a binary relation. So it is not an existential
problem, but it is a huge practical problem, because relational
representation are extremely poor with handling trees.

> Surely the "source text" will be easily processed if it reflects
> the structural properties of the database---if it is stored as
> relations. For example, when an Ada compiler marks a block such as
> a loop with a name written by the programmer, or with an ad-hoc
> name that it creates itself, then a database table of loops can
> have those names, too. (And they would serve in unique keys.)
> Similarly, the database can establish a "byte code table" for
> executing a list of CRUD instructions...
>
> Hmm... It might in fact be interesting to store program information
> in tables. It is then possible to perform queries like "give me all
> loops involving variables of a type in T'Class." ...

Due to total lack of abstractness relational representations require heavy
flattening, down to the lowest level. So it would be "give me the first
quark of the loop." Not very helpful.

--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de