Little people supporting Ada, possibly through AdaCore?

Little people supporting Ada, possibly through AdaCore?

[Patrick]

The other day I posted a comment in a thread:

"I am not attacking Adacore".......

"A private company seems to be the centre of the Ada and profit has to 
be their goal"

I got flamed.

In the rebuttal it stated that AdaCore has done more for Ada then the FSF. I never mentioned anything about the FSF and I am actually a bit disillusioned with them right now.

I couldn't agree more that AdaCore has done more for Ada then the FSF. having said this I think there is a danger to the greater Ada community to have all our "eggs in one basket". If an Oracle-like company decides to sue AdaCore, the results might not be as favourable as they appear to be playing out for Google, which has more wealth then entire countries to defend itself. 

My question is two fold.

Since AdacCore's paid support is well out of reach of my company(I am a one man operation) I can't really support AdaCore but I do want to. Is there something that can be done to keep the company going as long as possible?

Two, In the event that AdaCore should fail, would it be wise to come up with a back up plan? For instance, I know absolutely nothing about GNAT internals and I suspect many others are in this boat. Would it be good to try to form a non-profit group to studying the internals of it, just in case there is no one around to support it later? If this was the case, I propose it should be done in private as to not weaken AdaCore's market share.

-Patrick

Re: Little people supporting Ada, possibly through AdaCore?

[Marc C]

On Friday, May 4, 2012 8:26:53 AM UTC-5, Patrick wrote:

> Since AdacCore's paid support is well out of reach of my company(I am a
> one man operation) I can't really support AdaCore but I do want to. Is
> there something that can be done to keep the company going as long as
> possible?

- Advocate more use of Ada, which should result in more AdaCore customers.
- Report bugs and offer up patches. (Last week I submitted a patch to a GNATCOLL JSON package, which was accepted.)
- When your company becomes successful enough to afford paid support, do it and get the leading edge releases and company expertise on how to make your product better/faster/stronger.

> Two, In the event that AdaCore should fail...

AdaCore has assigned GNAT's copyright to the FSF, so the code would be publicly accessible to individuals, the remnants of AdaCore, and anyone else who would like to provide compiler support.

Marc A. Criley

Re: Little people supporting Ada, possibly through AdaCore?

[Manuel Gomez]

El 04/05/12 15:26, Patrick escribi�:
> Two, In the event that AdaCore should fail, would it be wise to come
> up with a back up plan? For instance, I know absolutely nothing about
> GNAT internals and I suspect many others are in this boat. Would it
> be good to try to form a non-profit group to studying the internals
> of it, just in case there is no one around to support it later? If
> this was the case, I propose it should be done in private as to not
> weaken AdaCore's market share.


In that event, I suppose the book "A Detailed Description of the GNU Ada
Run-Time" (J. Miranda, 2002) would be a valuable, although a bit 
outdated, resource.

http://www.iuma.ulpgc.es/users/jmiranda/

Re: Little people supporting Ada, possibly through AdaCore?

[gautier_niouzes]

Patrick:

> Having said this I think there is a danger to the greater Ada community to have all our "eggs in one basket".

Very right, and also it would be unhealthy for Ada to become a single-vendor language and lose the diversity of compilers which makes some of its strength.
If someone with a bit of sense of marketing could meet a small Ada compiler vendor... well, dreaming loud :-).

For the case AdaCore goes belly up, I would be less nervous: compilers do not stop working from themselves. So the first measure is to store versions of GNAT in a dry and cold place...
_________________________ 
Gautier's Ada programming 
http://freecode.com/users/gdemont

Re: Little people supporting Ada, possibly through AdaCore?

[okellogg]

On Friday, May 4, 2012 7:55:59 PM UTC+2, Manuel Gomez wrote:
> 
> In that event, I suppose the book "A Detailed Description of the GNU Ada
> Run-Time" (J. Miranda, 2002) would be a valuable, although a bit 
> outdated, resource.

+1 - I've found this  valuable as a high level overview.
However, going from there down to the compiler source code can still be a challenge.
[ off-topic: Recently I needed to understand how GNAT parses a WITH clause and it took me a few hours to figure it out,
http://www.okellogg.de/gnat1_handling_of_with_clause.html ]

Re: Little people supporting Ada, possibly through AdaCore?

[Pascal Obry]

Le 04/05/2012 21:28, gautier_niouzes@hotmail.com a �crit :
> Very right, and also it would be unhealthy for Ada to become a
> single-vendor language and lose the diversity of compilers which
> makes some of its strength. 

I agree with that, but if the single vendor (which is not the case
today) is an Open Source company it is not so bad. If AdaCore closes you
still have the compiler and toolset sources. This must be compared to
the case where a closed source company closes where at this point
everything disappear except the current binaries for the running compiler.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|    http://www.obry.net  -  http://v2p.fr.eu.org
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver keys.gnupg.net --recv-key F949BD3B

Re: Little people supporting Ada, possibly through AdaCore?

[Marco]

On Friday, May 4, 2012 10:55:59 AM UTC-7, Manuel Gomez wrote:

> 
> In that event, I suppose the book "A Detailed Description of the GNU Ada
> Run-Time" (J. Miranda, 2002) would be a valuable, although a bit 
> outdated, resource.
> 
> http://www.iuma.ulpgc.es/users/jmiranda/

Good candidate for a Wikibook so it could be updated.

example:
http://en.wikibooks.org/wiki/Ada_Programming

Re: Little people supporting Ada, possibly through AdaCore?

[Simon Wright]

okellogg@users.sourceforge.net writes:

> [ off-topic: Recently I needed to understand how GNAT parses a WITH
> clause and it took me a few hours to figure it out,
> http://www.okellogg.de/gnat1_handling_of_with_clause.html ]

Neat!

Your note on Par - which is a function, btw - I think what you mean is
that UML does not support stand-alone subprograms?

I suppose you could invent a 'package' Global or Library for
library-level subprograms to live in, cf Standard. Only if it helps!

Re: Little people supporting Ada, possibly through AdaCore?

[Lucretia]

> > http://www.iuma.ulpgc.es/users/jmiranda/
> 
> Good candidate for a Wikibook so it could be updated.
> 
> example:
> http://en.wikibooks.org/wiki/Ada_Programming

I think having an up to date internals book is a good idea. I'd be willing to add anything I've discovered about the Exception handling (which isn't much, but it is a start).

Luke.

Re: Little people supporting Ada, possibly through AdaCore?

[okellogg]

On Saturday, May 5, 2012 7:13:37 PM UTC+2, Simon Wright wrote:
> 
> > http://www.okellogg.de/gnat1_handling_of_with_clause.html
> 
> Your note on Par - which is a function, btw -

Thanks for noticing, I'll fix that.

>    I think what you mean is
> that UML does not support stand-alone subprograms?

Right.

> I suppose you could invent a 'package' Global or Library for
> library-level subprograms to live in, cf Standard. Only if it helps!

Yes. As you probably noticed, I've already twisted UML "class" to represent Ada package because UML "package" does not allow subprograms. Along these lines, making a UML class "Standard" should improve orthogonality.

-- Oliver

Re: Little people supporting Ada, possibly through AdaCore?

[Yannick Duchêne (Hibou57)]

Le Sun, 06 May 2012 18:26:59 +0200, <okellogg@users.sourceforge.net> a  
écrit:
>> I suppose you could invent a 'package' Global or Library for
>> library-level subprograms to live in, cf Standard. Only if it helps!
>
> Yes. As you probably noticed, I've already twisted UML "class" to  
> represent Ada package because UML "package" does not allow subprograms.

I believe that should be OK to say those classes stands for singleton  
objets classes. But I'm not versed at UML, which I know just too much few.  
Is there a way to apply a singleton stereotype to classes in UML?

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: Epigrams on Programming — Alan J. — P. Yale University

Re: Little people supporting Ada, possibly through AdaCore?

[Simon Wright]

"Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr> writes:

> Le Sun, 06 May 2012 18:26:59 +0200, <okellogg@users.sourceforge.net> a
> écrit:
>>> I suppose you could invent a 'package' Global or Library for
>>> library-level subprograms to live in, cf Standard. Only if it helps!
>>
>> Yes. As you probably noticed, I've already twisted UML "class" to
>> represent Ada package because UML "package" does not allow
>> subprograms.
>
> I believe that should be OK to say those classes stands for singleton
> objets classes. But I'm not versed at UML, which I know just too much
> few.  Is there a way to apply a singleton stereotype to classes in
> UML?

You certainly could, but in this case it makes much more sense (I think)
to say what you mean the diagram to represent (the "profile") in plain
words.

Oliver's use is rather more like what Rational Rose used to call a
"utility class" (one which has no instances) than a singleton (which ash
one instance).

Re: Little people supporting Ada, possibly through AdaCore?

[Yannick Duchêne (Hibou57)]

Le Sun, 06 May 2012 18:55:27 +0200, Simon Wright <simon@pushface.org> a  
écrit:
> Oliver's use is rather more like what Rational Rose used to call a
> "utility class" (one which has no instances) than a singleton (which ash
> one instance).

What's the difference? It has to be instantiated, anyway.

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: Epigrams on Programming — Alan J. — P. Yale University

Re: Little people supporting Ada, possibly through AdaCore?

[Simon Wright]

"Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr> writes:

> Le Sun, 06 May 2012 18:55:27 +0200, Simon Wright <simon@pushface.org>
> a écrit:
>> Oliver's use is rather more like what Rational Rose used to call a
>> "utility class" (one which has no instances) than a singleton (which ash
>> one instance).
>
> What's the difference? It has to be instantiated, anyway.

Not sure what you mean by 'instantiated'.

If the UML model has a class marked <<singleton>> then something in the
generated or handwritten code will have to provide a place for the
class's attributes; in some sort of instance record.

If a class is marked <<utility>>, on the other hand, I'd expect it to be
illegal (in that profile) for the class to have any attributes, so there
can be no need for an instance record.

Re: Little people supporting Ada, possibly through AdaCore?

[okellogg]

On Sunday, May 6, 2012 6:26:59 PM UTC+2, okel...@users.sourceforge.net wrote:
> On Saturday, May 5, 2012 7:13:37 PM UTC+2, Simon Wright wrote:
> > 
> > > http://www.okellogg.de/gnat1_handling_of_with_clause.html
> > 
> > Your note on Par - which is a function, btw -
> 
> Thanks for noticing, I'll fix that.

I fixed that and also extended the sequence to show when and how an input file is physically opened and loaded.

Further, I've added a page explaining how an input file name gets passed to the gnat1 executable (having discovered that this was non trivial enough to warrant a proper explanation):
http://www.okellogg.de/how_does_the_input_filename_get_into_gnat1.html

-- Oliver

Re: Little people supporting Ada, possibly through AdaCore?

[Adrian Hoe]

On Friday, May 4, 2012 10:36:12 PM UTC+8, Marc C wrote:
> 
> - Report bugs and offer up patches. (Last week I submitted a patch to a GNATCOLL JSON package, which was accepted.)


Hi Marc,

I wonder what patch you have submitted. The AdaCore repository (http://svn.eu.adacore.com/anonsvn/Dev/trunk/gps/gnatlib/src/) does not show commits.

I followed Thomas Locke's example in his Ada-DK Wiki. As in the output example (as in Thomas Ada-DK wiki), the sequence of the objects in the output are not the same as when they are created. Let’s take the core company data as an example.

In procedure Set_Core_Company_Data, the sequence is company_name, vat_no, hours, product and web. But the output shows the order: company_name, web, [addresses], products, hours, [persons] and vat_no.

Is this a bug in GNATColl.JASON? I can’t find any bug. Perhaps it is the “Ada.Containers.Indefinite_Hashed_Maps” or I have missed something?

I have posted a comment at Thomas' blog (http://ada-dk.org/2011/11/getting-down-and-dirty-with-ada-and-json/#comment-107).

Thanks.
--
Adrian Hoe

Re: Little people supporting Ada, possibly through AdaCore?

[Marc C]

On Monday, July 16, 2012 10:47:41 AM UTC-5, Adrian Hoe wrote:

> I wonder what patch you have submitted. The AdaCore repository (http://svn.eu.adacore.com/anonsvn/Dev/trunk/gps/gnatlib/src/) does not show commits.

(The link at libre.adacore.com to browse the repository appears to be broken now.)

You can see the record of the inclusion of the patch I provided at http://svn.eu.adacore.com/anonsvn/Dev/trunk/gps/gnatlib/known-problems-14, it's the first one in the list. I didn't do the commit of course, I just wrote the patch and emailed it in to AdaCore.

Marc A. Criley

Re: Little people supporting Ada, possibly through AdaCore?

[Adrian Hoe]

On Tuesday, July 17, 2012 2:13:24 AM UTC+8, Marc C wrote:
> On Monday, July 16, 2012 10:47:41 AM UTC-5, Adrian Hoe wrote:
> 
> > I wonder what patch you have submitted. The AdaCore repository (http://svn.eu.adacore.com/anonsvn/Dev/trunk/gps/gnatlib/src/) does not show commits.
> 
> (The link at libre.adacore.com to browse the repository appears to be broken now.)

I guessed so. Thanks for the link. Any idea about the problem that I encountered?

The JSON output that the example produced is perfectly valid JSON. My concern is human readable JSON. With the order of the objects not output according to the sequence of the input/creation makes the output very un-readable for human. Not good for debugging purpose though.


> You can see the record of the inclusion of the patch I provided at http://svn.eu.adacore.com/anonsvn/Dev/trunk/gps/gnatlib/known-problems-14, it's the first one in the list. I didn't do the commit of course, I just wrote the patch and emailed it in to AdaCore.
> 
> Marc A. Criley

Re: Little people supporting Ada, possibly through AdaCore?

[Thomas Løcke]

On 07/17/2012 03:58 AM, Adrian Hoe wrote:
> The JSON output that the example produced is perfectly valid JSON. My concern is human readable JSON. With the order of the objects not output according to the sequence of the input/creation makes the output very un-readable for human. Not good for debugging purpose though.


 From json.org:

"An object is an unordered set of name/value pairs."

So it is not the job of GNATCOLL.JSON to keep your JSON objects in any
kind of order.

:o)

-- 
Thomas L�cke | thomas@12boo.net | http://12boo.net

Re: Little people supporting Ada, possibly through AdaCore?

[Adrian Hoe]

On Tuesday, July 17, 2012 2:00:03 PM UTC+8, Thomas Løcke wrote:
> On 07/17/2012 03:58 AM, Adrian Hoe wrote:
> > The JSON output that the example produced is perfectly valid JSON. My concern is human readable JSON. With the order of the objects not output according to the sequence of the input/creation makes the output very un-readable for human. Not good for debugging purpose though.
> 
> 
>  From json.org:
> 
> "An object is an unordered set of name/value pairs."
> 
> So it is not the job of GNATCOLL.JSON to keep your JSON objects in any
> kind of order.
> 
> :o)
> 
> -- 
> Thomas Løcke | thomas@12boo.net | http://12boo.net

Yeah, but looks like GNATColl.JSON has mixed up the order of objects. So, if objects are created in the order of company_name, vat_no, hours, product and web as in procedure Set_Core_Company_Data then it should be left as it is. The objects should be traversed in the same order as they were created but the output shows company_name, web, product, hours and vat_no. I don't mean it is the job of  GNATColl.JSON to sort the objects according to some orders. The question is: Why the objects cannot be traversed in the original order as they are created?

Thanks.
--
Adrian Hoe

Re: Little people supporting Ada, possibly through AdaCore?

[Thomas Løcke]

On 07/17/2012 03:47 PM, Adrian Hoe wrote:
> Yeah, but looks like GNATColl.JSON has mixed up the order of objects. So, if objects are created in the order of company_name, vat_no, hours, product and web as in procedure Set_Core_Company_Data then it should be left as it is. The objects should be traversed in the same order as they were created but the output shows company_name, web, product, hours and vat_no. I don't mean it is the job of  GNATColl.JSON to sort the objects according to some orders. The question is: Why the objects cannot be traversed in the original order as they are created?


If you look at the code you'll see they are using a plain
Ada.Containers.Indefinite_Hashed_Maps for storage, and some simple
recursion in the Write function. The original order of the objects
are lost forever when they are added to a hashed map. There's no
sequence, only a collection of JSON_Value objects.

There's no way to sort the contents of an Indefinite_Hashed_Maps
container without "wasting" processing time, and since order doesn't
matter in JSON, I don't think the GNATColl devs have spent an awful lot
of time on making sure some sort of arbitrary order is maintained.

-- 
Thomas L�cke | thomas@12boo.net | http://12boo.net

Re: Little people supporting Ada, possibly through AdaCore?

[Marc C]

On Tuesday, July 17, 2012 8:47:02 AM UTC-5, Adrian Hoe wrote:
> On Tuesday, July 17, 2012 2:00:03 PM UTC+8, Thomas Løcke wrote:
> >  From json.org:
> > 
> > "An object is an unordered set of name/value pairs."

> Yeah, but looks like GNATColl.JSON has mixed up the order of objects. 
> The objects should be traversed in the same order as they were created
> The question is: Why the objects cannot be traversed in the original order as they are created?

An "unordered" set is an *unordered* set. It is inappropriate to expect any kind  of intrinsic or 'order of insertion' ordering of elements in such a set. It would be a waste of development and computational resources to impose a behavior on an entity that is not required.

On the other hand, a "JSONArray is an ordered sequence of values" (http://www.json.org/javadoc/org/json/JSONArray.html).

Marc A. Criley

Re: Little people supporting Ada, possibly through AdaCore?

[Dmitry A. Kazakov]

On Wed, 18 Jul 2012 06:33:34 -0700 (PDT), Marc C wrote:

> An "unordered" set is an *unordered* set. It is inappropriate to expect
> any kind  of intrinsic or 'order of insertion' ordering of elements in
> such a set.

True. However a set of truly unordered elements cannot be implemented
otherwise than on top of an ordered set. E.g. to be able to implement
membership test. Either the container imposes some order on the elements or
else the elements have some arbitrary order.

It is interesting to speculate about the interface of an unordered set such
that the clients could not exploit its ad-hoc order.

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

Re: Little people supporting Ada, possibly through AdaCore?

[Simon Wright]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On Wed, 18 Jul 2012 06:33:34 -0700 (PDT), Marc C wrote:
>
>> An "unordered" set is an *unordered* set. It is inappropriate to expect
>> any kind  of intrinsic or 'order of insertion' ordering of elements in
>> such a set.
>
> True. However a set of truly unordered elements cannot be implemented
> otherwise than on top of an ordered set. E.g. to be able to implement
> membership test. Either the container imposes some order on the elements or
> else the elements have some arbitrary order.
>
> It is interesting to speculate about the interface of an unordered set such
> that the clients could not exploit its ad-hoc order.

We had a requirement to display at most 50 log entries. We tried again
and again (but no further) to ask what the sort criteria should be if
there were more than 50 log entries; explaining that if we did nothing
the users would see the first 50 entries in the hashed map. The result
of that was a rant about the fact that the order depended on the
component library and might change; the response to which was that we
would never accept an upgraded component library without going through
appropriate acceptance procedures.

We never did find out what the sort criteria should be.

Re: Little people supporting Ada, possibly through AdaCore?

[Vasiliy Molostov]

Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> писал(а) в своём письме Wed,  
18 Jul 2012 21:14:35 +0400:

> On Wed, 18 Jul 2012 06:33:34 -0700 (PDT), Marc C wrote:
>
>> An "unordered" set is an *unordered* set. It is inappropriate to expect
>> any kind  of intrinsic or 'order of insertion' ordering of elements in
>> such a set.
>
> True. However a set of truly unordered elements cannot be implemented
> otherwise than on top of an ordered set. E.g. to be able to implement
> membership test. Either the container imposes some order on the elements  
> or
> else the elements have some arbitrary order.

how about the following:

type Unordered_Set is
record
	null;
end;

type Unordered_Element (Belongs_to: access Unordered_Set)is
record
	null; -- data
end;

elements has no order between each other, except membership itself, and a  
set has no ordering of elements also.

The membership test is very simple here: (element.belongs_to =  
unordered'access)


-- 
ps. perhaps this pseudo code is not ada, but adaptable well, i think.

Re: Little people supporting Ada, possibly through AdaCore?

[gautier_niouzes]

Le mardi 17 juillet 2012 15:47:02 UTC+2, Adrian Hoe a écrit :

"
Yeah, but looks like GNATColl.JSON has mixed up the order of objects. So, if objects are created in the order of company_name, vat_no, hours, product and web as in procedure Set_Core_Company_Data then it should be left as it is. The objects should be traversed in the same order as they were created but the output shows company_name, web, product, hours and vat_no. I don't mean it is the job of  GNATColl.JSON to sort the objects according to some orders. The question is: Why the objects cannot be traversed in the original order as they are created?
"

Did you consider adding an extra field, Order, entered with 1,2,3,... ?
Then you could sort the objects at the end.
_________________________
Gautier's Ada programming
http://gautiersblog.blogspot.com/search/label/Ada
NB: follow the above link for a valid e-mail address

Re: Little people supporting Ada, possibly through AdaCore?

[Maciej Sobczak]

W dniu środa, 18 lipca 2012 19:14:35 UTC+2 użytkownik Dmitry A. Kazakov napisał:

> True. However a set of truly unordered elements cannot be implemented
> otherwise than on top of an ordered set.

Why?

> E.g. to be able to implement
> membership test.

Membership test does not require any order.

> It is interesting to speculate about the interface of an unordered set such
> that the clients could not exploit its ad-hoc order.

Make it... parallel?
You know, instead of relying on sequential algorithms try to think in terms similar to those in ParaSail. Membership test is a question asked to multiple tasks (representing subsets or even individual elements from the domain), where at most one of them will answer "yes".

Inefficient? This depends on the hardware - our current hardware is sequential in nature where parallelism is an afterthought, but take molecular computing into account and things start to look a lot different.

-- 
Maciej Sobczak * http://www.msobczak.com * http://www.inspirel.com

Re: Little people supporting Ada, possibly through AdaCore?

[Dmitry A. Kazakov]

On Thu, 19 Jul 2012 00:57:42 +0400, Vasiliy Molostov wrote:

> Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> яПНяПНяПНяПНяПН(яПН) яПН яПНяПНяПНяПНяПН яПНяПНяПНяПНяПНяПН Wed,  
> 18 Jul 2012 21:14:35 +0400:
> 
>> On Wed, 18 Jul 2012 06:33:34 -0700 (PDT), Marc C wrote:
>>
>>> An "unordered" set is an *unordered* set. It is inappropriate to expect
>>> any kind  of intrinsic or 'order of insertion' ordering of elements in
>>> such a set.
>>
>> True. However a set of truly unordered elements cannot be implemented
>> otherwise than on top of an ordered set. E.g. to be able to implement
>> membership test. Either the container imposes some order on the elements  
>> or else the elements have some arbitrary order.
> 
> how about the following:
> 
> type Unordered_Set is
> record
> 	null;
> end;
>
> type Unordered_Element (Belongs_to: access Unordered_Set)is
> record
> 	null; -- data
> end;
> 
> elements has no order between each other, except membership itself, and a  
> set has no ordering of elements also.
> 
> The membership test is very simple here: (element.belongs_to =  
> unordered'access)

How would you copy such sets?

P.S. If you put book keeping in the elements, that is no more a set of
original element. Yes it is equivalent to it in some sense. But so an
ordered set would too.

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

Re: Little people supporting Ada, possibly through AdaCore?

[Dmitry A. Kazakov]

On Thu, 19 Jul 2012 00:45:19 -0700 (PDT), Maciej Sobczak wrote:

> W dniu �roda, 18 lipca 2012 19:14:35 UTC+2 u�ytkownik Dmitry A. Kazakov napisa�:
> 
>> True. However a set of truly unordered elements cannot be implemented
>> otherwise than on top of an ordered set.
> 
> Why?

I guess it is related to computability.

>> E.g. to be able to implement membership test.
> 
> Membership test does not require any order.

You need to enumerate elements to be able to compute it. Enumeration is
equivalent to ordering.

>> It is interesting to speculate about the interface of an unordered set such
>> that the clients could not exploit its ad-hoc order.
> 
> Make it... parallel?
> You know, instead of relying on sequential algorithms try to think in
> terms similar to those in ParaSail. Membership test is a question asked to
> multiple tasks (representing subsets or even individual elements from the
> domain), where at most one of them will answer "yes".

That confuses mutability and membership. Or do you suggest something like
Monte Carlo performed by a bunch of tasks? In that case you would need to
identify elements in the set in order to compare them with the testee. That
again would require some order.
 
> Inefficient? This depends on the hardware - our current hardware is
> sequential in nature where parallelism is an afterthought, but take
> molecular computing into account and things start to look a lot different.

Yep, as I said, it must be related to computability. A hardware may provide
sets incomputable programmatically. These could be unordered. E.g. it could
ask you if X belongs to S.

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

Re: Little people supporting Ada, possibly through AdaCore?

[Vasiliy Molostov]

Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> писал(а) в своём письме Thu,  
19 Jul 2012 12:08:16 +0400:

> P.S. If you put book keeping in the elements, that is no more a set of
> original element. Yes it is equivalent to it in some sense. But so an
> ordered set would too

 From a user perspective:
potentially storage pools can copy of such sets, and elements within still  
have no known order. I suppose that for user an unknown order means no  
order.
Strictly speaking: sets do not require ordering, they require membership  
test. And from this point of view an ordered set is a conjunction of two  
"atomics": an "ordered" (<,>) and a "set" (ismember).


As for json this is a child of two: "ordered" and a "dict". So the  
resolution to gnat json impl is that it is half-implemented (missing  
"ordered") in terms of usual java developer. But perhaps this is not bad  
for ada developer?
-- 
Написано в почтовом клиенте браузера Opera: http://www.opera.com/mail/

Re: Little people supporting Ada, possibly through AdaCore?

[Maciej Sobczak]

W dniu czwartek, 19 lipca 2012 10:23:41 UTC+2 użytkownik Dmitry A. Kazakov napisał:

> >> True. However a set of truly unordered elements cannot be implemented
> >> otherwise than on top of an ordered set.
> > 
> > Why?
> 
> I guess it is related to computability.

Why? I see no relation. Or, to put it in more concrete terms - I don't care about implementation details; the purpose of abstraction is to be independent from them. You might need something ordered (array? or even addressable memory?) at the very bottom, but that does not make the *concepts* related, it just exposes limitations of your current implementation platform.

> > Membership test does not require any order.
> 
> You need to enumerate elements to be able to compute it.

No, you don't need to enumerate. If I remember correctly, the Pascal language provides sets as a language-level entity and membership test is commonly implemented as logical, bitwise operation. Now, you can argue that bitsets rely on some assumed ordering of implicitly assigned position numbers or whatever, but wait until I finish my hardware-based implementation of logical operations on bit-cubes. No ordering is required, it is just an artifact of our current, very limited hardware.

> In that case you would need to
> identify elements in the set in order to compare them with the testee. That
> again would require some order.

No. Just wait until I finish my organic neural network, where sets are just implemented as multiple neurons connected to the owner, all triggered with the same signal. The membership test is O(1) and has nothing to do with enumeration (and therefore nothing to do with ordering).

Don't define general concepts in terms of current limited implementations on some crappy hardware.

-- 
Maciej Sobczak * http://www.msobczak.com * http://www.inspirel.com

Re: Little people supporting Ada, possibly through AdaCore?

[Georg Bauhaus]

On 19.07.12 14:12, Vasiliy Molostov wrote:
> As for json this is a child of two: "ordered" and a "dict".

I don't think so.

"An _object_ is an unordered set of name/value pairs.
 An object begins with { (left brace) and ends with }
 (right brace)."

"An _array_ is an ordered collection of values.
 An array begins with [ (left bracket) and ends with ]
 (right bracket)."

Therefore, the order is defined to be the order of
appearance in an array.

http://www.json.org/

Re: Little people supporting Ada, possibly through AdaCore?

[Dmitry A. Kazakov]

On Thu, 19 Jul 2012 05:42:19 -0700 (PDT), Maciej Sobczak wrote:

> W dniu czwartek, 19 lipca 2012 10:23:41 UTC+2 u�ytkownik Dmitry A. Kazakov napisa�:
> 
>> >> True. However a set of truly unordered elements cannot be implemented
>> >> otherwise than on top of an ordered set.
>> > 
>> > Why?
>> 
>> I guess it is related to computability.
> 
> Why? I see no relation. Or, to put it in more concrete terms - I don't
> care about implementation details; the purpose of abstraction is to be
> independent from them.

Yes, but that was not the point, which was that the underlying
implementation would need some ordered set and thus an ad-hoc order induced
by that.

The actual question was how to shape the interface of an unordered set so
that the clients could not exploit hidden order(s). As an example, maybe
not very good one, but anyway, consider sets of characters from ASCII,
EBCDIC. Let we wanted to prevent users to rely on ASCII'Succ ('I') = 'J',
because that might be untrue for EBCDIC. For example, should it be possible
to iterate elements in the set:

   for I in S'Range loop
       E := S (I);
   end loop;

or only this way:

   for E in S loop
       ... -- Unspecified order
   end loop;

or maybe there should be operations creating ordered snapshots of the
unordered original?

I think that unordered interfaces could be potentially useful for parallel
computing and very large [mutable/remote] sets, which could not be
iterated.

>> > Membership test does not require any order.
>> 
>> You need to enumerate elements to be able to compute it.
> 
> No, you don't need to enumerate. If I remember correctly, the Pascal
> language provides sets as a language-level entity and membership test is
> commonly implemented as logical, bitwise operation. Now, you can argue
> that bitsets rely on some assumed ordering of implicitly assigned position
> numbers or whatever, but wait until I finish my hardware-based
> implementation of logical operations on bit-cubes. No ordering is
> required, it is just an artifact of our current, very limited hardware.

As I said, it is related to computability. You could have an "oracle"
telling if X is in S. "oracle" = incomputable by other means (i.e. by FSA).
But when computable, then ordered.

>> In that case you would need to
>> identify elements in the set in order to compare them with the testee. That
>> again would require some order.
> 
> No. Just wait until I finish my organic neural network, where sets are
> just implemented as multiple neurons connected to the owner, all triggered
> with the same signal. The membership test is O(1) and has nothing to do
> with enumeration (and therefore nothing to do with ordering).

You could simply say that the membership relation is implemented by an
incidence matrix, which is an equivalent to neurons wiring. But rows and
columns of the matrix are enumerated, that gives you an order.

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

Re: Little people supporting Ada, possibly through AdaCore?

[Randy Brukardt]

"Vasiliy Molostov" <molostoff@gmail.com> wrote in message 
news:op.whoz7g1gka8ora@aspire.local...
...
> I suppose that for user an unknown order means no order.

Not really. There are many, many examples of programmers taking advantage of 
a order that a particular implementation has. As Dmitry points out, it's 
important that the interfaces expose as little order as possible.

This is, in fact, the reason that we ultimately decided that Ada shouldn't 
have unordered maps and sets. The implementation would necessarily iterate 
the maps and sets in some order, and it seemed impossible to prevent code 
from depending on that order. Moreover, lookups in a truly unordered map or 
set are expensive (requiring looking at the complete contents of the map or 
set), and there seemed to be no significant performance advantage to the 
unordered forms over the other forrms.

Of course, the iteration order of a hashed map is unknown and should not be 
depended upon, but that doesn't stop people from trying (as in the OP). 
Probably, unordered containers shouldn't allow any iteration, but that's 
obviously limiting.

                                         Randy.

Re: Little people supporting Ada, possibly through AdaCore?

[Vasiliy Molostov]

Georg Bauhaus <rm.dash-bauhaus@futureapps.de> писал(а) в своём письме Thu,  
19 Jul 2012 17:22:23 +0400:

> On 19.07.12 14:12, Vasiliy Molostov wrote:
>> As for json this is a child of two: "ordered" and a "dict".
>
> I don't think so.
>
> "An _object_ is an unordered set of name/value pairs.
>  An object begins with { (left brace) and ends with }
>  (right brace)."
>
> "An _array_ is an ordered collection of values.
>  An array begins with [ (left bracket) and ends with ]
>  (right bracket)."
>
> Therefore, the order is defined to be the order of
> appearance in an array.

perhaps, regarding to java type model, I meant array object.

Otherwise, array is not an object which is not correct, I suppose.

>
> http://www.json.org/
>


-- 
Написано в почтовом клиенте браузера Opera: http://www.opera.com/mail/

Re: Little people supporting Ada, possibly through AdaCore?

[Vasiliy Molostov]

This is true for a complete library interface which is offered to the  
user. I doubt that it can be handful.

In the reply, I meant intermediate interface models, which user can  
aggregate to get that of his interest, which is more flexible way.

Any complete and strong defined interface comes with restrictions, and not  
all of them can be adopted without compromise, and mandatory ordering of  
some sort where you can not avoid it is a potential point of expectation  
mistake. Especially where it has environment dependencies (for example,  
character encoding, locale settings and so on).

Looking over a superset of all possible sorts of the behaviour of that  
interface implementation, I am as a user can say that this order is  
unknown to me, since interface has no definition about it, and  
consequently - unknown order falls back to "no order", which means I have  
to reorder it by my own implementation, e.g. override.

What part of that interface I can override?

ps. Sorry, perhaps I am arguing without referring to initial questioned  
problem, I have just responded about "unordered sets are impossible".

Randy Brukardt <randy@rrsoftware.com> писал(а) в своём письме Fri, 20 Jul  
2012 06:51:05 +0400:

> "Vasiliy Molostov" <molostoff@gmail.com> wrote in message
> news:op.whoz7g1gka8ora@aspire.local...
> ...
>> I suppose that for user an unknown order means no order.
>
> Not really. There are many, many examples of programmers taking  
> advantage of
> a order that a particular implementation has. As Dmitry points out, it's
> important that the interfaces expose as little order as possible.
>
> This is, in fact, the reason that we ultimately decided that Ada  
> shouldn't
> have unordered maps and sets. The implementation would necessarily  
> iterate
> the maps and sets in some order, and it seemed impossible to prevent code
> from depending on that order. Moreover, lookups in a truly unordered map  
> or
> set are expensive (requiring looking at the complete contents of the map  
> or
> set), and there seemed to be no significant performance advantage to the
> unordered forms over the other forrms.
>
> Of course, the iteration order of a hashed map is unknown and should not  
> be
> depended upon, but that doesn't stop people from trying (as in the OP).
> Probably, unordered containers shouldn't allow any iteration, but that's
> obviously limiting.
>
>                                          Randy.
>
>
>


-- 
Написано в почтовом клиенте браузера Opera: http://www.opera.com/mail/