Ada's core attributes

8.20: web.adda/ada/predefined attributes:
. what are Ada's reserved attributes?
here they are renamed for clarification
(these are just the most basic ones;
there are many more for floats, etc):
type'base  -- the unconstrained subtype;
enum in type'first .. type'last,
A'range(N) =  A'first(n) .. A'last(n) -- array's nth dimension;
type'value(enumcode number or image string);
type'image(value) is a string;
type'code(value) -- the integer representing the value (aka pos);
type'codebitsize -- obj's fixed size (when packed);
rec.component'codebitoffset;
type'imagesize -- #characters(for largest expression);
type'++(value) -- successor;
type'--(value) -- predecessor .

obj'c categories and Ada's hierarchical pkg

8.14: adda/oop/obj'c categories and ada hierarchical libs:
reviewing:
2012-01-31 Objective-C Categories
1.20: adda/type/obj'c categories:
. Apple is using the obj'c Category for MVC separation;*
eg, string has many uses in a command-line interface,
so it exists in the core package without any methods for
drawing on a gui;
categories are then simply extending that string type,
instead of having sublclasses reuse that string type
in yet another type;
so just one type can exist
yet with  relevant parts in different packages .
* see { Buck, Yacktman}`Cocoa Design Patterns

todo:
. isn't that use of categories needed only because
the designers were assuming certain requirements
that are demanded only by the current oop model?

. if your string wants to express gui-specific tricks
such as appearing in a particular font,
or being arranged so as to follow a curve,
that need should be served by the use of a drawing record
which then has a string as one of it's parts .
(ie, it's ok to have 2 different classes !)
--
. a main point of the book"design patterns

was to critique oop's use of subclassing;
and, that criticism might apply equally well
to this use of categories;
but, generally, categories do have a good purpose:
they allow separate compilation of class extensions
without having to recompile the original interface
which might then require a recompile of
all the clients of that interface .

. this reminds of Ada's hierarchical libraries,
in Ada you can reuse oldlib's module
with the syntax:
package oldlib.additionalmethods
(by including oldlib's name like that
within your new package's name,
your new package includes the binaries of oldlib ).
. now current clients of oldlib
still don't have additional methods,
but, future clients of oldlib.additionalmethods
will have access to both modules
with that one import .
. obj'c categories by contrast,
allow you to add the same new modules
but this addition will also be affecting
current clients!
-- the category's method has access only to
the target's interface, not its internals;
so, a category can't fix every bug;
yet it can create bugs because it can
override system methods .

. I have 2 competing ideas on this:
# we should be able to describe in adda
any idea of any other language;
vs,
# we should not be supporting the use of ideas
that are either complicating or insecure .

here's how the the Category idea might be impl'd:
. when a datataype agrees to be modified by categories;
then at run-time, the type mgt is a modifiable object
and, it provides a dictionary
where you can see if it supports a message .
. it can dynamically add entries to this dictionary
(allowing it to support new messages),
and it can change method addresses
(allowing it to update the methods of old messages).
[10.8:
. now all we need is an uncomplicated way to
decide which types are so modifiable .
. perhaps a type wishing to participate
could declare one of its components to be
a dictionary with a standard name
(perhaps SEL, in honor of Obj'C);
then anytime a message is unrecognized,
the run-time would check SEL for the method .
11.8: correction:
. in order to work like an obj'c category,
it has to check SEL all the time,
not just when a message is unrecognized,
in case one of its methods got overridden .]

parasail is big win for reliable concurrency

12.7.2: news.adda/co/ParaSail
(Parallel Spec and Impl Lang) is by Ada's Tucker Taft:

first siting of parasail:
11/09/11 Language Lessons: Where New
Parallel Developments Fit Into Your Toolkit

By John Moore for Intelligence In Software
The rise of multicore processors and programmable GPUs
has sparked a wave of developments in
parallel programming languages.
Developers seeking to exploit multicore and manycore systems
-- potentially thousands of processors --
now have more options at their disposal.
Parallel languages making moves of late
include the SEJITS of University of California, Berkeley;
The Khronos Group’s OpenCL;
the recently open-sourced Cilk Plus;
and the newly created ParaSail language.
Developers may encounter these languages directly,
though the wider community will most likely find them
embedded within higher-level languages.

. ParaSail incorporates formal methods such as
preconditions and post-conditions,
which are enforced by the compiler.
In another nod to secure, safety-critical systems,

translating Cocoa's obj'c to Ada's concurrency

1.24: adda/co/translating Cocoa's obj'c to Ada's concurrency:
. Hillegass's mac book has an inspiring section on concurrency .
summary:
the key to no race conditions is no indirect use of
shared modified variables;
anything done with the Cocoa libraries
should get exec'd as a msg sent to the main thread .

. adda needs a way to know when a function is
calling something that is not thread safe,
ie, not only can it not be allowed to modify non-locals,
it can't even call anyting that would modify a non-local
-- or even read a non-local if there's a chance that
some other thread might modify it .
. or else,
it can put mutexes around code doing the reading;
or, it can put shared globals in ada's protected var,
getting all requests by queue
and putting all outputs on a temp pointer provided by caller:
eg, "( this is one of the pointers on my mailbox,
it will be reserved for your response;
I will check it for non-nil until I find something ).

modulus vs remainder

2.7, 2.16: Using the mod() function with negative numbers
"modulo" as a relation:
[pointing in the same direction on a clock]
any two numbers a and b are congruent modulo m
if (a - b) is a multiple of m.
. math's idea of "integer division":
x . . . . : 2.7, -2.7
floor(x) .: 2.0, -3.0
ceiling(x): 3.0, -2.0 .

. for both mod (modulus) and rem (remainder),
they are related to div by:
A = ( A DIV B ) * B + A % B
where % is either { rem, mod };
. {mod, rem} are similar in that
they are both consistent with a div function;
but mod's div truncates towards -∞ (negative infinity);
whereas, rem's div truncates towards zero .
. mod(-n, d) -- vs rem -- is the complement
of mod(n, d); eg,
MOD(-340,60)= 20
MOD(340,60)= 40
(40 and 20 are complementary modulo 60;
ie, 40+20 = 60).
. truncating toward -∞ (negative infinity)
means that if n (the numerator) is negative;
then the usual integer div needs to be decremented:
div = int(n/d)-1
-- so that the truncation is consistent by
always reducing the value instead of
changing it willy-nilly towards nil
(that'd be adding value when truncating negatives
while subtracting value when truncating positives).

Ada's "mod" (modulus) and "rem" (remainder):
. notice that while Ada supports both {mod, rem}
it has only rem-consistent div (truncate toward zero)
ie, observing the identity (-A)/B = -(A/B) = A/(-B)
for A,B in positives .
by contrast, Python truncates toward -infinity .
. here is Python's mod-consistent div ( % means mod )
. 123 / 10 = 12,  123 % 10 = 3
-123 / 10 = -13, -123 % 10 = 7
. 123 /-10 = -13, 123 % -10 = -7
-123 / -10 = 12, -123 % -10 = -3

translation from ada to c:
. ada's {rem, mod} is defined for (n,d) in Z
(integers, numerator and denominator can be negatives);
let c`% = abs(n) % abs(d):
-- (%) is c's symbol for remainder function --
then depending on the original signs of n,d,
use the following table to know whether to
{complement, negate} c`% .
-- complement (~) means abs(modulus) - x;
so for modulus = 5, the complement
of 1..4
is 4..1, respectively .
for rem:
. (n rem d)`sign = n`sign
details:
. when n,d are both positive,
or only d(modulus) is negative:
eg, 1...4 rem -5 = 1..4
or 1...4 rem 5 = 1..4
--> c`% .
. when n,d are both negative,
or only n is negative:
eg, -1...-4 rem -5 = -1 .. -4;
or -1...-4 rem 5 = -1..-4
--> -c`% .
for mod:
. (n mod d)`sign = d`sign;
if only n or only d is negative,
then complement .
details:
. when n,d are both positive:
eg, 1...4 mod 5 = 1..4
--> c`% .
. when n,d are both negative:
eg, -1...-4 mod -5 = -1 .. -4
--> -c`% .
. when only d(modulus) is negative:
eg, 1...4 mod -5 = -4..-1
--> -~c`% .
. when only n is negative:
eg, -1...-4 mod 5 = 4..1
--> ~c`% .

eiffel vs ada

11.10: adda/lang/eiffel vs ada
Tucker Taft:

. pre- and post-conditions can be
fairly easily and efficiently included in Ada code.
Invariants seem difficult to emulate directly in Ada.
If you're really interested in the
formal use of assertions with Ada,
maybe Anna is a solution for you.

. although I like the assertion stuff in Eiffel,
I think the language has a number of "inelegant" aspects.
For example:
# exception handlers only at
the top level of a routine,
with the only way to "handle" an exception
being by retrying the whole routine.
# No way to return from a routine in the middle.
This makes it a pain in the neck
to search through a list for something in a loop,
and then return immediately
when you find what you want.
(I have never found the addition of
extra boolean control variable
a help to the understanding of an algorithm.)
# Namespace control
handled by a separate sublanguage,
and no real higher level concept of
"module" or "subsystem."
An obscure notation like "!!" (construction).
being used for an important and frequent operation;
# No way to conveniently "use" another abstraction
without inheriting from it.
# No strong distinctions between
integer types used for array indexing.
# Using the same operator ":="
for both (aliasing) pointer assignment,
and for value assignment,
depending on whether the type is "expanded."
(Simula's solution was far preferable, IMHO).
-- And most critically:
# No separate interface for an abstraction.
You can view an interface by running a tool,
but this misses completely the importance of
having a physical module that represents the interface,
and acts as a contract between
the specifier or user of an abstraction
and its implementor.
In Eiffel, one might not even be truly aware
when one is changing the interface to an abstraction,
because there is no particular physical separation
between interface and implementation.
I consider many of the above problems quite serious,
with some of them being real throwbacks
to the old style of programming languages
where there were no well defined
interfaces or modules.
Hence,
I cringe a bit when people say
that Eiffel is the "most elegant" OOP
and that they would use it
if only it were practical to do so.
In many ways,
I think Ada is much better human-engineered than Eiffel,
with important things like range constraints
built into the language
in a way that makes them convenient to use.
Although general assertions are nice,
they don't give you the kind of
line-by-line consistency checks
that Ada can give you.
To summarize --
Although Eiffel certainly has a number of nice features,
I don't consider it ready for prime time
as far as building and maintaining large systems
with large numbers of programmers.
And from a human engineering point of view,
I think Ada is significantly better.

jhc0033:
Eiffel targets a largely similar audience of
"correctness-oriented" programmers that Ada does.
However, it took some digging around
(no introductions to the language mention it)
to discover that Eiffel has a gap in its type system.
Guess what, type theory is a branch of math,
and OOP is a spiritual following.
I know what takes precedence in my book.
The Eiffel community's attitude is basically:
"we'll just pretend 2+2=5 because we can
use it to justify some teachings".
Ludovic Brenta:
I evaluated Eiffel too when I read Bertrand Meyer's
Object-Oriented Software Construction book.
The two things I dislike the most about Eiffel
are the lack of range constraints on numeric types
and the fact that almost all contract checks
are deferred to run-time.
Helmut

- Ada has a built in concurrency model (like java)
and Eiffel does not.
In Eiffel there is SCOOP
(simple concurrent object oriented programming)
which tries to integrate concurrency into the language.
But there is not yet any Eiffel compiler available
which implementes SCOOP.
- Eiffel has "Design by Contract"
which is a very powerful mechanism to get your SW right.
Using assertions in your code appropriately,
you are able to catch a bug much closer to it's origin
than without DbC.
DbC opens up the road for a verifying compiler
(i.e. a compiler which can at compile time
verify if contracts are not broken).
I don't understand why the promotors of Eiffel
haven't made the language more complete
in terms of standardization,
standard libraries and concurrency.

Pascal Obry:

Ada even supports a Ravenscar profile
(where no dead-lock can occurs)
usable for high-critical systems.
1995 oop: programing by extension and dynamic dispatching
2005 oop: protected/tasking interface that can be inherited.

helmut:

The ECMA Eiffel language specification is a well written document
(it is a language specification document
and not a document for the Eiffel user).
It lacks only in the area of
void safety, initialization
and covariant redefinitions (catcalls).
The problem:
It has not been updated since june 2006.
I.e. it reflects a status which has never been implemented
(and will probably never be implemented,
not even by EiffelStudio).

Eiffel`author Bertrand Meyer provoked by Ada.

(Yannick Duchêne) a écrit :

I talk to him (back in 1990 or 1991) one time:
the Eiffel inventor hates Ada .

Adam:

. It appears that Meyer has some criticisms of Ada,
but I couldn't find anything that would indicate
that he hates it.
His Eiffel site has an article about the Ariane 5 crash,
but he said there that
the language couldn't really be blamed
because the problem could have been caught
using Ada's exception mechanism
if the programmers had used it properly.

lang's for supercomputer concurrency

adda/concurrency/lang's for supercomputer concurrency
7.27:
. the DARPA`HPCS program
(High Productivity Computing Systems)
is meant to tame the costs of HPC
(High Performance Computing)
-- HPC is the use of supercomputers for
simulations to solve problems in
chemistry, physics, ecology, sociology,
and esp'ly warfare .
. programmer productivity
means making it easier to develope
code that can make full use of
a supercomputer's concurrency .
. the main source of the cost
is a lack of smart software tools
that can turn science experts
into computer coders .
. toward this end, they are funding
the design of new concurrency lang's .
7.28:
. the DoD and DARPA already made
quite an investment in the
Ada concurrency lang',
a language designed for expressing
the sort of concurrency needed by
embedded system engineers; 7.31:
but, the software developer community
spurned Ada as soon as there was
something better ...
. pascal was popular before '85,
and when Ada arrived '83,
it was popular too;
then came the Visual version
of Basic (familiar and slick).
. the top demanded langs by year were:
'85: C, lisp, Ada, basic;
'95: v.basic, c++, C, lisp, Ada;
'05: Java, C, c++, perl, php,

. the only currently popular lang's
meant for exploiting multi-core cpu's
if not other forms of concurrency, are:
(3.0% rating) obj'c 2.0 (with blocks)
(0.6% rating) Go
(0.4% rating) Ada
7.29:
. whether or not Ada's concurrency model
is well-suited for supercomputers
as well as embedded systems,
it is not increasing coder'productivity .
. while Ada boosted productivity beyond
that offered by C,
it was nevertheless proven to do
less for productivity than Haskell .

HPC Productivity 2004/Kepner{ 2003(pdf), 2004(pdf) }:
. lang's were compared for
expressiveness vs performance:
. the goal of a high-performance lang'
is to have the expressiveness
of Matlab and Python,
with the performance of VHDL
(VHDL is a version of Ada for ASICs ).
. UPC (Unified Parallel C) and Co-array Fortran
are half way to high-productivity
merely by using PGAS
(Partitioned global address space)
rather than MPI
(Message Passing Interface).
. the older tool set: C, MPI, and openMP
is both slow and difficult to use .

. the 2 lang's that DARPA is banking on now
are Cray`Chapel, and IBM`X10 Java .
. they were also funding Sun`Fortress
until 2006,
which features a syntax like advanced math
-- the sort of greek that physics experts
are expected to appreciate .

golang's issue#9 -- clashes with go! -- revisited

10.7.30: news.adda/lang"go!/clash with go

. I was reminded of a name dispute
between Google and a language designer,
and couldn't remember the details;
I didn't know how it compared to
Microsoft denying Linux PC's
the name Lindows (mocking their name ?)
so I revisited the matter .

wiki's take needs an update:

"( On the day of the general release,
Francis McCabe, developer of the
Go! programming language,
requested a name change of Google's language
to prevent confusion with his language.)

. that is not quite accurate:
he claimed, point blank, that "(Go)
was exactly the name of his language,
and if you look on his personal filesharing website,
indeed, "(go) is the nickname;
but,
in both his whitepaper (pdf) and his book intro,
the published name is "(go!) not "(go):

Go!
– A Multi-paradigm Programming Language
for Implementing Multi-threaded Agents
K.L. Clark Dept. of Computing Imperial College London, UK
F.G. McCabe Fujistu Labs of America Sunnyvale CA, USA

. reading that paper,
you soon find why the name is "(go!)
-- and not go --
. the main purpose of go! is to
reverse some of prolog's faults;
. cleverly,
the reverse of "(go!) is (!og)
as in the "(log) of "(prolog)
which stands for (logic).

. the one thing he wishes most
would go away in prolog
is the "(!) operator (pronounced "(cut))
hence the name "(go!)
as in "(go away, Cut operator):

"( Go! has many features in common with Prolog,
particularly multi-threaded Prolog’s,
there are significant differences
related to transparency of code
and security.
Features of Prolog that mitigate against
transparency,
such as the infamous cut (!) primitive,
are absent from Go!.)

. meanwhile, the name of
google's go lang'
could be short for "(GOogle),
and is said to be a reference to
the design being motivated by
a need for compilers to go faster:

"( "In Google we spent so long
literally waiting for compilations,
even though we have parallelism
in all of these tools to help;
even incremental builds can be slow.
And we looked at this and realized
many of the reasons for that
are just fundamental to C and C++,
as were the tools that everybody used .
So we wanted to start from scratch .)

. wikipedia has this reference:

Google 'Go' Name Brings Accusations Of 'Evil'
InformationWeek Thomas Claburn November 11, 2009

"( McCabe's Go! programming language
is described in a 2007 book he published
and in a research paper published in 2004 (pdf)) .

McCabe:

"( It is in the tradition of
languages like Prolog.
In particular, my motivation was
bringing some of the discipline
of software engineering
to logic programming.)

. and *that*
is exactly the origin of the "(!)
-- an essential part of the name's genius --
so it's bewildering why he would
want to also claim the "(go) name
-- in addition to the "(go!) name .
some wikipedia authors speculate
that there could be some confusion,

"(McCabe requested a name change
to prevent confusion with his language, Go! .)

indeed, some have used "(yahoo!) as an example:

"( Comment 77 by wrinkles, Nov 11, 2009
Go and Go! are not the same? Great,
I just started a new company called Yahoo.)

you can't use "(Yahoo) as a noun
for something other than Yahoo!
without giving some context .
eg, hearing "(go!) might provoke
the question:
"( did you mean "(go faster),
or "(go away cut-operator) ?
) .]
. there's a link to to go's "(Issue 9) debate
where Frank McCabe wrote up an issue with Go:
"I have already used the name for
*MY* programming language."

all of McCabe's entries in Issue 9 to date:
"(

by fmccabe, Nov 10, 2009
I have been working on a programming language,
also called Go,
for the last 10 years.
There have been papers published on this
and I have a book.
I would appreciate it if
google changed the name of this language;
as I do not want to have to
change my language!

Comment 2 by fmccabe, Nov 10, 2009
If you google (sic) francis mccabe go
you will find some references.
I published the book on lulu.com

Comment 5 by fmccabe, Nov 10, 2009
My language is called Go!.
The book is called Let's Go!.
The issue is not whether or not Google's go
will be well known. It is one of fairness.

[7.31:
. if google throws a party for "(go)
they should invite "(go!),
to make sure in the future
people finding (go!) don't assume it's
some extension of google's (go) ? ]

Comment 300 by fmccabe, Nov 11, 2009
. I am very grateful for the
support I have received on this thread.
It seems to have hit a nerve.
. I want to make one particular point,
some people have suggested that
"I should be grateful"
for the extra advertising.
My response to that is that
I was not actively looking for this advertising.

[7.31:
. doesn't clarification require advertising
when there is such disagreement on
whether (go) clashes with (go!) ?
]

It was not me who picked a clashing name.
. I fully understand that it is possible that
insufficient search was done before hand.
However, when I picked the name Go!
I did try to find out if anyone else was using it.
In fact, I was kind of surprised that no one was!;
since it was clearly a great name.
. For those interested, Go! is a bi-lingual pun.

[7.30:
-- in Japan, where Prolog is very popular .
]

My previous work focused on a language called April.
In Japanese, the literal back-translation of April
is "4th Month".
Go is Japanese for 5.)

responses to McCabe's issue (verifying go! exists):

Comment 81 by yarkot1, Nov 11, 2009 [paraphrased]
'Go!' is available on sourceforge.net (networkagent),
and was developed jointly with McCabe and Clark
with commits back in 2000:
"A group of systems for building network-oriented intelligent agents,
consisting an agent communications infrastructure,
April - an agent construction programming language,
Go! - a logic programming language
and DialoX - an XML-based user interface engine".
[7.30:
. go! can be pronounced "(networkagent go)? ]

Comment 243 by andy.arvid, Nov 11, 2009
The Go! Source: homepage.mac.com
[redirects to nk11r10-homepage.mac.com]

april-9-30-07.tgz 2.3 MB
go-9-30-07.tgz 3.8 MB
InstallingGo.rtf 6 KB
ooio-9-30-07.tgz 821 KB

[7.30:
. see the problem here?
in some situ's (like unix) it's not wise*
to use the "(!) character in the name .
... could name it gol to look like (go!) ?
*: Characters you should not use in filenames:
| ; , ! @ # $ ( ) < > / \ " ' ` ~ { } [ ] = + & ^
. ]

Comment 454 by abraham.estrada, Nov 11, 2009
http://en.wikipedia.org/wiki/Go!_%28programming_language%29
[7.30:
. that link includes these resources:]

References
Clark, K.L.; McCabe, F.G. (2003).
"Go! for multi-threaded deliberative agents" .
International Conference on Autonomous Agents (AAMAS'03): 964–965.
Clark, K.L.; McCabe, F.G. (2006).
"Ontology oriented programming in go!" .
Applied Intelligence 24 (3): 189–204.
Further reading
Clark, K.L.; McCabe, F.G. (2003).
Ontology Oriented Programming in Go! .
Clark, K.L.; McCabe, F.G. (2004).
"Go!—A Multi-Paradigm Programming Language
for Implementing Multi-Threaded Agents" .
Annals of Mathematics and Artificial Intelligence 41 (2-4): 171–206. .

Comment 222 by keithsthompson, Nov 11, 2009
There's a Go! program on 99-bottles-of-beer.net;
it's been there since 2005.
That site is an excellent place to check for existing language names.

responses to McCabe's issue (resolution attempts):

Comment 6 by zhenshe41, Nov 10, 2009
In Go! , can the IDE know the differences between
Go! and go ?

Comment 40 by patla073, Nov 11, 2009
Why not just name it Golang?
Erlang - "Ericsson Language"
Golang - "Google Language"

Comment 64 by david.kitchen, Nov 11, 2009
@40 Golang looks like a winner...
they're already using the domain golang.org
and it looks like no-one else is using
that as a language name.

Comment 45 by tuxthelinuxdood, Nov 11, 2009 [paraphrased]
It is obvious that "do no evil" Google employees
did not research the name
in terms of existing languages before release.
[7.30:
. how is it obvious?
they could have easily seen C# vs C
as a precident for go vs go! .]

Comment 54 by pierrevm, Nov 11, 2009
First Closure (name-squatting Clojure)
now Go stopping Go! in its tracks.
Just another week in the life of a giant company. [...]

Comment 66 by yless42, Nov 11, 2009
[...]
. as you all rightly pointed out,
one is called "go"
and the other is called "Go!".
Am I the only person seeing the similarities
between that and "C" == "C#"?
If you think that having an extra character
is a problem,
you should go speak to Microsoft first.
[...]
. I suggest you see these lists:
wikipedia.org, esolangs.org .
. See how many languages there are on those lists
where one name is only separated from another name
by one character? [...]

Comment 70 by pygy79, Nov 11, 2009
@66 the spelling may be different,
but in both cases (Clojure and Go!),
the pronounciation of the
Google newly introduced products
is identical.
[7.30:
not identical in both cases:
. just as C# is pronounced c-sharp;
go! should be pronounced go-bang
or go-cut (prolog`cut-operator) .]

Comment 79 by rnmboon, Nov 11, 2009
They should change the name to "god".
Why hold back on the level of ambition here.

Comment 80 by j...@ww.com, Nov 11, 2009
Google should do the right thing
and change their name, be gracious about it.
. Do no evil, remember ?

Comment 89 by jamesda...@gmail.com, Nov 11, 2009
#77: Why not start a company called "Google!" ?

Comment 90 by AxelSanner, Nov 11, 2009
[wikipedia's don't be evil]
then ... don't
[7.30:
. that page tells about "(don't be evil) being
Google's "(informal corporate motto (or slogan));
the page states that in January 2010,

"(Apple CEO Steve Jobs strongly criticized the slogan,
saying: "We did not enter the search business.
They[Google] entered the phone business.
Make no mistake they want to kill the iPhone.)

-- and then he scoffs at "(don't be evil);
but, he might be just showing off
to shareholders . look:
. Google is in the phone business because
the phone is where much of the googling
could be coming from;
so, they just want to make sure
a mobile platform is out there .
. Apple still has a competitive product:
a phone running on the secure
mac microkernel with solid software
(I don't have a smartphone,
but my mac desktop is a lot more solid
than my linux laptop
-- the linux world scoffs at microkernels
for losing energy, but Ubuntu is more likely
to lose my data ... I need to
take the Android hint
and do more cloud computing!) .]

Comment 157 by mich...@sun-sol.com, Nov 11, 2009
They should name the language "Evil--"
(do no evil...).

Comment 161 by ropers, Nov 11, 2009
[...] appreciating the difference between
terms that merely sound
and terms that actually *are* identical. [...]

Comment 170 by tomhaste, Nov 11, 2009
Some of these comments are plain silly. Heres another to join in;
If Go isnt the same as Go!;
Then Google isnt the same as Google!.

Comment 212 by Mo6eeeB, Nov 11, 2009
[...]
"Go!" wouldn't work, because
the only way I can think
of audibly pronouncing the "!"
is "bang" and "Go bang"
just sounds silly.
[...]

Comment 219 by lozeno1982, Nov 11, 2009
To those who say "it's like C and C#"
or "it's like C and C++" etc...
No, it's not the same case.
. First, C# and C++ are called this way
because they inherited their {sintax, syntax}
from C
and wanted to express that kind of legacy;
Second, they are actually pronounced DIFFERENTLY:
it's "See" (C), "See-plus-plus" (C++)
and "See-Sharp" (C#).
. Now, how do you pronounce Go and Go! ?
I read them both the same way: "Go".
I can't read a "!" to make a difference.
[7.30:
. this reminds that the reason yahoo
spells their name with a "(!)
is to pronounce the word with enthusiasm;
literally to step up the octave
of the last syllable .]

Comment 255 by insomniac8400, Nov 11, 2009
Go and Go Bang
are as different as C and C Sharp.

Comment 274 by THM...@gmail.com, Nov 11, 2009
[...]
(C vs. C++, vs. C# anyone)).

Comment 312 by merkey88, Nov 11, 2009
This reminds me of an old court case
where Yahoo! had to change their name to the previously stated
from Yahoo (with no exclamation).
By contrast, your programming language
already has the exclamation point,
so as long as Google does not use
an exclamation after Go (or go),
there should be no reason to change.

Comment 382 by samterrell, Nov 11, 2009
[...]
If Wikipedia can deal with the issue,
[... GML, Go, Go!, GOAL, ...]

Comment 521 by darkhorn, Nov 12, 2009
[...] write a new language called "Google!".'
Comment 525 by ashish.afriend, Nov 12, 2009
@521: There are differences
in a language and a company.

Comment 563 by kikito, Nov 12, 2009
You can read the ! symbol in English.
It is commonly pronounced as "Bang".
"Go Bang" vs "Go"
is exactly the same difference as in
"C Sharp" vs "C", pronuntiation-wise.

Comment 584 by malonsosanchez, Nov 12, 2009
[...]
Go and Go! are very similar.

Comment 610 by davidsinger0, Nov 12, 2009
[...]
. you yourself said you used the term
"Let's Go!" for a book
which if you google is the name of a
very popular book series.
Are you then infringing on their rights?

Comment 654 by roman.go...@gmail.com, Nov 12, 2009
. Nothing wrong with google using Go,
just like nothing wrong with
C++ using the C,
nor using it in C# by Microsoft.
There is no confusion,
and there is no real difficulty in finding
help for those languages.
. I think this is a non-issue
and is just an excuse for people to
get into the town-hall mentality
of yelling out absurdities
and not looking at the facts.
[...]
. Go and Go! can co-exist,
even if !Go comes out.

Comment 741 by victor.petrov, Nov 12, 2009
[...]
For those of you who
brought the C -> C++ example:
your example isn't valid
in this situation.
C++ was actually a set of
extensions to the C language.
Google's Go is NOT
an extension to Go!,
nor is Go! an extension to Go.
[7.30:
. but the point is that
they are distinguishable names;
also, C# is not an extension
of either {C, C++},
and people thought that was a great name,
easily pronouncing it c-sharp;
just as we'll easily pronounce
go! as go-Cut .]

Comment 744 by coolboygreatone, Nov 12, 2009
@741: What about C++ and C#
P.S. : Google should not change the name

Comment 828 by julian.notfound, Nov 13, 2009
Forgot to put a link to slashdot discussion .

Comment 843 by davidsarah.hopwood, Nov 13, 2009
[7.30:
. one David-Sarah Hopwood
has been active in the E lang'
and cap'based security
where she's had many pro' conversations
with several google employees:
Ben Laurie [@] benl@google.com (2009)
Mike Stay [@] stay@google.com (2009)
Mark S. Miller [@] erights@google.com (2008...2010)
. ]

. "Go" is a really terrible name
for a programming language.
Besides the two languages,
it has two common meanings in English
(the verb and the name of the board game),
and
it also means "naked" in Croatian,

[7.30:
-- naked, as in barefoot-fast?
]

and "him" in Polish.

[7.30:
-- him, as in speed & strength vs longevity?
]

This many existing meanings
is what you would expect
for such a short word.
. Anyway, who chooses a name for
a programming language these days
without googling "FOO programming language"
to see if it's already taken?
That's impolite at best;
even downright negligent.

[7.30:
but why assume they didn't see "(go!) ?
would go# be ok in a C# world ?
.]
. The paper on the original Go! language,
incidentally, is at
http://www.doc.ic.ac.uk/~klc/annals.pdf
. It's a concurrent-logic dialect of Prolog
with asynchronous message passing
and Hindley-Milner type inference. [link]

Comment 878 by Lucretia...@yahoo.co.uk, Nov 14, 2009
[...] stop trying [to] make C safe
and use Ada instead,
[...] Just a thought, eh Google!?
[7.31:
. what?! Go is hardly a safer C;
it's basically a quicker Python .]
[7.30:
. like most dev'houses, google has to
reach for what the market will offer;
most hot-shot coders will not
touch that verbose language;
c is low-level, but has a huge library,
and your glue code is compact,
not verbose;
your tools are solid and familiar .]

Comment 891 by wrolufsen, Nov 15, 2009
My vote is for Go@, pronounced like 'goat'.

Comment 932 by graham.p...@gmail.com, Nov 16, 2009
Google probably already knew about
"Go!" (or "gobang" as it may be pronounced,
[...] So "Go" without the "!"
is like "C#" without the "#".
Also, I doubt you can trademark "Go"
so legally there's not leg to .

many suggested calling it plan9:

"( The name Plan 9 from Bell Labs
is a reference to the 1959
cult science fiction B-movie
Plan 9 from Outer Space.)

)

. issue 9 is still open .

. McCabe's old blog's about-page is taking comments .

review of other clashes with "(go):

. another name clashing with "(go)
is a different sort of "(language):
"(the cultural roadmap for the city girl)
... then for a lack of language there is
"(go) family news portal by Disney .

. finally, for some foreign language,
"(Go!) is the english version of weg!:
. an Afrikaans language outdoor and travel magazine;
focuses on affordable destinations in South Africa
and the rest of Africa.

adda's enumerated types

6.22: adda/type"enum:
. for the sake of readability,
adda`enums should be translated
directly to c`enums;
however, c`enums do need a lot of
helper functions in order to provide
ada-style functionality .
. it should also add -- in addition to Ada's way --
the same functionality for enums
that c has for pointers:
eg, if the ptr points at 4-byte ints,
then ptr+1 actually means ptr+4;
likewise for enums:
(e+1) means find the enum value
of next enum;
. if the enum is complicated by
non-consecutive values:
eg, { off, green:10, yellow:50, red:100 }
then it needs to generate a table
that enumerates the enum values:
eg, if the value will be in {0, 10, 50, 100}
then the table: value -> ordinal
is {0:0, 10:1, 50:2, 100:3};
with the ordinal value,
the encoded value is found from
an array lookup: {0, 10, 50, 100};
so if e=green+1; then
{ off, green:10, yellow:50, red:100
}(green) -> 10:
e= val#10 + ord#1 then
{0:0, 10:1, 50:2, 100:3}(10) -> 1:
e= ord#1 + ord#1 = ord#2 then
{0, 10, 50, 100}(+2) -> 50:
yellow
--. if there are only a few var's
it would be more efficient to
store both the ordinal and value in e .
. if values are consecutive
then after possibly shifting for a non-zero start,
the ordinal equals the value;
so, the enum`arithmetic functions need only
check for [out of range] .
. there should be unique type`names for
the 3 classes of enum types:
* subtype"simple-enum
has consecutive values that are
bijecting to names;
* subtype"encoding-enum has
non-consecutive bijections;
* subtype"entyping-enum is non-bijective:
there is no functional mapping
from code to name;
rationale for the name "(entyping):
traversing the values of the entyping-enum
then returns a sort of typing or
partitioning into equivalence classes:
eg, a mapping of enum`names to {0,1}
{ off:0, green:1, yellow:1, red:1 }
would have a traversal that returns
sets:
the first set is all names encoded as 0:
{ off }
the next set is names encoded as 1:
{ green, yellow, red } .

in's and out's of Ada programming

4.8: todo.co.addn/dev.ada/ask about c infiltration:
. from looking at the F35 project,
it seems like c has won the war with Ada;
and, that got me realizing that
much of what I like about Ada
could be transferred to c .
. the essential Ada features could be introduced
just like the enum types were;
and,
perhaps some version could try
the same route that c++ did:
"(this is a superset);
the industry really went wild for that .

4.15: Atego’s Aonix ObjectAda:
Military Embedded Systems`Editor's Choice award:
Atego’s Aonix ObjectAda Real-Time®
for Windows
targeting Intel x86 architectures
running Wind River’s VxWorks RTOS

Atego is the recent merger between
Artisan Software Tools and Aonix.
mission-critical systems
safety-critical systems
software development tools;
allows all teams
-- architecture, systems, software
and hardware engineering --
to [Work as One]SM
- from concept through to
delivery, maintenance and support.

Artisan Software Tools
. the world’s largest independent supplier of
industrial-grade, collaborative modeling tools
for complex, mission and safety-critical systems and software
Artisan Studio®, supports OMG SysML™, UML®
and Architectural Frameworks.

Aonix ObjectAda Real-Time
consists of a fully compliant
ACATS 2.5 Ada 95 compiler .
. Aonix ObjectAda for VxWorks leverages
the Eclipse-based Wind River Workbench .
Aonix PERC® secure java vm for embedded systems .

4.30: web.addn/dev.ada/online studies:
. searched site:faculty.cs.wwu.edu/reedyc/CS141_Spring_2005
and site:faculty.cs.wwu.edu ada
for ada study materials .

oop's dot notation

4.28: bk.adda/ada05`oop/why is dot notation needed?:
. didn't ada have a problem with needing oop's x.f
to avoid a redundancy problem with f(x) ?
. 05's rationale for oop syntax changes
is not compelling in adda's context:
. they noted that x.f can look a lot neater than f(x);
esp'ly in math formulae;
but, adda allows f x * ...
which means the same as f(x) * ... .
. they liked the fact that components and primitives
could be accessed with the same syntax .
. what should adda say x`f means?
the possessive character (`)
was supposed to remind one that
some modifications could be happening;
and, to offer a c.lang convenience like (x+= b)
-- which means x= x+b --
adda offers x`+ b .

ladyada.net`openware

3.15: web.adds/ladyada.net`openware:
. I heard of ladyada in a makezine;
she also sells kits for the designs she gives:
. one of her mit eng'ing projects
was a cell-phone jammer (not available as a kit!)
. she has an [ask an engineer].page
"(Our weekly LIVE video chat. Every Saturday 10PM ET )

3.15: web.adds/dangerousprototypes.com`openware:
. her saturday vid chat was spammed with this:
dangerousprototypes.com
-- A new open source hardware project every month
eg, a web platform kit for $35, assembled for $5 more.

The Dangerous Prototypes web platform is a tiny server
designed for networked hacks where a full PC is inconvenient.
for projects that bridge the internet to microcontrollers,
but most of them have a PC in the middle to handle network stuff.
This business card-sized internet appliance
can connect to web services,
control physical objects from a browser interface,
or email sensor status reports;
no PC intermediary required!

. owner ian also has:
http://www.diylife.com/bloggers/ian-lesnet/
eg, computer-mouse-salvage

3.15: co.adds/forums.adafruit.com/ergonomic keyboard kit:
. posted in kitbiz / ergonomic keyboard kit:
. thinking about questions to ask,
I'd like to buy an open source kit for
ergonomic keyboard kit:

. I was hoping someone would open-source
an ergonomic keyboard kit
with one or more of these features:
it comes in 2 parts that communicate with each other
as if one keyboard .
. it has a set of macro keys that are programmable by
reading an sd card's text file .
. the sd card can hold your passwords securely,
so macro keys could send long passwords .
. some cable that converts a laptop into a keyboard;
so that another computer thinks it's just a keyboard,
when really it's a set of programmable macro keys as well .

preventing death of a language

10.5: adda/ada/preventing death:

. when ada is refered to as a dying lang',

they must mean that the foundational req's of the lang

are precluding modernization .

. one dimension of death prevention

is ensuring that there are tools that can automate

the translation of the current lang'

to any other lang' chosen as a future replacement .

. the other problem is how to make it easy for

the transition of language tools:

these tools read the lang'

and will be broken if the lang' changes .

. one solution is to use the mono system,

where the lang' of your choice is translated to a

high-level universal lang', or cil (common intermediate lang') .

. however, as was seen in the mono spec's,

designing a high-level universal lang is not easy:

there have have been several instances of

being unable to express some feature in terms of the cil .

bitc

10.4: web.adda/bitc/validating c as assembler code:

. reviewing the progress of gnu`hurd,

hurd/ng is referencing coyote who is working on bitc,

whose mailing list seems to be dwindling:

. it's got some interesting problems in 2005:

http://www.coyotos.org/pipermail/bitc-dev/2005-July/000287.html

http://www.coyotos.org/pipermail/bitc-dev/2005-July/000277.html

. recent bits:

Jonathan S. Shapiro Apr 7 2009:

. several people have asked what all of this means for Coyotos.

Active work on Coyotos stopped several months ago,

and is unlikely to resume.

I am debating whether to re-license it under BSD,

but other than that, I have no current plans to continue the Coyotos work.

Getitng BitC v1 done is already pushing the limits of what is feasible

pretty severely.

Sat Apr 25 13:15:24 EDT 2009:

We looked at C-- early on and decided not to go that way.

C-- has come a long way since then,

but the time for that option has passed.

Shapiro Feb 10 2009

At a certain point the complexity of the compiler got big enough

that Python was no longer the right tool.

We went to C++ rather than C because we wanted to use smart pointers.

In hindsight, we should have stuck with C.

2008.04 paper on bitc`origins:

what we didn't know then:

http://www.bitc-lang.org/docs/bitc/bitc-origins.html

It is possible to program in something else (typically the prover)

and treat a small subset of a particular C implementation

as a well-defined assembly language,

as the L4.verified project has since done

Gerwin Klein, Michael Norrish, Kevin Elphinstone and Gernot Heiser.

``Verifying a High-Performance Micro-Kernel.''

7th Annual High-Confidence Software and Systems Conference,

Baltimore, MD, USA, May, 2007

Ada is a dying language:

. whatever its merits, ada is a dying language ...

it does not effectively exploit the advances in programming language theory

that have been made over the last two decades.

haskell`monads don't scale well

In ML, the use of state in the language is very carefully constrained to

simplify the core language semantics.

When state is introduced generally,

the language is suddenly forced to adopt a rich, first-class semantics

of locations into both the core semantics

and the core type system.

When let-polymorphism is present, adding core mutability

threatens the ability of the type inference engine

to generate principal types.

We wanted type inference, because Shapiro had witnessed

an unending stream of examples in UNIX

where failures to keep types synchronized across a code base led to errors,

and because

useable abstraction is hard to get in this class of language

without both type variables and type inference.

Being blissfully ignorant (at least when we started) of formal type theory,

all of this looked hard but straightforward,

which describes what kernel researchers do pretty much all the time:

navigate hard engineering compromises.

In fact, we soon learned that nobody had ever discovered

a sound and complete type system incorporating at the same time

both polymorphism and general mutability

Because of its preponderence for heap allocation,

extracting any sort of decent performance from an ML program

requires a level of optimization that is well beyond aggressive.

We needed a language that could preserve the illusion that

``what you see is what you get.''

This, among other issues, drove us to choose

eager rather than lazy evaluation.

object-oriented features actively got in the way of

understanding what was going on

however,

We needed the operator ``+'' to operate over arbitrary integer types.

Haskell presented a ready-made solution: type classes.

These simultaneously allowed us to generalize operators

and introduce a form of overloading into the language.

But type classes raise a problem that we will come back to later.

They introduce overloading and matching ambiguities that need to be addressed:

given two valid choices of specialization, which to choose?

In consequence, they have an unfortunate tendancy to break

separate compilation schemes.

Another issue with type classes is that the major implementations

all violate our code transparency objective.

The dictionary-based implementation technique

is not well-suited to languages having value types of multiple sizes;

we wanted an implementation that operated more in the style of C++ templates

-- not least because of the importance of linkage compatibility with C.

This would turn out to be the most problematic feature of the language.

In C, it is possible to have simultaneously a pointer to constant X

and a pointer to X,

both of which reference the same location.

This means that the compiler must be conservative when procedure calls are made.

In general, it cannot assume that supposedly constant objects

are unable to change.

In the interests of optimization, the ANSI C standard [1]

actually permits the compiler to make exactly this assumption.

Since there is no way for a C programmer to check whether

they have complied with the expectation of the compiler,

this is an invitation to error.

Since the result of computation depends on the

optimization decisions of particular language implementations,

bugs of this sort cannot be reliably eliminated through testing.

In BitC,

we decided very early to implement the notion of

immutability rather then constantness.

A BitC location that is declared to have immutable type

cannot be modified through [/]any reference.

In C, the ``const'' in const char is a type qualifier that can be stripped away.

In BitC it is an integral part of the type.

Actually, there wasn't any const type constructor in early BitC.

Variables and fields were constant unless declared mutable.

10.5:

The problems with module systems in stateful languages

are all about global variable initialization order.

. two language features that create problems for initialization order:

external declarations and assignment.

External declarations intentionally allow global identifiers

to be used before they are defined in ways that cannot be checked

when modules are compiled separately.

Assignment can cause initialized values to change between uses.

This either leads to a much finer dependency ordering on initializers

or to throwing up your hands and leaving ordering of effects during initialization undefined.

That may be type safe, but you get no guarantee about

what values global variables may hold when main() begins to run.

From a verification perspective this is problematic.

It is also makes the operation of a macro system

(which we intend to add in the future) undefined.

Well-formed programs invariably satisfy an implicit

lattice-structured dependency relationship for their initializers

(or at least don't get caught violating one).

The problem is that the ordering built by the compiler

is dictated by computational dependency,

while the organization of the program

required for manageability (the module relationships)

is dictated by conceptual relationships that exist in the minds of the developer.

The problem of initialization order is to satisfy both constraints simultaneously.

In BitC, we solved the initialization ordering problem

by declaring that interfaces are initialized first according to

the lattice defined by their import dependencies.

Within an interface, initialization proceeds from top to bottom,

and use of undefined forward references is prohibited.

It is source units of compilation that present the problem.

A BitC interface can declare a procedure that is implemented by

some exporting source unit of compilation.

In the absence of this feature,

we could declare that source units got initialized last in unspecified order.

Because source units can only export their identifiers through interfaces,

there cannot be further ordering dependencies

once the interface units have initialized in a defined order.

In the presence of export, this doesn't quite work.

What we do instead is to require that

any definition that is exported by a source unit

may rely (transitively) only on those symbols

that were in scope at the point of declaration in the interface.

The provided definition can rely on

other procedures and variables in the source unit,

and initialization proceeds as if all of those procedures and variables

had been temporarily copied into the interface unit of compilation.

But what about assignment and side effects?

And what if some of the procedures executed during initialization

get run multiple times?

9.2 Initialization vs. State

. permitting assignment during initialization is problematic.

Empirically, it isn't enough to require that

initializers be designed sensibly by the programmer

-- in the presence of shared libraries this requirement is nearly unachievable,

and the problem becomes more challenging in a higher-order programming language.

We cannot preclude the use of set! in initializers altogether.

This is too strong; it would prevent any occurrence of set!,

even if the containing procedure is not called at initialization time.

And strictly speaking, we can allow assignments in initializers

as long as the results of those assignments do not escape.

The position taken in BitC is that initializers must be ``pure,''

meaning that they may not modify any globally reachable values.

Implementing this forced us, with considerable hesitation,

to adopt an effect type system (Section 10).

10.5: adda/bitc/verifiable and modern systems prog' lang:

. after reading about the origins and req's of bitc

I was worried about the job ahead for designing adda .

. the storm shelter is to be found in modularity:

to be safe,

the system need only confine systems prog'ing to a module;

and within that module the system doesn't have to be safe:

it's ok if a module fails

so long as the failure doesn't bedevil other modules .

. for systems prog'ing with adda

we need to see how adda maps directly to c

while still staying true to the adda syntax .

efficiency:

. one paper points out why efficiency matters:

systems prog'ing is responsible for the energy use of data centers,

and that energy comes mostly in the form of cooling .

. the more cycles we use, the greater that ac bill .

. a major waste of energy is copying data that could be shared,

and there are 2 routes:

the complicated way is to try providing safe sharing;

while the easy way is to let systems prog'ing

happen in a separate, background process,

where any freeze-up's won't bedevil the safe parts .

[10.10: ie,

the most important thing for prototyping

is to help the user be an effective app'programmer

where worrying about efficiency can happen later . ]

10.5: bk.adda/Why Systems Programmers Still Use C:

Jonathan Shapiro, Ph.D.`Programming Language Challenges in Systems Codes

(Why Systems Programmers Still Use C, and What to Do About It)

. Singularity may obviate the cap'based coyote.os

. the Singularity project is probably the most serious challenge

to the current Coyotos work in the secure embedded system space.

There are some denial of resource issues

that are inherent in the Singularity communications layer.

These are fixable, and we gave serious thought to

replacing the Coyotos system with a structurally similar system

built on Singularity-like foundations.

In the commercial Coyotos effort,

we reluctantly concluded that the schedule risk

to our current commitments was too high,

but we think that there is an interesting research challenge here:

enhance the linear type approach of Singularity messages

with complete storage accountability during message exchange.

See if a system can be successfully structured

using language based mechanisms when abandoning the assumption

that there is an infinite pool of storage .

. if linear types prove to be a human-manageable mechanism

for handling interprocess communication,

it may really be true that

the era of hardware-based isolation is over .

Most of the performance unpredictability issues of garbage collection

become irrelevant if collection occurs over a small heap.

By increasing messaging performance,

Singularity permits applications to be split into

much smaller, independently collected domains.

Robustness is simultaneously improved.

10.5: bk.adda/Sound and Complete Type Inference for a Systems Programming Language:

Swaroop Sridhar, Jonathan S. Shapiro, Scott F. Smith

10.6: todo.adda/advanced typing systems:

. type systems of ml and haskell origins?

and see downloaded papers .

hierarchical modules

8.30: adda/ada`module architecture:

. instead of private part in head

they mean the head is a public contract

and part of the body can include a contract also .

. if types aren't defined in head,

compiler expects them def'd in body`root

8.30: adda/syntax/hierarchical modules:

t.type/newlib`=(..),

t.type/newlib`body`=(..),

unlike ada,

using the type t auto'ly makes all of lib available .

9.4: adda/import/as folder structure:

. the primary way to do implicit import

is to declare a var to be a type,

and then that type's module is imported .

. but what about other modules?

. the most intuitive way of importing

is to put the pkg's or their links into the program's enclosing folder,

. instead of putting the pkg itself there,

there would be an interface file .

that way, if the program is moved to a new user,

instead of just importing the name of a package,

you have the package's complete socket description;

making it harder for mix-up's to happen .

. this could still be done using ada's style:

"(import pkg) would make sure there was such a pkg header,

and copy it to the program's enviro.folder .

. the project folder contains a subfolder for each library unit;

. a subprogram has a separate folder that contains

separate parts of the program:

file for code

files or links for pkg heads,

subfolders for each local subprogram .

. here is the intuitive import:

"(../`+ my.pkg)

. it reminds you there is correspondence between the program structure

and some of your folder structure .

. you can do this by hand,

then go into the header and weed-out all the entries

that your program won't be using .

95:

. the includes go in a jacks.folder ? .

ada's concurrency

8.30: bk.adda/ada`concurrency:

. ada`partition has a separate enviro task for elaborating type mgts;

each partition has its own instance of each type mgt process .

. rpc (remote proc call) between partitions is done by

having some unit being declared with the rp.interface pragma .

. rci units can belong to only one partition;

ie, the unit should be named after the partition it's working for .

. rpc can be async when declared with an optional pragma .

. ipc can be done via passive partition sharing rather than rpc;

that means a unit containing only non-var's (pure)

or only passive vars (atomic or passive protected)

. passive protected var's are those that don't have entries like task,

just primitives that insure mutually exclusive access .

. pointers that are passed across partitions

must be url's;

think of pointer as being a type.class .

ada at youtube

6.17: co.net.youtube.com/AdaCore05:

http://www.youtube.com/profile?user=AdaCore05&method=add_friend

Your subscription to 'AdaCore05' has been added.

your request to add as friend has been sent .

AdaCore05

Joined: April 06, 2009

Last Sign In: 41 minutes ago

This channel is dedicated to presenting videos produced by AdaCore,

the leading provider of commercial, open software solutions for Ada,

a modern programming language designed for large, long-lived applications

where reliability, efficiency and safety are absolutely critical.

benefits of ada's language design

7.14: co.net/reddit.com/dev.ada:

www.reddit.com/r/programming/comments/8ycxp/the_return_of_ada

fierarul:

These kind of studies tend to miss a lot of important stuff

beyond the error rate, etc.

For example, usually Ada/Lisp coders that would be involved in such an experiment

would be a self-selected bunch of experts

that tend to also be above-average programmers.

So, the good results aren't just the merit of the language

but the merit of having good programmers in the team.

LucasMembrane :

No. There was a college prof teaching programming who got about

none of his student teams finishing their term project

when he had them do it in C++

and got about all of them finishing it when he had them do it in Ada.

queus:

(Killer?) link?

addn(my reply):

. the reference is to here:

Welcoming Software Into the Industrial Fold

James M. Sutton, Lockheed Martin Aeronautics

http://www.stsc.hill.af.mil/crosstalk/2008/05/0805Sutton.html

. his reference is this:

McCormick, John W. Software Engineering Education: On the Right Track. Aug. 2000

http://www.stsc.hill.af.mil/crosstalk/2000/08/mccormick.html

7.14: co.net/linkedin.com/ada/Ada debated on reddit.com:

www.linkedin.com/groupAnswers

my comment:

. I found them a link pointing out that Ada

made students more productive than C did (appended below) .

. I hope to create a scripting language

that translates something like Ada into plain old C;

. it's believed that Ada is complicated for the sake of safety,

but the bulk of this rule complexity

really comes from insuring both safety and efficiency .