Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.
Dismiss
Little people supporting Ada, possibly through AdaCore?
391 views
Skip to first unread message
Patrick
May 4, 2012, 9:26:53 AM5/4/12
to
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
Marc C
May 4, 2012, 10:36:12 AM5/4/12
to
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.
> 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?
- 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
Manuel Gomez
May 4, 2012, 1:55:59 PM5/4/12
to
El 04/05/12 15:26, Patrick escribió:
Run-Time" (J. Miranda, 2002) would be a valuable, although a bit
outdated, resource.
http://www.iuma.ulpgc.es/users/jmiranda/
> 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
> 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.
Run-Time" (J. Miranda, 2002) would be a valuable, although a bit
outdated, resource.
http://www.iuma.ulpgc.es/users/jmiranda/
gautier...@hotmail.com
May 4, 2012, 3:28:33 PM5/4/12
to
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
> 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
okel...@users.sourceforge.net
May 4, 2012, 3:59:53 PM5/4/12
to
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.
>
> 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.
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 ]
Pascal Obry
May 5, 2012, 9:28:16 AM5/5/12
to
Le 04/05/2012 21:28, gautier...@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
> 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.
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
Marco
May 5, 2012, 10:17:14 AM5/5/12
to
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.
>
> 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/
example:
http://en.wikibooks.org/wiki/Ada_Programming
Simon Wright
May 5, 2012, 1:13:37 PM5/5/12
to
okel...@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!
> [ 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 ]
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!
Lucretia
May 6, 2012, 9:01:09 AM5/6/12
to
> > 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).
>
> Good candidate for a Wikibook so it could be updated.
>
> example:
> http://en.wikibooks.org/wiki/Ada_Programming
Luke.
okel...@users.sourceforge.net
May 6, 2012, 12:26:59 PM5/6/12
to
On Saturday, May 5, 2012 7:13:37 PM UTC+2, Simon Wright wrote:
>
> > http://www.okellogg.de/gnat1_handling_of_with_clause.html
> 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
>
> > 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.
> 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!
-- Oliver
Yannick Duchêne (Hibou57)
May 6, 2012, 12:42:51 PM5/6/12
to
Le Sun, 06 May 2012 18:26:59 +0200, <okel...@users.sourceforge.net> a
écrit:
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
é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
>> 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.
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
Simon Wright
May 6, 2012, 12:55:27 PM5/6/12
to
"Yannick Duchêne (Hibou57)" <yannick...@yahoo.fr> writes:
> Le Sun, 06 May 2012 18:26:59 +0200, <okel...@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)
> Le Sun, 06 May 2012 18:26:59 +0200, <okel...@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?
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).
Yannick Duchêne (Hibou57)
May 6, 2012, 1:21:21 PM5/6/12
to
Le Sun, 06 May 2012 18:55:27 +0200, Simon Wright <si...@pushface.org> a
écrit:
é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.
> "utility class" (one which has no instances) than a singleton (which ash
> one instance).
Simon Wright
May 6, 2012, 3:33:39 PM5/6/12
to
> Le Sun, 06 May 2012 18:55:27 +0200, Simon Wright <si...@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'.
> 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.
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.
okel...@users.sourceforge.net
May 20, 2012, 9:38:47 AM5/20/12
to
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.
> 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.
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
Adrian Hoe
Jul 16, 2012, 11:47:41 AM7/16/12
to
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,
>
> - Report bugs and offer up patches. (Last week I submitted a patch to a GNATCOLL JSON package, which was accepted.)
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
Marc C
Jul 16, 2012, 2:13:24 PM7/16/12
to
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 wonder what patch you have submitted. The AdaCore repository (http://svn.eu.adacore.com/anonsvn/Dev/trunk/gps/gnatlib/src/) does not show commits.
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
Adrian Hoe
Jul 16, 2012, 9:58:41 PM7/16/12
to
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.
> On Monday, July 16, 2012 10:47:41 AM UTC-5, Adrian Hoe wrote:
>
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
Thomas Løcke
Jul 17, 2012, 2:00:03 AM7/17/12
to
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:
> 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.
"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 | tho...@12boo.net | http://12boo.net
Adrian Hoe
Jul 17, 2012, 9:47:02 AM7/17/12
to
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.
> On 07/17/2012 03:58 AM, Adrian Hoe wrote:
>
>
> 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 | tho...@12boo.net | http://12boo.net
> So it is not the job of GNATCOLL.JSON to keep your JSON objects in any
> kind of order.
>
> :o)
>
> --
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
Thomas Løcke
Jul 17, 2012, 11:06:28 AM7/17/12
to
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
> 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?
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.
Marc C
Jul 18, 2012, 9:33:34 AM7/18/12
to
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:
> On Tuesday, July 17, 2012 2:00:03 PM UTC+8, Thomas Løcke wrote:
> >
> > "An object is an unordered set of name/value pairs."
> > "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
Dmitry A. Kazakov
Jul 18, 2012, 1:14:35 PM7/18/12
to
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
> 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.
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
Simon Wright
Jul 18, 2012, 1:49:22 PM7/18/12
to
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.
Vasiliy Molostov
Jul 18, 2012, 4:57:42 PM7/18/12
to
Dmitry A. Kazakov <mai...@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.
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.
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.
gautier...@hotmail.com
Jul 18, 2012, 9:01:26 PM7/18/12
to
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.
NB: follow the above link for a valid e-mail address
"
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
Gautier's Ada programming
NB: follow the above link for a valid e-mail address
Maciej Sobczak
Jul 19, 2012, 3:45:19 AM7/19/12
to mai...@dmitry-kazakov.de
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?
> 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.
> It is interesting to speculate about the interface of an unordered set such
> that the clients could not exploit its ad-hoc order.
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
Dmitry A. Kazakov
Jul 19, 2012, 4:08:16 AM7/19/12
to
On Thu, 19 Jul 2012 00:57:42 +0400, Vasiliy Molostov wrote:
> Dmitry A. Kazakov <mai...@dmitry-kazakov.de> яПНяПНяПНяПНяПН(яПН) яПН яПНяПНяПНяПНяПН яПНяПНяПНяПНяПНяПН Wed,
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.
> Dmitry A. Kazakov <mai...@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?
>
>> 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)
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.
Dmitry A. Kazakov
Jul 19, 2012, 4:23:41 AM7/19/12
to
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�:
>> 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.
> 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.
>> 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.
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".
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.
sets incomputable programmatically. These could be unordered. E.g. it could
ask you if X belongs to S.
Vasiliy Molostov
Jul 19, 2012, 8:12:42 AM7/19/12
to
Dmitry A. Kazakov <mai...@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/
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
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/
Maciej Sobczak
Jul 19, 2012, 8:42:19 AM7/19/12
to mai...@dmitry-kazakov.de
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?
> > Membership test does not require any order.
> 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.
> >> 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.
> I guess it is related to computability.
> > 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.
> You need to enumerate elements to be able to compute it.
> 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.
Don't define general concepts in terms of current limited implementations on some crappy hardware.
Georg Bauhaus
Jul 19, 2012, 9:22:23 AM7/19/12
to
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.
> As for json this is a child of two: "ordered" and a "dict".
"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/
Dmitry A. Kazakov
Jul 19, 2012, 10:05:21 AM7/19/12
to
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�:
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.
> 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
>> >> 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.
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.
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).
incidence matrix, which is an equivalent to neurons wiring. But rows and
columns of the matrix are enumerated, that gives you an order.
Randy Brukardt
Jul 19, 2012, 10:51:05 PM7/19/12
to
"Vasiliy Molostov" <molo...@gmail.com> wrote in message
news:op.whoz7...@aspire.local...
...
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.
news:op.whoz7...@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.
Vasiliy Molostov
Jul 21, 2012, 1:01:29 PM7/21/12
to
Georg Bauhaus <rm.dash...@futureapps.de> писал(а) в своём письме Thu,
19 Jul 2012 17:22:23 +0400:
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/
19 Jul 2012 17:22:23 +0400:
Otherwise, array is not an object which is not correct, I suppose.
>
> http://www.json.org/
Vasiliy Molostov
Jul 21, 2012, 1:04:28 PM7/21/12
to
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 <ra...@rrsoftware.com> писал(а) в своём письме Fri, 20 Jul
2012 06:51:05 +0400:
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 <ra...@rrsoftware.com> писал(а) в своём письме Fri, 20 Jul
2012 06:51:05 +0400:
0 new messages