What exactly is the licensing situation with Gnat?

What exactly is the licensing situation with Gnat?

[Hubert]

So I am relatively new to Ada and I never really looked much into all 
the Open Source license models that are out there, so I don't know much 
about the differences. I'm trying to understand the particular situation 
that Adacore's Gnat package has.

Can someone please tell me if I am wrong here:

A) The compiler is basically GPL meaning anybody can copy it.
B) The Ada and Gnat libraries that come with it are also GPL so if you 
use them to write a program and give that program away you must also 
give away the source code.
C) If you buy the Pro version your receive the runtime libraries with a 
different license that allows you to sell a program written with them 
without giving out the code.

D) Here I am not sure: If you write a program that does not use the Ada 
and Gnat libraries, then you are not obliged to give away the source 
code as well since you dont use any GPL licensed code in your program?

E) What about the Ada.Standard library which is a pseudo library and 
built into the compiler? One has to use elements from that library, 
there's no way around that.



---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with Gnat?

[Markus Schöpflin]

No, there are basically three versions of Gnat:

1) FSF: Is GPL but contains an exception that allows you the create programs 
which are not GPL (basically the same as e.g. g++)

2) AdaCore Libre: Also GPL, but no exception. Hence your program is also GPL.

3) AdaCore Pro: Commercial and allows you to create programs which are not GPL.

Markus

Re: What exactly is the licensing situation with GNAT?

[Jacob Sparre Andersen]

Hubert wrote:

> I'm trying to understand the particular situation that Adacore's Gnat
> package has.

AdaCore distributes two "GNAT" packages:

1) GNAT Pro
2) GNAT GPL

You should be aware that the Free Software Foundation (FSF), Debian and
others distribute a third variant of GNAT, typically known as GNAT FSF.
GNAT FSF has more or less the same license as GNAT Pro, but the releases
tend to fall a bit behind GNAT Pro and GNAT GPL.

> A) The compiler is basically GPL meaning anybody can copy it.

True for both.

> B) The Ada and Gnat libraries that come with it are also GPL so if you
> use them to write a program and give that program away you must also
> give away the source code.

Not true for GNAT Pro.  True for GNAT GPL.

> C) If you buy the Pro version your receive the runtime libraries with
> a different license that allows you to sell a program written with
> them without giving out the code.

You don't buy GNAT Pro.  You buy a support contract.  With the support
contract you "magically" get access to GNAT Pro.

> D) Here I am not sure: If you write a program that does not use the
> Ada and Gnat libraries, then you are not obliged to give away the
> source code as well since you dont use any GPL licensed code in your
> program?

True for GNAT Pro.  Not necessarily true for GNAT GPL, as the run-time
library for GNAT GPL is plain GPL, and typically will be compiled into
your application.

> E) What about the Ada.Standard library which is a pseudo library and
> built into the compiler? One has to use elements from that library,
> there's no way around that.

If you compile your application with GNAT Pro, everything is fine.  If
you compile it with GNAT GPL, you should assume that the application is
plain GPL.


As I see it, the main reason for downloading and using GNAT GPL is to
get to play with the latest version of GNAT (without spending money on a
support contract).  If you want to be able to distribute your software
according to your preferred license, you should stick to GNAT FSF and/or
make enough money to pay for a support contract.

Greetings,

Jacob
-- 
"Universities are not part of the nation's security organisation,
 they are not the nation's research laboratory either: they are
 the nation's universities."                     -- E.W. Dijkstra

Re: What exactly is the licensing situation with GNAT?

[Hubert]

Ok, thanks everyone, I see that it is really complicated when you get 
down to the details, but in principle it's like if you sell a program, 
you need the Pro version or you use the FSF version which is most likely 
older and may not have all the feature or current bug fixes.

The good thing is that the GPL version allows me to play around and see 
if I can incorporate Ada tools into our project and then buy the pro 
version later, if it turns out to be useful.

---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Markus Schöpflin]

Am 10.11.2014 um 12:09 schrieb Hubert:

[...]

> The good thing is that the GPL version allows me to play around and see if I
> can incorporate Ada tools into our project and then buy the pro version later,
> if it turns out to be useful.

I would start with the FSF version and use the AdaCore versions only when you 
encounter bugs that are not easily worked around.

Markus

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> I would start with the FSF version and use the AdaCore versions only when you 
> encounter bugs that are not easily worked around.

Despite my open disdain for AdaCore's switch in licenses of their pubic versions to a GPL virus run time. I would say that it depends on platform and what you are looking to do if it makes sense to start with the FSF version or not.

On Windows for example until MinGW is updated to a more recent compiler and includes GPR tools you are probably better off with the GPL version regardless of use.

Based on what you wrote in previous posts, since your project would later on be looking at support best to start with the GPL version regardless of platform in my opinion.

David Botton

Re: What exactly is the licensing situation with GNAT?

[Hubert]

On 11/10/2014 7:45 AM, David Botton wrote:
>> I would start with the FSF version and use the AdaCore versions only when you
>> encounter bugs that are not easily worked around.
>
> Despite my open disdain for AdaCore's switch in licenses of their pubic versions to a GPL virus run time. I would say that it depends on platform and what you are looking to do if it makes sense to start with the FSF version or not.
>
> On Windows for example until MinGW is updated to a more recent compiler and includes GPR tools you are probably better off with the GPL version regardless of use.
>
> Based on what you wrote in previous posts, since your project would later on be looking at support best to start with the GPL version regardless of platform in my opinion.
>
> David Botton
>
Yes, plus I really need the GPS editor for my Ada code at the moment. I 
have no experience whatsoever with Emacs or Vim and I am somewhat 
addicted to having a hierarchy browser (I know we wrote big programs in 
the 90s without it but I couldn't imagine that anymore). I want to take 
a serious look at the new Slickedit version when it is released and then 
I hope I can use that to edit, compile and debug, since I'm having my 
problems with the debug environment in GPS it is a bit cumbersome with 2 
or 3 steps necessary to start a program under the debugger.


---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Georg Bauhaus]

On 11.11.14 01:09, Hubert wrote:
> I have no experience whatsoever with Emacs or Vim and I am somewhat addicted to having a hierarchy browser (I know we wrote big programs in the 90s without it but I couldn't imagine that anymore).

For the record, Emacs has speedbar, which (for Ada mode version 4.x)
displays a hierarchy of folders, Ada files, and the declarations
contained therein. These are grouped by kind. Clicking on a leaf displays
the corresponding item in the editor, in context.

Re: What exactly is the licensing situation with GNAT?

[Hubert]

On 11/11/2014 2:54 AM, Georg Bauhaus wrote:
> On 11.11.14 01:09, Hubert wrote:
>> I have no experience whatsoever with Emacs or Vim and I am somewhat
>> addicted to having a hierarchy browser (I know we wrote big programs
>> in the 90s without it but I couldn't imagine that anymore).
>
> For the record, Emacs has speedbar, which (for Ada mode version 4.x)
> displays a hierarchy of folders, Ada files, and the declarations
> contained therein. These are grouped by kind. Clicking on a leaf displays
> the corresponding item in the editor, in context.
>
Good to know, it sounds like some sort of browser after all. I will wait 
for Slick edit however since I had some experience with it in the past. 
At the moment it looks like it will take another month or two I guess, 
they still seem to have major stability problems although they are 
supposedly far in the testing process.


---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[john]

> Yes, plus I really need the GPS editor for my Ada code at the moment.

I would recommend using the GPS editor of Adacore GNAT GPL in combination with GNAT FSF as the compiler. That's what I do, and at least on Ubuntu it works fine. Just remember not to use any libraries provided by Adacore's GNAT.

Re: What exactly is the licensing situation with GNAT?

[Hubert]

On 11/11/2014 5:37 AM, john@peppermind.com wrote:
>
>> Yes, plus I really need the GPS editor for my Ada code at the moment.
>
> I would recommend using the GPS editor of Adacore GNAT GPL in combination with GNAT FSF as the compiler. That's what I do, and at least on Ubuntu it works fine. Just remember not to use any libraries provided by Adacore's GNAT.
>
I never thought about that combination, I thought you have to use the 
compiler that comes with GPS but it makes sense.

Speaking of this, what are the libraries that are specific to the GPL 
version? I know the Ada libraries are the language standard, so I assume 
all the Gnat libraries are extensions provided by Adacore?


---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[David Botton]

They essentially virused the standard Ada runtime. It is certainly a question if it would hold in truth legally, but basically even with no runtime they would claim your resulting executable is GPL.

David Botton 

Re: What exactly is the licensing situation with GNAT?

[Alan Jump]

On Tuesday, November 11, 2014 3:10:26 PM UTC-8, David Botton wrote:
> They essentially virused the standard Ada runtime. It is certainly a question if it would hold in truth legally, but basically even with no runtime they would claim your resulting executable is GPL.
> 
> David Botton

"Virused"?

'Splain, please.

Re: What exactly is the licensing situation with GNAT?

[David Botton]

Some viruses can be good, some viruses can be bad, and some viruses that are good are being abused.

By using the GPL in a compiler run time, initial boot loader code, etc. AdaCore places a  "license virus" on your software, i.e. regardless of your intended license it is now under the full GPL.

That may be a good thing for OS tools even compiler tools, etc. perhaps you may even prefer the GPL, but when placed in a compiler it is an abuse designed to make an open source compiler Shareware at best.

David Botton

Re: What exactly is the licensing situation with GNAT?

[Simon Clubley]

On 2014-11-12, David Botton <david@botton.com> wrote:
> Some viruses can be good, some viruses can be bad, and some viruses that are good are being abused.
>
> By using the GPL in a compiler run time, initial boot loader code,
> etc. AdaCore places a "license virus" on your software,
> i.e. regardless of your intended license it is now under the full GPL.
>
> That may be a good thing for OS tools even compiler tools,
> etc. perhaps you may even prefer the GPL, but when placed in a
> compiler it is an abuse designed to make an open source compiler

s/compiler/compiler's runtime/

surely ?

> Shareware at best.
>

And what no-one has mentioned so far this time around is that you
simply would not be having this conversation when talking about
normal C/C++ compilers.

This whole licence situation is yet another barrier in the way of
getting people to use Ada.

Simon.

PS: I've been around the Ada world long enough to remember the days
when GtkAda was GMGPL. That little fiasco killed my use of Ada in
GTK based front ends stone dead so I can understand how someone new
to the Ada world might look at the GPL compiler situation and then
go and choose another language which simply doesn't have those
issues.

-- 
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Microsoft: Bringing you 1980s technology to a 21st century world

Re: What exactly is the licensing situation with GNAT?

[Hubert]

On 11/11/2014 16:50 PM, David Botton wrote:
> Some viruses can be good, some viruses can be bad, and some viruses that are good are being abused.
>
> By using the GPL in a compiler run time, initial boot loader code, etc. AdaCore places a  "license virus" on your software, i.e. regardless of your intended license it is now under the full GPL.
>
> That may be a good thing for OS tools even compiler tools, etc. perhaps you may even prefer the GPL, but when placed in a compiler it is an abuse designed to make an open source compiler Shareware at best.
>
> David Botton
>

Ok, I was wondering about that for a while, hence my question about the 
GPL situation with the libraries. I was under the impressino that the 
thing that makes the resulting program GPL was the libraries and not the 
compiler, but this explains now why any output from the GPL compiler is 
GPL if the runtime that is essential to run the compiled program is also 
GPL.
The whole situation is not so easily understood and the explanation in 
the Libre Adacore package don't make it much clearer either. I was 
thinking if it is the Libraries only, one could omit them and write a 
new set of libraries, but this essentially rules that out.

Now this raises another question. I have been reading through the posts 
regarding Gnoga ( a great project by the way ) and it is my 
understanding that the applications developed with Gnoga can run on a 
server and the browser on the client side only render the output. How is 
the situation with that sort of stuff? If you write a server application 
that is never given out, can you do that with the GPL version?

---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> Ok, I was wondering about that for a while, hence my question about the 
> GPL situation with the libraries. I was under the impressino that the 
> thing that makes the resulting program GPL was the libraries and not the 
> compiler, but this explains now why any output from the GPL compiler is 
> GPL if the runtime that is essential to run the compiled program is also 
> GPL.

No, the GNAT GPL is a "special" case designed to virus software. The FSF versions do not contain code that would do that and so even though the compiler is GPL it does not produce executables that would be under the GPL unless you linked in some library that did that.

> The whole situation is not so easily understood and the explanation in 
> the Libre Adacore package don't make it much clearer either. I was 
> thinking if it is the Libraries only, one could omit them and write a 
> new set of libraries, but this essentially rules that out.

it is possible I am wrong about the binding code, but I am under the impression they hold that anything produced by their public compiler is GPL unless you have GNAT PRO.

> Now this raises another question. I have been reading through the posts 
> regarding Gnoga ( a great project by the way ) and it is my 
> understanding that the applications developed with Gnoga can run on a 
> server and the browser on the client side only render the output. How is 
> the situation with that sort of stuff? If you write a server application 
> that is never given out, can you do that with the GPL version?

Yes you can :) It is a loophole. Since you are not distributing your binaries only using them server side you do not have to share the source.

Honestly I am actually a fan of the GPL and hope you will when you can share the sources and of course changes and extensions to Gnoga as well.

The FSF versions do work with Gnoga as well. (For windows MinGW will be updated soon and will work and for Linux you need for now Debian sid)

David Botton

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> Honestly I am actually a fan of the GPL and hope you will when you can share the sources and of course changes and extensions to Gnoga as well.
>

Yes it is not bad for tools and stuff. Of course, when you write an 
application that you want to make money with, it's not so good. My first 
project I'll be working on soon is a text user interface library and I 
intend to make that public, although not many people will be interested 
in text output, but I think that for simple tools etc it is easier to 
have a simple UI that to get into all the overhead that a graphical UI 
comes with.




---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Gour]

On Wed, 12 Nov 2014 01:02:56 +0000 (UTC)
Simon Clubley <clubley@remove_me.eisner.decus.org-Earth.UFP> wrote:

> PS: I've been around the Ada world long enough to remember the days
> when GtkAda was GMGPL. That little fiasco killed my use of Ada in
> GTK based front ends stone dead so I can understand how someone new
> to the Ada world might look at the GPL compiler situation and then
> go and choose another language which simply doesn't have those
> issues.

You're right.

I was not at all thinking about it when considering to use Ada to write
(multi-platform) desktop app using GtkAda, but now I must say that it
sheds different light on using Ada for GUI app.

Too bad, considering people have some other language choices to consider
for the task...


Sincerely,
Gour

-- 
A person is said to be elevated in yoga when, having renounced 
all material desires, he neither acts for sense gratification 
nor engages in fruitive activities.

Re: What exactly is the licensing situation with GNAT?

[Pascal Obry]

Le mardi 11 novembre 2014 à 16:50 -0800, David Botton a écrit :
> By using the GPL in a compiler run time, initial boot loader code,
> etc. AdaCore places a "license virus" on your software, i.e.
> regardless of your intended license it is now under the full GPL.

Well another point of view is that it encourage Open Source softwares.
And after all we all know that we can sell Open Source software. The
only requirement is to make available the sources if someone ask for
them when you sell the software.

I bet this is in fact no big deal for many applications.

-- 
  Pascal Obry /  Magny Les Hameaux (78)

  The best way to travel is by means of imagination

  http://v2p.fr.eu.org
  http://www.obry.net

  gpg --keyserver keys.gnupg.net --recv-key F949BD3B

Re: What exactly is the licensing situation with GNAT?

[Gour]

On Tue, 11 Nov 2014 17:24:50 -0800 (PST)
David Botton <david@botton.com> wrote:

> Yes you can :) It is a loophole. Since you are not distributing your
> binaries only using them server side you do not have to share the
> source.

What is the possibility that the hole might be eliminated by Adacore
if e.g. Gnoga become (too) popular allowing people to take advantage of
it without getting into Pro contracts (which is probably anyway too
expensive for smaller players)?


Sincerely,
Gour

-- 
Before giving up this present body, if one is able to tolerate 
the urges of the material senses and check the force of desire and 
anger, he is well situated and is happy in this world.

Re: What exactly is the licensing situation with GNAT?

[Simon Wright]

David Botton <david@botton.com> writes:

> It is certainly a question if it would hold in truth legally, but
> basically even with no runtime they would claim your resulting
> executable is GPL.

What would you have copied? It's the *runtime* that has had the
*runtime* exception rmoved from it.

Re: What exactly is the licensing situation with GNAT?

[Simon Wright]

Simon Clubley <clubley@remove_me.eisner.decus.org-Earth.UFP> writes:

> PS: I've been around the Ada world long enough to remember the days
> when GtkAda was GMGPL.

"was" -> "stopped being" ?

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> Well another point of view is that it encourage Open Source softwares.
> And after all we all know that we can sell Open Source software. The
> only requirement is to make available the sources if someone ask for
> them when you sell the software.
>
> I bet this is in fact no big deal for many applications.
>
That is basically correct. Of course it depends on the situation. Fir 
instance, I licensed a 3D graphics engine some 2 years ago. It cost 
about 500$ at the time. You would get the complete source code with it.

However the variable names were so cryptic, and there were absolutely no 
comments in the source code, I mean zero, nada, I have never ever seen 
such a void in my life. I believe the developer was using a tool to 
remove all comments before he gave out the source.

The effect was really that you could hardly use the code to do anything 
like fixing a problem or adding a feature. Analyzing the source, say to 
write your own engine would be a complete waste of time. So I guess 
handing out the source code is not the terrible thing that closed source 
developer might think it is.

I am thinking about releasing the source of our game client too in the 
future (it's in C++) so that maybe people can develop their own client 
based on it. But of course I would never give out the code to the server 
part since that's where the money is generated.


---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Simon Wright]

Hubert <herrdoktor@fumanchu.com> writes:

> Ok, I was wondering about that for a while, hence my question about
> the GPL situation with the libraries. I was under the impressino that
> the thing that makes the resulting program GPL was the libraries and
> not the compiler, but this explains now why any output from the GPL
> compiler is GPL if the runtime that is essential to run the compiled
> program is also GPL.

GCC itself has always been GPL; WindRiver, for example, have always
provided GCC as one of the compilers their customers could use to build
proprietary applications.

To quote from the GNU Licences FAQ[1],

   The GCC Runtime Library Exception covers libgcc, libstdc++,
   libfortran, libgomp, libdecnumber, and other libraries distributed
   with GCC. The exception is meant to allow people to distribute
   programs compiled with GCC under terms of their choice, even when
   parts of these libraries are included in the executable as part of
   the compilation process.

and from the GCC Runtime Library Exception Rationale[2],

   [...]  the FSF decided long ago to allow developers to use GCC's
   libraries to compile any program, regardless of its
   license. Developing nonfree software is not good for society, and we
   have no obligation to make it easier. We decided to permit this
   because forbidding it seemed likely to backfire, and because using
   small libraries to limit the use of GCC seemed like the tail wagging
   the dog.

This is why the FSF GCC Ada runtime _does_ carry the Runtime Library
Exception.

The last sentence is, of course, borne out by this present row.

> The whole situation is not so easily understood and the explanation in
> the Libre Adacore package don't make it much clearer either. I was
> thinking if it is the Libraries only, one could omit them and write a
> new set of libraries, but this essentially rules that out.

For info, which explanation? I've certainly heard what I considered to
be misleading statements on this from AdaCore, but that could well have
been because they were trying to persuade management and I was only
present as technical assistance.

You could write a new set of libraries (probably working from the FSF
compilers) but that would be a large task (mammoth if you started from
scratch, and moreover a moving target).

[1] http://www.gnu.org/licenses/gpl-faq.html#LibGCCException
[2] http://www.gnu.org/licenses/gcc-exception-faq.html

Re: What exactly is the licensing situation with GNAT?

[Simon Wright]

David Botton <david@botton.com> writes:

>> Now this raises another question. I have been reading through the
>> posts regarding Gnoga ( a great project by the way ) and it is my
>> understanding that the applications developed with Gnoga can run on a
>> server and the browser on the client side only render the output. How
>> is the situation with that sort of stuff? If you write a server
>> application that is never given out, can you do that with the GPL
>> version?
>
> Yes you can :) It is a loophole. Since you are not distributing your
> binaries only using them server side you do not have to share the
> source.

You might be interested in the Affero GPL?
http://www.gnu.org/licenses/why-affero-gpl.html

Re: What exactly is the licensing situation with GNAT?

[Simon Wright]

David Botton <david@botton.com> writes:

>> The whole situation is not so easily understood and the explanation
>> in the Libre Adacore package don't make it much clearer either. I was
>> thinking if it is the Libraries only, one could omit them and write a
>> new set of libraries, but this essentially rules that out.
>
> it is possible I am wrong about the binding code, but I am under the
> impression they hold that anything produced by their public compiler
> is GPL unless you have GNAT PRO.

They would, wouldn't they.

http://en.wikipedia.org/wiki/Mandy_Rice-Davies#.22He_would.2C_wouldn.27t_he.3F.22

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> You could write a new set of libraries (probably working from the FSF
> compilers) but that would be a large task (mammoth if you started from
> scratch, and moreover a moving target).

Well I was more talking hypothetically, I certainly have no urge to do 
that. I just recently dropped a huge proprietary library we were using 
for 10 years or so in order to move to STL for the first time and I 
appreciate the power these libraries offer over smaller proprietary ones.



---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> You might be interested in the Affero GPL?
> http://www.gnu.org/licenses/why-affero-gpl.html

No I'm not writing anything that I want to protect for myself. I'm just 
trying to understand what the situation with Ada is since we are 
discussing a port to Ada as a possibility, however that would still be a 
few years in the future to be realistic, for the time being it is just 
inhouse tool programming, but I am always in favor of checking out 
feasibility first before I spend a considerable amount of time getting 
into a matter only to find out that a simple issue makes my whole effort 
obsolete. That's why I usually ask for the price of a program before I 
download the trial version and if I don't get that info, I know it's 
because the price is exorbitant.

I know Ada would be well suited for our project from a language point of 
view, the question is now what about the license situation. In general 
the move (meaning getting the pro license) would only be feasible if our 
project in the current version generates enough money (which we won't 
know before next year), since I know the price is in the 10K$ range. If 
not I will take a hard look at the FSF version, what puts me off for the 
time being is the comments I read so far that the FSF version is behind 
the GPL version, however I don't know yet in what particular way, if 
it's missing language features, missing libraries, having bugs that are 
fixed in the GPL version etc.




---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Thomas Jahrne]

On 2014-11-12, Pascal Obry <pascal@obry.net> wrote:
> Le mardi 11 novembre 2014 ?? 16:50 -0800, David Botton a ??crit :
>> By using the GPL in a compiler run time, initial boot loader code,
>> etc. AdaCore places a "license virus" on your software, i.e.
>> regardless of your intended license it is now under the full GPL.
>
> Well another point of view is that it encourage Open Source softwares.
> And after all we all know that we can sell Open Source software.

Although that is technically true it doesn't happen often. Especially it's a
little funny in this context since Adacore doesn't sell GNAT they just sell
the support. But there is a little gotcha since you can't get the toolchain
unless you buy support for it.

All funded with U.S. taxpayer money.

I call BULLSHIT.

> I bet this in fact no big deal for many applications.

Again in the context of Ada where everything is virtually 100% defence and
the remainder government projects it is certainly a big deal and you will
never see this source code. Which is why they are able to get people to buy
their toolchain oops I meant support for their toolchain.

Thomas

Re: What exactly is the licensing situation with GNAT?

[Mark Carroll]

Hubert <herrdoktor@fumanchu.com> writes:

> If not I will take a hard look at the FSF version, what puts me off
> for the time being is the comments I read so far that the FSF version
> is behind the GPL version, however I don't know yet in what particular
> way, if it's missing language features, missing libraries, having bugs
> that are fixed in the GPL version etc.

I also have the impression that there's a lack of assurance that
bug-fixes, etc. will keep flowing to the FSF version, and there's a
shortage of cheap or free alternatives for compiling closed code?
(It's not like I am funded by CPFF contracts from DoD BAAs.)

I had been looking at creating an GUI application that would have to
work well on Windows, so I also have a bit of work to do in
understanding more about the dependency on MinGW for that, but maybe
that's all transparent and wonderful, just new to me.

I don't need to make language decisions right now, but all this is
keeping me nervously on the fence; I don't want to commit to a direction
for which affordable support is in danger of withering and, while I had
thought it a good idea to use a coming project to learn and try out Ada,
it is not like I am having to develop near-real-time embedded systems or
suchlike.

-- Mark

Re: What exactly is the licensing situation with GNAT?

[Mark Carroll]

Pascal Obry <pascal@obry.net> writes:

> Le mardi 11 novembre 2014 à 16:50 -0800, David Botton a écrit :
>> By using the GPL in a compiler run time, initial boot loader code,
>> etc. AdaCore places a "license virus" on your software, i.e.
>> regardless of your intended license it is now under the full GPL.
>
> Well another point of view is that it encourage Open Source softwares.
> And after all we all know that we can sell Open Source software. The
> only requirement is to make available the sources if someone ask for
> them when you sell the software.
>
> I bet this is in fact no big deal for many applications.

In the case of the full GPL, the requirements are far more than that!
The customer have the ability to tweak and sell it themselves, etc.

-- Mark

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> I don't need to make language decisions right now, but all this is
> keeping me nervously on the fence; I don't want to commit to a direction
> for which affordable support is in danger of withering and, while I had
> thought it a good idea to use a coming project to learn and try out Ada,
> it is not like I am having to develop near-real-time embedded systems or
> suchlike.
>
> -- Mark
>

Well from what I have learned so far, I see the situation as follows:
- If you want to make and release full GPL software you're good to go 
with the GPL version of Ada
- If you write code for Missiles or Nuclear Power Plants, you're good to 
go with the Pro version
- If you're a little guy wanting to write a professional piece of 
software that you want to sell but it is not mission critical you are 
somewhat hanging in the air.

It is my opinion that what is missing is some sort of intermediate 
license for people who just want to write small scale applications and 
don't have the security requirements of big projects adn thus don't need 
the support that Adacore offers. Something like Turbo Pascal in the past 
or maybe even Visual Studio in the Personal Edition or so.

Personally I wouldn't mind paying a few 100$ right now for a license 
that would allow me to write closed source applications even if I get no 
support or just some way to report bugs which may or may not be fixed 
later. I don't need a minuteman response if I find a bug with Ada (which 
is more than unlikely to happen anyway). the current Pro license is 
something I consider but only given our particular situation where we 
sell a product first and then rewrite part or all of it in Ada and have 
the money to get the license. I would not consider it if I were to start 
a brand new project of which I have no idea how the sales situation will be.

So something like a personal license that would be nice to have.





---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Georg Bauhaus]

On 12.11.14 10:08, Thomas Jahrne wrote:
> Especially it's a
> little funny in this context since Adacore doesn't sell GNAT they just sell
> the support.

No.

https://archive.fosdem.org/2012/interview/robert-dewar

Find "sell".

In the corresponding video, the president of said company more emphatically
states that they do sell software. Have you seen one AdaCore contract?

> But there is a little gotcha since you can't get the toolchain
> unless you buy support for it.

No.

What part of the AdaCore tool chain centered around GNAT can one not
get for free, and compatibly with both FOSS and closed source development?
The GNAT stuff, GPS, etc. are also available as part of Linux systems.

(The other remarks: about trains in France, the UK, and elsewhere, as well
as cars from Japan being 100% run by the military seem to lend themselves
to an estimation of their value.)

Re: What exactly is the licensing situation with GNAT?

[jm.tarrasa]

> - If you're a little guy wanting to write a professional piece of 
> software that you want to sell but it is not mission critical you are 
> somewhat hanging in the air.

10K$/seat makes no sense. Obviously Adacore is not interested in you.

There is a market of deep pockets for Ada (so far), but there is no market of small Ada developers. They have locked customers with deep pockets and  no competence, so they are not interested in other market.

You could argue that such market is shrinking and could die.
So? 
Gnat investment was recovered long ago (did they invest or was DoD's investment?). Now they have no advertising costs, almost no development costs (what they have? a developer? two?) whatever they get from deep pockets is almost net profit. 
Creating a market for Ada small developers would mean to create an ecosystem, compete against other languages. Why should they invest such amount of resources in an uncertain adventure? 

so, when the deep pockets market die, they'll let Gnat die. You are not in the equation.

Re: What exactly is the licensing situation with GNAT?

[J-P. Rosen]

Le 12/11/2014 11:31, jm.tarrasa@gmail.com a écrit :
Please do not spread information that you know nothing about (and I am
not an employee of AdaCore).

> [...] Now they have no advertising costs

They are certainly the company that invests the most in advertising, for
example by actively supporting Ada associations (including Ada-France
and Ada-Europe), providing material (recently, Ada-France had a booth at
Linux expo, where we distributed Barnes book and other valuable
material, provided free of charge by AdaCore), etc...

> almost no
>> development costs (what they have? a developer? two?)
They have tens of developers, actively improving the compiler and
environment tools.

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> There is a market of deep pockets for Ada (so far), but there is no market of small Ada developers. They have locked customers with deep pockets and  no competence, so they are not interested in other market.

I agree here. I guess though it's a bit of a chicken-egg problem. 
without software to get one started with Ada, there is no incentive to 
use Ada over C++ but without little guys using Ada, there is little 
incentive to write software others could use.

The Gnoga project might be something to get people started though. Part 
of what put me off two years ago was that Gtk wasn't working very well 
for me. The layout editor was messing up half my screen and looked not 
very user friendly, so my conclusion was without a decent User Interface 
library it makes little sense for me to invest more time.



---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Simon Wright]

Hubert <herrdoktor@fumanchu.com> writes:

>> You might be interested in the Affero GPL?
>> http://www.gnu.org/licenses/why-affero-gpl.html
>
> No I'm not writing anything that I want to protect for myself.

I was aimng that remark more at David.

Re: What exactly is the licensing situation with GNAT?

[David Botton]

No possibility since FSF gnat works just as well.

David Botton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> Well another point of view is that it encourage Open Source softwares.

Not true and the reason the FSF compilers do not encumber their executables like AdaCore's GPL version. Even they, who are the father of Free software advocates, know that the GPL in this context is a poison to advocating the use of the GPL itself.

David Botton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

>was not at all thinking about it when considering to use Ada to write
> (multi-platform) desktop app using GtkAda, but now I must say that it
> sheds different light on using Ada for GUI app.

Thankfully you can use Gnoga now and an FSF compiler :)

David Botton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> It is my opinion that what is missing is some sort of intermediate 
> license for people who just want to write small scale applications and 
> don't have the security requirements of big projects adn thus don't need 
> the support that Adacore offers.

I had a meeting this last Monday with AdaCore with a business model to make that possible and lucrative for them.

With or without them, I have a solution to this currently in the works and I'll give them a bit of time before I push the sans AdaCore solution.

I would rather do it with them despite what they did to the community with the GPL version, total disregard of it, they have put in the work on the compiler and the language that deserves giving them a chance to be part of the solution.

David Botton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

>(what they have? a developer? two?) 

Huh? I can tell you right now they have a huge team and top notch. I don't like a decision they make but this is false information. There is tons of development going on.

David Botton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> > No I'm not writing anything that I want to protect for myself.
> 
> I was aimng that remark more at David.

That is the bomb against the loophole, I don't want it closed. I'd almost say to not let people know about that effort :)

David Botton

Re: What exactly is the licensing situation with GNAT?

[Pascal Obry]

Le mercredi 12 novembre 2014 à 03:05 -0800, David Botton a écrit : 
> > Well another point of view is that it encourage Open Source softwares.
> 
> Not true and the reason the FSF compilers do not encumber their
> executables like AdaCore's GPL version. Even they, who are the father
> of Free software advocates, know that the GPL in this context is a
> poison to advocating the use of the GPL itself.

But then if the FSF compiler is used to create Open Source software
that's fine. But then again, what's wrong with the GPL one? At the end
you have an Open Source software :)

I understand that GNAT FSF can be used for closed sources software, but
again how many they are? I'm not saying there is nothing, but as I said
in my first post the GPL do cover the most majority of Ada projects
needs.

Regards,

-- 
  Pascal Obry /  Magny Les Hameaux (78)

  The best way to travel is by means of imagination

  http://v2p.fr.eu.org
  http://www.obry.net

  gpg --keyserver keys.gnupg.net --recv-key F949BD3B

Re: What exactly is the licensing situation with GNAT?

[Gour]

On Wed, 12 Nov 2014 02:44:28 -0800
Hubert <herrdoktor@fumanchu.com> wrote:

> The Gnoga project might be something to get people started though.

I'm still not fully sold out on Gnoga and admit that (maybe) I'd be
happier having choice of maintained/stable wx/Qt bindings for
multi-platform GUI app.

> Part of what put me off two years ago was that Gtk wasn't working
> very well for me. The layout editor was messing up half my screen and
> looked not very user friendly, so my conclusion was without a decent
> User Interface library it makes little sense for me to invest more
> time.

...and hearing about yout past Gtk experience is not encouraging,
although Ada itself looks as one of the rare sane choices.


Sincerely,
Gour

-- 
A person who is not disturbed by the incessant flow of 
desires — that enter like rivers into the ocean, which is 
ever being filled but is always still — can alone achieve 
peace, and not the man who strives to satisfy such desires.

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> But then if the FSF compiler is used to create Open Source software
> that's fine. But then again, what's wrong with the GPL one? At the end
> you have an Open Source software :)

Because for businesses that doesn't work. Most people like me who are happy to write and share GMGPL and GPL software are often making a living for companies that _WILL NOT_ allow GPL executables with their corporate IP mixed in.

So a GPL compiler _kills_ Ada use for everyone but those developing OS tools or other such projects.

We want to advocate Ada and the GPL on the runtime _HURTS_ it not helps it.

> I understand that GNAT FSF can be used for closed sources software, but
> again how many they are?

More than you can ever imagine. People are not posting their closed source use, but I can tell you that I've written more closed source Ada than public and so have most here.


> I'm not saying there is nothing, but as I said
> in my first post the GPL do cover the most majority of Ada projects
> needs.

That is _COMPLETELY_ false information and the same ridiculous argument I've heard from AdaCore trying to justify their shortsighted and harmful decision to GPL Virus the compiler and make it Shareware. They turned GNAT in to a toy.

The _reality_ is that the GPL compiler killed tons of __GPL__ projects and even more GMGPL projects.

Add to that the the GPL compiler has completely closed down all advocacy of Ada for the business world.

I'm going to make sure that changes :) hopefully with AdaCore, but even if without.

David Botton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> I'm still not fully sold out on Gnoga and admit that (maybe) I'd be
> happier having choice of maintained/stable wx/Qt bindings for
> multi-platform GUI app.

Nothing truly is for everyone :)

However once I have the native clients (which could even be using Qt) to build executables with embedded browsers and Gnoga it will replace most need and be far more compatible across platforms that Qt or Gtk.

Plus I should have native client for Android and eventually iOS coming.

The Gnoga project beyond the framework and coming tools is to push Ada to the business world and that will include fixing the GNAT image and providing solid professional use Ada compilers (with or without AdaCore, the offer is on AdaCore's table now, we will see).

David Botton

Re: What exactly is the licensing situation with GNAT?

[G.B.]

On 12.11.14 13:31, David Botton wrote:
> Add to that the the GPL compiler has completely closed down all advocacy of Ada for the business world.

Has the GPL branch produced an opportunity for other compiler makers?
I understand that they, too, would mostly require customers with
deeper pockets.

As a new customer, I would be

(1) needing an affordable compiler (Ada 2005, generics working)
(2) be fine with reduced support (cf. Apple, MS, etc.!)

and compiler vendors would need

(3) protection against freeloaders destroying their full support
business.

For (3) to work, have contracts include a clause that limits
customers who want to employ the affordable compiler in unjust
enrichment.

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Wed, 12 Nov 2014 02:44:28 -0800, Hubert wrote:

> Part 
> of what put me off two years ago was that Gtk wasn't working very well 
> for me. The layout editor was messing up half my screen and looked not 
> very user friendly,

That likely is because GTK's philosophy of dealing with the layout is
different from the traditional fixed-layout approach as known in Windows
GDI or Delphi.

GTK's idea (similar to TeX, BTW) is that the layout and all widgets must be
resizable by default. Which is IMO far more natural, at least for desktop
applications. One of the advantages is that the UI looks well in all screen
resolutions, provided designed correctly. However, it may require a bit
more mental efforts while designing the layout and some courage not to go
easy GLADE path.

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

Re: What exactly is the licensing situation with GNAT?

[Jacob Sparre Andersen]

Hubert <herrdoktor@fumanchu.com> wrote:

> - If you're a little guy wanting to write a professional piece of
> software that you want to sell but it is not mission critical you are
> somewhat hanging in the air.

You should consider if Janus/Ada is relevant for you.  It has some
limitations (for Microsoft Windows, only Ada 95), but it also comes with
what appears to be the most Ada friendly Ada GUI library available
(CLAW).

Greetings,

Jacob
-- 
Growing older is compulsory. Growing up isn't.

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> > Add to that the the GPL compiler has completely closed down all advocacy of Ada for the business world.
> 
> Has the GPL branch produced an opportunity for other compiler makers?

The opportunity is there, however none have taken it. Partly because unfamiliarity with how to monetize Open Source projects, which in the case of most companies to date it is through selling "Support" not the code or executables as the product.

> I understand that they, too, would mostly require customers with
> deeper pockets.

It is not required. It is one market. The problem is that Ada vendors got lazy pursuing other venues since there was easy pickin' on the government cheese.

> As a new customer, I would be
> 
> (1) needing an affordable compiler (Ada 2005, generics working)
> (2) be fine with reduced support (cf. Apple, MS, etc.!)

And you are the majority software developers even for Ada. I placed a business proposal in AdaCore's hands this last Monday to target your market. That proposal lays out how I plan on doing it with their being part or not.


> and compiler vendors would need
> 
> (3) protection against freeloaders destroying their full support
> business.

No, what they need is a good product. AdaCore has that. No one that can afford their support walks away because of bad service. It was shortsighted thinking on their part to make their public version Shareware killing off all startups and serious business investments in Ada.

That is my goal to correct that. I'll be posting various aspects of the Gnoga business model soon, today I will be starting with its goals in another post.

> For (3) to work, have contracts include a clause that limits
> customers who want to employ the affordable compiler in unjust
> enrichment.

Unjust.... I am afraid that thinking is pre-the FSF movement, Gnat is built on GCC and has to be released GPL and the US taxpayer money which also required it be freely available, etc.

Would you say it is unjust that AdaCore is profiting on GCC?

AdaCore has _not been_ unjust, even though not super timely, they have given back to the FSF updates.

They are just outside the "spirit" and "intent" of the above and doing things to hurt Ada advocacy outside of their niche market.

Yes Stallman's position is that he wished he could put a GPL Virus in the compiler, but he states clearly he _didn't_ to advocate the use of Free software...

So let's see AdaCore is not encouraging Free software development OR Ada advocacy by having replaced the runtime on their public version.

What they did was create a Shareware version of GNAT that is intended to make others think that GNAT can not be used for professional use if not their Pro version.

I still am happy they still put out the GPL version despite that it is Shareware. Since without it they would have totally killed the Ada community not just maimed it. 

I am certainly hoping they continue to put out a GPL version but I am pushing and _investing_ time and money with the hope they will match to go back to GMGPL and be part of the new movement to push Ada for general purpose application development.

David Botton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> You should consider if Janus/Ada is relevant for you.  It has some
> limitations (for Microsoft Windows, only Ada 95), but it also comes with
> what appears to be the most Ada friendly Ada GUI library available
> (CLAW).

CLAW and Janus, having used both are a _very_ nice top notch compiler and library combo.

However, GWindows and GNATCOM (http://sourceforge.net/projects/gnavi/) are more capable, very well maintained, open source, and easier to use and they work well with the windows FSF version of GNAT that comes with MinGW. You can use Ada 2005 and Ada 2012 with them as a result too.

Despite the lack of PR (not sure why they are not listed in the AdaIC.org list of packages for example. It is probably the largest ada framework used outside of those distributed today by AdaCore in the world.

When I created them they were placed under the GMGPL so you can enjoy using them in commercial products and I have and hundreds others do.

When I abandoned public Ada projects and advocacy ten years ago, _because_ those libraries are open source people like Gautier de Montmollin and others were willing to get involved and are even running the show on them now. So Open Source is a critical part of success today. You just have to be creative to know how to monetize it.

For application development MinGW is absolutely usable for professional development.

Same goes for other platform GNATs and you should have no qualms of using it for non-safety critical work.

David Botton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

Ok it is probably an exaggeration that GWindows / Gnatcom is the largest non AdaCore framework, some older stuff like Booch components etc probably still beat it. :)

David Botton

Re: What exactly is the licensing situation with GNAT?

[Gour]

On Wed, 12 Nov 2014 04:38:34 -0800 (PST)
David Botton <david@botton.com> wrote:

> However once I have the native clients (which could even be using Qt)
> to build executables with embedded browsers and Gnoga it will replace
> most need and be far more compatible across platforms that Qt or Gtk.

Well, I mentioned wx and Qt since both are suitable for desktop apps
offering rich set of widgets. Wx provides native look on Mac/Win -
nothing against GTK being 'native' on Linux, although there is work on
wxQt port as well. Otoh, Qt is also very rich toolkit and with good
support, even for monibile OS-es.

It seems that Gnoga *could* be able to be used instead. Moreover, let me
say that "It doesn't matter if a cat is black or white, so long as it
catches mice." ;)

> Plus I should have native client for Android and eventually iOS
> coming.

How would that go along with desktop clients?

> The Gnoga project beyond the framework and coming tools is to push
> Ada to the business world and that will include fixing the GNAT image
> and providing solid professional use Ada compilers (with or without
> AdaCore, the offer is on AdaCore's table now, we will see).

This is very noble attempt - Ada looks as capable as all other so called
'modern' languages both in terms of features and performance as well, so
if you succeed in your attempt, it will be great service for Ada
community. I'm very thankful to you for it!!


Sincerely,
Gour

-- 
One who is not disturbed in mind even amidst the threefold 
miseries or elated when there is happiness, and who is free 
from attachment, fear and anger, is called a sage of steady mind.

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> How would that go along with desktop clients?

Gnoga uses the same code base for desktop, web or mobile.

On desktop and android/ios instead of websockets it is possible to just get a direct hook in to the webkit/ie/gecko engine and talk direct. I have some concept code for webkit on Mac and ie and tested a few methods for gecko (XULRunner). It is a lower priority for the moment since can run on all those platforms with websockets now.

> Ada looks as capable as all other so called
> 'modern' languages both in terms of features and performance as well

I believe more so :)

David Botton

Re: What exactly is the licensing situation with GNAT?

[Simon Wright]

David Botton <david@botton.com> writes:

> Ok it is probably an exaggeration that GWindows / Gnatcom is the
> largest non AdaCore framework, some older stuff like Booch components
> etc probably still beat it. :)

There have been 412 downloads of the BCs from Sourceforge[1] in the year
to date, to my surprise.

The last open ticket was created in January 2007.

I must admit I haven't checked the BCs out with Ada 2012 ...

[1] http://sourceforge.net/p/booch95/

Re: What exactly is the licensing situation with GNAT?

[john]

> Yes Stallman's position is that he wished he could put a GPL Virus in the compiler

Have you talked to him personally about that? To me this seems like a pretty unfair statement, given that most if not all other FSF-backed programming languages do not encumber executables with the GPL.

The runtime engine should have been put under LGPL and wasn't (perhaps because LGPL didn't exist at that time?), but I would be surprised to hear that this was in any way RMS's decision. 

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> Have you talked to him personally about that? To me this seems like a pretty unfair statement, given that most if not all other FSF-backed programming languages do not encumber executables with the GPL.

He wrote it on the FSF website and why he chose _not_ to GPL the runtimes.

> The runtime engine should have been put under LGPL and wasn't (perhaps because LGPL didn't exist at that time?), but I would be surprised to hear that this was in any way RMS's decision.

The FSF of the GNAT version is not encumbered and no, he would not do such a thing for the same reasons he wrote in general about not making the other GCC runtimes GPL. This was an AdaCore decision to Shareware a version of the compiler they put out publicly. Disclaimer: AdaCore have every right to do so as well.

David Botton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> He wrote it on the FSF website and why he chose _not_ to GPL the runtimes.

This was quoted earlier I think:

"However, the FSF decided long ago to allow developers to use GCC's libraries to compile any program, regardless of its license. Developing nonfree software is not good for society, and we have no obligation to make it easier. We decided to permit this because forbidding it seemed likely to backfire, and because using small libraries to limit the use of GCC seemed like the tail wagging the dog."

So now for Ada this would not only be like the tail wagging the dog, but the toe jam wagging the dog.....


David Botton

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Hubert" <herrdoktor@fumanchu.com> wrote in message 
news:zTF8w.509165$No4.167804@fx19.iad...
...
> - If you're a little guy wanting to write a professional piece of software 
> that you want to sell but it is not mission critical you are somewhat 
> hanging in the air.

You could of course use a different, commercial Ada compiler, rather than 
insisting on GNAT. At least Janus/Ada still costs $195 for the personal 
version and $500 for the professional version. See www.rrsoftware.com. 
(Disclaimer for new people here, I'm a co-founder and primary author of 
Janus/Ada, so I'm a bit biased. :-)

> It is my opinion that what is missing is some sort of intermediate license 
> for people who just want to write small scale applications and don't have 
> the security requirements of big projects adn thus don't need the support 
> that Adacore offers. Something like Turbo Pascal in the past or maybe even 
> Visual Studio in the Personal Edition or so.

Aonix used to have an ObjectAda version like that, but I heard that they got 
rid of it as they couldn't afford to support it. Janus/Ada is in that price 
range as well, but I have to admit the same is true -- there isn't enough 
business to justify working on it full-time. I have to do standardization 
stuff and ACATS stuff to make ends meet.

> Personally I wouldn't mind paying a few 100$ right now for a license that 
> would allow me to write closed source applications even if I get no 
> support or just some way to report bugs which may or may not be fixed 
> later.

See note about Janus/Ada above. ;-)

                   Randy Brukardt, R.R. Software, Inc.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Hubert" <herrdoktor@fumanchu.com> wrote in message 
news:aSG8w.567817$Q61.266688@fx13.iad...
...
> The Gnoga project might be something to get people started though. Part of 
> what put me off two years ago was that Gtk wasn't working very well for 
> me. The layout editor was messing up half my screen and looked not very 
> user friendly, so my conclusion was without a decent User Interface 
> library it makes little sense for me to invest more time.

Unfortunately, if it is like most of David's other software, it won't work 
on other Ada compilers. (That is a common problem, not really picking on 
David here, a lot of supposedly Ada software is really GNAT software.) That 
locks you into GNAT, and as you note, the costs for getting regular support 
for GNAT are not really affordable.

One of the reasons we built Claw was to provide a Windows interface that 
would work on any Ada 95 compiler for Windows, not just GNAT. That requires 
displine and testing that most hobbyests wouldn't bother with.

                                         Randy.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"David Botton" <david@botton.com> wrote in message 
news:bb4c0cb4-65d3-4081-a47f-10e87bcd91f1@googlegroups.com...

>> You should consider if Janus/Ada is relevant for you.  It has some
>> limitations (for Microsoft Windows, only Ada 95), but it also comes with
>> what appears to be the most Ada friendly Ada GUI library available
>> (CLAW).

>CLAW and Janus, having used both are a _very_ nice top notch compiler and 
>library combo.

>However, GWindows and GNATCOM (http://sourceforge.net/projects/gnavi/) are 
>more capable, very well >maintained, open source, and easier to use and 
>they work well with the windows FSF version of GNAT that comes >with MinGW. 
>You can use Ada 2005 and Ada 2012 with them as a result too.

GWindows is still GNAT-only, right? If you want to use a different Ada 
compiler, Claw is really your only option.

>Despite the lack of PR (not sure why they are not listed in the AdaIC.org 
>list of packages for example.
>It is probably the largest ada framework used outside of those distributed 
>today by AdaCore in the world.

The AdaIC page is a list of locations to look for free software, not a "list 
of packages". GWindows is in libre (at least it used to be), so it doesn't 
get a separate listing. The same is true Dmitry's various packages, Tero's 
stuff, and so on.

The page really is just a listing of places to look, and it mainly is just a 
list of links that we feed to the search engine. The intent was that the way 
to find any package was to use the search engine 
(http://www.adaic.org/ada-resources/ada-on-the-web/) to find possibilities.

(Besides, I thought AdaPower had such a list of packages. Which hasn't been 
updated in forever... :-)

                                                          Randy.

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> Unfortunately, if it is like most of David's other software, it won't work 
> on other Ada compilers

Not true. Janus is the only Windows compiler with an issue.

There was an ABI issue with using Janus that was too much effort for me to consider as a volunteer effort for  a non Open Source compiler, however, GnatCOM was used  on Aonix OpenAda and in Rational's Ada compiler. Privately I can give you a list of projects where I know it was used if you like not on GNAT.

I do not know if GWindows was used on other compilers, but other than the fact that I tend to use Object'Img there is nothing GNAT specific about the project. Since GNAT is the only open source compiler, it is the only one I choose to support until there are others.


> That requires displine and testing that most hobbyests wouldn't bother with.

I think that you confuse Open Source developers with "Hobbyest", that is usually not the case at all.

GnatCOM was a professional supported product by GNAT.

GWindows is used as a professional product by fortune 500 companies. I didn't go through with my plan 10 years ago with bringing Ada to the business sector because of license changes in GNAT to the public version and various other issues. Using FSF compilers in those days was not a big option.

There is nothing in Gnoga other than the use again of Object'Img preventing it from being used on Janus if it ever gets updated to Ada 2012. I'd be happy to help you do the work to replace AWS if needed with your own implementation of Websockets, etc.

I think that for many people they have not "figured" out how to make Open Source work to their advantage. It has in my career. 

I'd be happy to talk to you privately any time about how to make Janus work in an Open Source environment provided you could open it. If you can't perhaps we can talk about options for a new Open Source compiler. I really liked Janus.

Your CLAW Open Source version came too late, if it was a year before I probably would have forked it and used it instead of created GWindows.

David Botton

Re: What exactly is the licensing situation with GNAT?

[Britt]

On Wednesday, November 12, 2014 5:47:24 PM UTC-5, Randy Brukardt wrote:

> 
> You could of course use a different, commercial Ada compiler, rather than 
> insisting on GNAT. At least Janus/Ada still costs $195 for the personal 
> version and $500 for the professional version. See www.rrsoftware.com. 

Randy,

I remember buying one of your early versions of of Janus Ada for $99. It might have been around 1989 or so. I might buy the current personal edition if I could be sure it would work on Windows 7 or 8.1.

Your website appears a bit dated with the references to Windows 95/NT and Rational Apex NT (which I used in the past before Rational killed it).

What is the status of Janus Ada and CLAW with regard to Windows 7 & 8?

- Britt

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> GWindows is still GNAT-only, right? If you want to use a different Ada 
> compiler, Claw is really your only option.

Nope, would be a simple compile and change a few lines here and there for Object'Img.

It could be it has been used on other compilers, I didn't keep track. Others run the project now and may know.

Also since others maintain it now, not myself, there may be Ada 2005 and 2012 code already in it. Perhaps some day if there as actually another compiler for 2005 or 2012 we can see.

> The page really is just a listing of places to look, and it mainly is just a 
> list of links that we feed to the search engine. The intent was that the way 
> to find any package was to use the search engine 
> (http://www.adaic.org/ada-resources/ada-on-the-web/) to find possibilities.

Thanks for the explantation.

> (Besides, I thought AdaPower had such a list of packages. Which hasn't been 
> updated in forever... :-)

As I said in a few threads, I abandoned all public Ada projects 10 years ago with the start of Shareware GNAT. Now that there is a professional grade unencumbered open source compiler again (GNAT-FSF), I have taken an interest again to give Ada one more try. I think it is worth it, I assume you do to :)

I'd love to see you involved Randy on making the new push of Ada into the Application's market. You have more experience than many others in the Ada world in that space (most have Zero) and it would serve you well in it. Contact me by e-mail and we can talk more.

BTW Gnoga would work well with Janus although it would take some work to backport to Ada 95 and It would need a websocket implementation other than AWS which requires 2012.

Given that, yes AdaPower will be updated soon, using Gnoga actually :)

David Botton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> Now they have no advertising costs, almost no development costs (what they have? a developer? two?) whatever they get from deep pockets is almost net profit.

Some recent upstream from AdaCore gcc/ada: https://gcc.gnu.org/git/?p=gcc.git;a=history;f=gcc/ada

I may not agree with AdaCore's making a Shareware GNAT, because it harms potential use of Ada in markets they don't even start to understand, but they do good work and a lot of it.

I would like them for the benefit of Ada in all markets to consider other approaches as I presented to them. However if they don't my plan is to drive the GNAT-FSF compilers into those markets as the _Professional_ compilers they are. Which ultimately will still net them the "big fish" in those markets.

AdaCore is not "costing" on the results of the government funds if giving back to the FSF, only being very shortsighted.

David Boton

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> AdaCore is not "costing"

coasting 

You get the point :)

Re: What exactly is the licensing situation with GNAT?

[sbelmont700]

On Wednesday, November 12, 2014 5:53:48 PM UTC-5, Randy Brukardt wrote:
> 
> One of the reasons we built Claw was to provide a Windows interface that 
> would work on any Ada 95 compiler for Windows, not just GNAT. That requires 
> displine and testing that most hobbyests wouldn't bother with.
> 
>                                          Randy.

I was under the impression that any Win32 Ada program was by definition compiler-specific, since there is no standardized way to import stdcall subprograms? 

-sb

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Randy Brukardt" <randy@rrsoftware.com> wrote in message 
news:m40odq$tdv$1@loke.gir.dk...
...
> One of the reasons we built Claw was to provide a Windows interface that 
> would work on any Ada 95 compiler for Windows, not just GNAT. That 
> requires displine and testing that most hobbyests wouldn't bother with.

I should have noted (beyond spelling better in the above!) that the Ada 2012 
pragma Profile (No_Implementation_Extensions) should help a great deal with 
that. If that's put into a package, the majority of of 
implementation-defined things would be identified. But it can't identify 
everything.

                                Randy.

Re: What exactly is the licensing situation with GNAT?

[Simon Clubley]

On 2014-11-12, Simon Wright <simon@pushface.org> wrote:
> Simon Clubley <clubley@remove_me.eisner.decus.org-Earth.UFP> writes:
>
>> PS: I've been around the Ada world long enough to remember the days
>> when GtkAda was GMGPL.
>
> "was" -> "stopped being" ?

That will work as well :-), but what I was trying to say was there was
a time when GtkAda was GMGPL and I chose to use it because it was GMGPL.

So much for posting last thing at night. :-)

Simon.

-- 
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Microsoft: Bringing you 1980s technology to a 21st century world

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

<sbelmont700@gmail.com> wrote in message 
news:bb27f98c-bf30-4287-acb3-7ee2b284f22f@googlegroups.com...
> On Wednesday, November 12, 2014 5:53:48 PM UTC-5, Randy Brukardt wrote:
>>
>> One of the reasons we built Claw was to provide a Windows interface that
>> would work on any Ada 95 compiler for Windows, not just GNAT. That 
>> requires
>> displine and testing that most hobbyests wouldn't bother with.
>>
>>                                          Randy.
>
> I was under the impression that any Win32 Ada program was by definition 
> compiler-specific,
>since there is no standardized way to import stdcall subprograms?

I suppose that's formally true ("stdcall" not appearing in the RM), but 
every Ada compiler for Windows that I know of uses "stdcall" for the 
convention name. (Janus/Ada was the only one that didn't initially, and that 
was easily solved. :-) So practically, that's not a portability problem. We 
were able to put the differences into a handful of packages (mostly having 
to do with linking pragmas).

                                    Randy.

Re: What exactly is the licensing situation with GNAT?

[Simon Clubley]

On 2014-11-12, john@peppermind.com <john@peppermind.com> wrote:
>
>> Yes Stallman's position is that he wished he could put a GPL Virus in the compiler
>
> Have you talked to him personally about that? To me this seems like
> a pretty unfair statement, given that most if not all other FSF-backed
> programming languages do not encumber executables with the GPL.
>

Actually, it's an accurate statement IIRC.

David's already posted a statement which I was unaware of and which backs
up my memory that in the very early days of gcc, RMS proposed that _any_
output from the gcc compiler would also be covered by the GPL.

IIRC, the backlash from that was so huge (by the standards of the time)
that RMS made it formally clear this wasn't, and would not be, the case.

Simon.

-- 
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Microsoft: Bringing you 1980s technology to a 21st century world

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"David Botton" <david@botton.com> wrote in message 
news:19fa65d4-72c9-44ab-b44b-4ea0929c18f2@googlegroups.com...

>> Unfortunately, if it is like most of David's other software, it won't 
>> work
>> on other Ada compilers

>Not true. Janus is the only Windows compiler with an issue.

>There was an ABI issue with using Janus that was too much effort for me to 
>consider as a
>volunteer effort for  a non Open Source compiler, however, GnatCOM was used 
>on
>Aonix OpenAda and in Rational's Ada compiler. Privately I can give you a 
>list of projects
>where I know it was used if you like not on GNAT.

Didn't even remember GnatCOM. (With a name like that, why would anyone 
expect it to work with any other Ada compiler? Marketing, as you mention, is 
important.)

>I do not know if GWindows was used on other compilers, but other than the 
>fact that
>I tend to use Object'Img there is nothing GNAT specific about the project. 
>Since
>GNAT is the only open source compiler, it is the only one I choose to 
>support until
>there are others.

Understand the latter. Have you ever tried profile 
(No_Implementation_Extensions)? My experience is that people use a lot of 
them without even being aware. (That's true for me, too, BTW).

My recollection is that GWindows depended on Unrestricted_Access (a huge 
amount of GNAT software does), and that really only works with the GCC 
runtime model. (The use of trampolines caused lots of problems on Windows; 
AdaCore has finally gotten rid of most of those.)

>> That requires displine and testing that most hobbyests wouldn't bother 
>> with.
>
>I think that you confuse Open Source developers with "Hobbyest", that is 
>usually not the case at all.

Well, the vast majority of the Ada software posted here is not 
professionally developed. The authors may be professional, but the software 
is a side-line at best. That's what I was thinking of when I said the above.

>GnatCOM was a professional supported product by GNAT.

Right, but those sorts of products have even less incentive to work on other 
compilers. They only really care about their own compiler.

>GWindows is used as a professional product by fortune 500 companies. I 
>didn't go
>through with my plan 10 years ago with bringing Ada to the business sector 
>because
>of license changes in GNAT to the public version and various other issues. 
>Using FSF
>compilers in those days was not a big option.

It did however cannibalize our Claw business such that it made it 
non-economic to put major work into it, and of course poliferated 
interfaces. One of the major goals that we had for Claw was to make a 
semi-standard interface for Windows so that everyone could use a single 
interface.

>There is nothing in Gnoga other than the use again of Object'Img preventing 
>it from
>being used on Janus if it ever gets updated to Ada 2012. I'd be happy to 
>help you do
>the work to replace AWS if needed with your own implementation of 
>Websockets, etc.

I'm not sure I have the time; I've spread myself too thin to do anything 
well which is not helping Ada much. (And of course the "updating to Ada 
2012" probably ought to have priority.) But I'll keep that in mind should 
the need arise.

>I think that for many people they have not "figured" out how to make Open 
>Source
>work to their advantage. It has in my career.
>
>I'd be happy to talk to you privately any time about how to make Janus work 
>in an
>Open Source environment provided you could open it. If you can't perhaps we 
>can
>talk about options for a new Open Source compiler. I really liked Janus.

I've seriously considered that, but I'm dubious that a business model based 
on support alone would work (we always had problems selling support 
contracts). Anyway, let's take this off line; my e-mail hasn't changed since 
the last time we talked. :-)

>Your CLAW Open Source version came too late, if it was a year before I 
>probably
>would have forked it and used it instead of created GWindows.

That's of course the big annoyance for me. We'd always intended to open 
source the binding once the government obligation had been cleared. We 
didn't do it immediately because I didn't want it forked until it was pretty 
well tested (and the because the Builder had to be good enough to stand on 
its own). Had you talked to me before starting GWindows, I'm pretty sure we 
could have worked something out (given that there wasn't any major 
difference between our plans and your plans).

But that's water under the dam at this point. I promise I'll forget about 
Web-Claw. :-)

                                  Randy.

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> Unfortunately, if it is like most of David's other software, it won't work
> on other Ada compilers. (That is a common problem, not really picking on
> David here, a lot of supposedly Ada software is really GNAT software.) That
> locks you into GNAT, and as you note, the costs for getting regular support
> for GNAT are not really affordable.

Let's face it: Gnat is the only compiler out there that has any chance 
of making it to mainstream market. I contacted the other two vendors of 
Ada compilers (forgot the names, I refer to them internally as the green 
and the silver/blue website). they dont have prices on their sites, have 
cool pics of fighter jets and only support up to Ada 95. I wanted to ask 
for prices, evaluation version and I didn't even get a response, so I 
guess unless you have "IBM" or "Pentagon" in your email domain, they 
don't even read your email.



---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"David Botton" <david@botton.com> wrote in message 
news:c9535bc6-4e37-4e92-a2a1-3a5f7280d324@googlegroups.com...
>> GWindows is still GNAT-only, right? If you want to use a different Ada
>> compiler, Claw is really your only option.
>
>Nope, would be a simple compile and change a few lines here and there for 
>Object'Img.
>
>It could be it has been used on other compilers, I didn't keep track. 
>Others run
>the project now and may know.

I remember that another vendor I know tried that and told me that it was 
very difficult to get to work on their implementation. Dunno if that was an 
older version or if it is still true. (It would surely be worse on Janus/Ada 
with the weird System.Address size and the like.)

>Also since others maintain it now, not myself, there may be Ada 2005 and 
>2012 code
>already in it. Perhaps some day if there as actually another compiler for 
>2005 or 2012
>we can see.

You're sounding like Dewar. :-) The Rational/IBM compiler is a full 
implementation of Ada 2005. Janus/Ada supports some Ada 2005 stuff, and will 
support more when I get a round tuit, as well as some Ada 2012 stuff.

...
>> (Besides, I thought AdaPower had such a list of packages. Which hasn't 
>> been
>> updated in forever... :-)
>
>As I said in a few threads, I abandoned all public Ada projects 10 years 
>ago with the
>start of Shareware GNAT. Now that there is a professional grade 
>unencumbered open
>source compiler again (GNAT-FSF), I have taken an interest again to give 
>Ada one
>more try. I think it is worth it, I assume you do to :)
>
>I'd love to see you involved Randy on making the new push of Ada into the
>Application's market. You have more experience than many others in the Ada
>world in that space (most have Zero) and it would serve you well in it. 
>Contact
>me by e-mail and we can talk more.

Write me with what you have in mind.

>BTW Gnoga would work well with Janus although it would take some work to
>backport to Ada 95 and It would need a websocket implementation other than
>AWS which requires 2012.

Well, Ada 95 + 10% of Ada 2005. Not sure what "websocket" you are talking 
about here. NC.Sockets is a regular, portable sockets implementation that 
works on both Windows and Linux. ("NC" ==> "Not Claw", it's based on the 
Claw sockets implementation, but with the Windows-specific stuff filed off. 
Tero Koskinen built a Linux version which I've been using for that part. 
It's BSD-licensed. I need to finish that up one of these days, as the Ada 
search engine and Trash-finder both depend on it, and I need to port them 
from our obsolete W2K server to the newish Linux server.)

>Given that, yes AdaPower will be updated soon, using Gnoga actually :)

                         Randy.

Re: What exactly is the licensing situation with GNAT?

[Hubert]

Ok, One was GreenHills and the other was Atego, I looked them up



---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Britt" <britt.snodgrass@gmail.com> wrote in message 
news:1af12fe7-ddd9-4eec-b8d3-3237d3e1427a@googlegroups.com...
> On Wednesday, November 12, 2014 5:47:24 PM UTC-5, Randy Brukardt wrote:
>
>>
>> You could of course use a different, commercial Ada compiler, rather than
>> insisting on GNAT. At least Janus/Ada still costs $195 for the personal
>> version and $500 for the professional version. See www.rrsoftware.com.
>
> Randy,
>
> I remember buying one of your early versions of of Janus Ada for $99. It 
> might have been around 1989 or so. I might buy the current personal 
> edition if I could be sure it would work on Windows 7 or 8.1.
>
> Your website appears a bit dated with the references to Windows 95/NT and 
> Rational Apex NT
>(which I used in the past before Rational killed it).

I've been holding off on updating the website until all of the Windows 7 
issues are cleared.

> What is the status of Janus Ada and CLAW with regard to Windows 7 & 8?

Windows 8 == Vista to me; I'm waiting for Windows 10 as a system that tried 
to make the desktop a second-class citizen is near-worthless for 
programming. So no testing there. (Tom Moran reported that everything works 
the same there as it does on Windows 7; I don't think there are any 
additional issues, but as I said, I didn't try them.)

As far as Windows 7 goes, there are a few minor problems that have so far 
kept the compiler in beta. The main one is that the uninstaller doesn't work 
(I can't seem to convince Windows that it should have the permissions to 
uninstall, even when run explicitly as an administrator). The minor one 
(considering that it is obsolete even if it works) is that the GUI 
programming environment doesn't work at all; you'd have to use some other 
editor. (Most people prefer to do that anyway, but it really ought to work; 
to do that, it will have to be totally replaced, something I don't have time 
for right now.)

The Claw binding and Claw programs work on Windows 7, so far as I can tell 
via testing. The Claw Builder comes up with a white screen for some reason 
on Windows 7, so it isn't usable right now on that system. (I'm guessing 
that there is a deadlock situation in the way Claw writes the overlay, but 
it will take some intensive testing to figure out the cause.) A more minor 
problem is that the help files have to be found manually every time you open 
them, for some reason Windows 7 can't remember where they are.

Anyway, the beta works on Windows 7, with some glitches. Once the glitches 
are gone, I'll update the web site, too.

                                        Randy.

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> Write me with what you have in mind.

I will be in touch soon.

> Not sure what "websocket" you are talking 

Is part of HTML5, http://en.wikipedia.org/wiki/WebSocket

David Botton

Re: What exactly is the licensing situation with GNAT?

[Shark8]

On 12-Nov-14 19:10, Randy Brukardt wrote:
>
> Anyway, the beta works on Windows 7, with some glitches. Once the glitches
> are gone, I'll update the web site, too.
>

Good to hear.

Re: What exactly is the licensing situation with GNAT?

[Harry Bolger]

On 2014-11-13, Simon Clubley <clubley@remove_me.eisner.decus.org-Earth.UFP> wrote:
>
> David's already posted a statement which I was unaware of and which backs
> up my memory that in the very early days of gcc, RMS proposed that _any_
> output from the gcc compiler would also be covered by the GPL.
>
> IIRC, the backlash from that was so huge (by the standards of the time)
> that RMS made it formally clear this wasn't, and would not be, the case.

That's now. I suspect once world domination draws near they will pull that
trick out of their sleeve and it will be too late for the lemmings to do
anything about it.

Harry

Re: What exactly is the licensing situation with GNAT?

[George Curioso]

On 2014-11-12, Randy Brukardt <randy@rrsoftware.com> wrote:

> You could of course use a different, commercial Ada compiler, rather than 
> insisting on GNAT. At least Janus/Ada still costs $195 for the personal 
> version and $500 for the professional version. See www.rrsoftware.com. 
> (Disclaimer for new people here, I'm a co-founder and primary author of 
> Janus/Ada, so I'm a bit biased. :-)

It's hard to tell from your website exactly which *NIX are supported. If you
could clarify that it might be helpful. Many people are no longer using
Windows and or prefer coding on UNIX or UNIX-like platforms as I'm sure you know.

Will it run on Linux, Solaris (x86 or SPARC), FreeBSD, etc? 32 bits or 64? I
downloaded your test executables (I think they were old a.out) years ago and
I couldn't get them to work on anything I had running at the time.

>> Personally I wouldn't mind paying a few 100$ right now for a license that 
>> would allow me to write closed source applications even if I get no 
>> support or just some way to report bugs which may or may not be fixed 
>> later.
>
> See note about Janus/Ada above. ;-)

Please clarify exactly what platforms and Ada versions are supported. I've
heard (read) good things about your toolchain but your website doesn't help ;-)

George

Re: What exactly is the licensing situation with GNAT?

[Luther Bogart]

On 2014-11-13, Hubert <herrdoktor@fumanchu.com> wrote:
>> Unfortunately, if it is like most of David's other software, it won't work
>> on other Ada compilers. (That is a common problem, not really picking on
>> David here, a lot of supposedly Ada software is really GNAT software.) That
>> locks you into GNAT, and as you note, the costs for getting regular support
>> for GNAT are not really affordable.
>
> Let's face it: Gnat is the only compiler out there that has any chance 
> of making it to mainstream market. I contacted the other two vendors of 
> Ada compilers (forgot the names, I refer to them internally as the green 
> and the silver/blue website). they dont have prices on their sites, have 
> cool pics of fighter jets and only support up to Ada 95. I wanted to ask 
> for prices, evaluation version and I didn't even get a response, so I 
> guess unless you have "IBM" or "Pentagon" in your email domain, they 
> don't even read your email.

I have had similar experiences and said so here over the years. I even
called and got the guy to laugh at me over the phone for the price of a long
distance call (no distributor here). But they can't sell it to IBM since IBM
already has Ada they bought from Rational. IBM previously sold off their Ada
370 version to a company in Virginia. Those people are a lot more personable
(and reasonable) but you still have to take out a second mortgage if you
want to use Ada.

Anyway I don't agree with you thaht GNAT can make it in the mainstream
market if you mean the real Ada market. There are already a few companies in
that space and they'll stay there until the business disappears.

As far as hobbyist, personal, or small professional developer goes there
shouldn't be any reason why gcc-Ada can't be just like gcc and gfortran,
without an encumbered runtime. People are selling stuff written in gcc all
the time and they don't have to open source it.

Luther

Re: What exactly is the licensing situation with GNAT?

[Luther Bogart]

On 2014-11-13, Luther Bogart <playitagain@morocco.com> wrote:
> On 2014-11-13, Hubert <herrdoktor@fumanchu.com> wrote:

>> Let's face it: Gnat is the only compiler out there that has any chance 
>> of making it to mainstream market. I contacted the other two vendors of 
>> Ada compilers (forgot the names, I refer to them internally as the green 
>> and the silver/blue website). they dont have prices on their sites, have 
>> cool pics of fighter jets and only support up to Ada 95. I wanted to ask 
>> for prices, evaluation version and I didn't even get a response, so I 
>> guess unless you have "IBM" or "Pentagon" in your email domain, they 
>> don't even read your email.
>

I meant to write

Anyway I don't agree with you that GNAT "is the only compiler out there
that has any chance of making it to the mainstream market" since there
already 4 or 5 significant players in that business space.

Obviously GNAT made it already ;-) They are just not motivated to sell
licenses to hobbyists or small startup-type development ventures.

Luther

Re: What exactly is the licensing situation with GNAT?

[Georg Bauhaus]

On 13.11.14 02:29, Randy Brukardt wrote:
> I should have noted (beyond spelling better in the above!) that the Ada 2012
> pragma Profile (No_Implementation_Extensions) should help a great deal with
> that. If that's put into a package,


A test case program is another place I sometimes use to make
sure the language used stays Ada. In particular, the earlier (Ada 95)

  No_Implementation_{Attributes|Pragmas}

restriction identifiers serve these cases well.

Re: What exactly is the licensing situation with GNAT?

[Pete Ballmer]

On 2014-11-12, Randy Brukardt <randy@rrsoftware.com> wrote:

> Unfortunately, if it is like most of David's other software, it won't work 
> on other Ada compilers. (That is a common problem, not really picking on 
> David here, a lot of supposedly Ada software is really GNAT software.) That 
> locks you into GNAT, and as you note, the costs for getting regular support 
> for GNAT are not really affordable.

This is an issue with all of FSF's proprietary stuff generally not just
Ada. What percentage of "C" code written for Linux and NUXI is actually
really C rather than gcc? Not very much. It's bad for the ecosystem when
code only compiles under one toolchain. FSF knows that and that's why they
create all these extensinons. It's just another smarter form of vendor
lock-in and it's hard to understand why people accept this.

It takes a lot of discipline and expense to write portable code and all the
gxx stuff makes it tempting to do otherwise. You _will_ be fsfimilated!

Peter

Re: What exactly is the licensing situation with GNAT?

[Georg Bauhaus]

On 13.11.14 02:49, Randy Brukardt wrote:
> My recollection is that GWindows depended on Unrestricted_Access (a huge
> amount of GNAT software does), and that really only works with the GCC
> runtime model.

I understand ICC's compiler has (something like) Unrestricted_Access?

(But maybe some uses of 'Unrestricted_Access may be supplanted now
with plain access subprogram parameters of Ada 2005.)

Re: What exactly is the licensing situation with GNAT?

[Georg Bauhaus]

On 13.11.14 08:40, Harry Bolger wrote:
> That's now. I suspect once world domination draws near they will pull that
> trick out of their sleeve and it will be too late for the lemmings to do
> anything about it.

You're joking, right?

Re: What exactly is the licensing situation with GNAT?

[Harry Bolger]

On 2014-11-13, Georg Bauhaus <bauhaus@futureapps.invalid> wrote:
> On 13.11.14 08:40, Harry Bolger wrote:
>> That's now. I suspect once world domination draws near they will pull that
>> trick out of their sleeve and it will be too late for the lemmings to do
>> anything about it.
>
> You're joking, right?
>

About what? Stalemate has already acknowledged he wants this. He just
couldn't shove it down people's throats far enough at that time. Later on
when Linux finishes blotting out all the other desktop and low-end server OS
and all the other toolchains have disappeared people will have to swallow
whatever the FSF tells them and like it, sir! All that proprietary gcc code
they wrote over the past twenty years thinking it was C won't compile or run
on anything else and they'll be locked in.

Is this such a difficult proposition for you?

Harry

Re: What exactly is the licensing situation with GNAT?

[Georg Bauhaus]

On 13.11.14 09:03, Pete Ballmer wrote:
> It's just another smarter form of vendor
> lock-in and it's hard to understand why people accept this.

Other than simply ignorance and imitation, accepting language
extensions could well be a direct consequence of how
consultancy works, I think, and of how GTD management works.
There are rewards:

Sentences about language involving "technically superior", "long term",
"portable", etc, have no momentary effect.  They don't get things done,
now. They do not help "getting things re-done" forever, too, if
software may become finished, with no control over profitable sequels.
Just an observation.

Re: What exactly is the licensing situation with GNAT?

[Georg Bauhaus]

On 13.11.14 09:41, Harry Bolger wrote:
> On 2014-11-13, Georg Bauhaus <bauhaus@futureapps.invalid> wrote:
>> On 13.11.14 08:40, Harry Bolger wrote:
>>> That's now. I suspect once world domination draws near they will pull that
>>> trick out of their sleeve and it will be too late for the lemmings to do
>>> anything about it.
>>
>> You're joking, right?
>>
>
> About what? Stalemate has already acknowledged he wants this. He just
> couldn't shove it down people's throats far enough at that time.

Right. And a single citizen cannot survive a move against most of his
supporters, including commercial supporters like Redhat or Oracle or
AdaCore, who make a living in the enterprise and military spaces.
The powers insinuated are even less if there is the prospect of moving
towards differently licensed open source LLVM. I don't think the FSF
is sufficiently suicidal for that.

>  All that proprietary gcc code
> they wrote over the past twenty years thinking it was C won't compile or run
> on anything else and they'll be locked in.

I recall that many GNU-isms are well supported by major C compilers,
including Intel, and also that the same argument could apply in reverse
when trying to port C or Fortran away form Intel-isms.

Apple, OTOH, have been doing exactly what you have outlined, a couple
of times, and they are doing well.

> Is this such a difficult proposition for you?

Not difficult to decipher as a fine specimen of FUD, by all standards
I can just now think of. For example, completeness.

Re: What exactly is the licensing situation with GNAT?

[Georg Bauhaus]

On 13.11.14 09:03, Pete Ballmer wrote:
> It's just another smarter form of vendor
> lock-in and it's hard to understand why people accept this.

And BTW, this is how Ada started! Someone did no longer want
to accept his organization being locked-in to over 400 vendors.

History repeating?

Re: What exactly is the licensing situation with GNAT?

[Gour]

On Wed, 12 Nov 2014 20:10:39 -0600
"Randy Brukardt" <randy@rrsoftware.com> wrote:

> Windows 8 == Vista to me; I'm waiting for Windows 10 as a system that
> tried to make the desktop a second-class citizen is near-worthless
> for programming. So no testing there. 

What about Linux (x86_64) and someone wanting to write multi-platform
open-source desktop app?


Sincerely,
Gour


-- 
You have a right to perform your prescribed duty, but you
are not entitled to the fruits of action. Never consider 
yourself the cause of the results of your activities,
and never be attached to not doing your duty.

Re: What exactly is the licensing situation with GNAT?

[Maciej Sobczak]

> About what? Stalemate has already acknowledged he wants this. He just
> couldn't shove it down people's throats far enough at that time. Later on
> when Linux finishes blotting out all the other desktop and low-end server OS
> and all the other toolchains have disappeared people will have to swallow
> whatever the FSF tells them and like it, sir!

By "all the other toolchains" you mean also llvm? Because as far as I know, this toolchain is actually starting to push gcc out of the picture (think FreeBSD, Apple). So, don't worry about the world dominance of gcc and possible tricks that might follow.

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

Re: What exactly is the licensing situation with GNAT?

[Tero Koskinen]

13.11.2014 3:29, Randy Brukardt wrote:
> "Randy Brukardt" <randy@rrsoftware.com> wrote in message 
> news:m40odq$tdv$1@loke.gir.dk...
> ...
>> One of the reasons we built Claw was to provide a Windows interface that 
>> would work on any Ada 95 compiler for Windows, not just GNAT. That 
>> requires displine and testing that most hobbyests wouldn't bother with.
> 
> I should have noted (beyond spelling better in the above!) that the Ada 2012 
> pragma Profile (No_Implementation_Extensions) should help a great deal with 
> that. If that's put into a package, the majority of of 
> implementation-defined things would be identified. But it can't identify 
> everything.

Too bad, right now the pragma does not work in practice :)

Janus/Ada [for Ada 95/07] - Version 3.1.2b (Windows NT 386)
...
Input File Is C:\work\ahven\src\AHVEN.ADS
#
In File C:\work\ahven\src\AHVEN.ADS at line 18
--------------
   17:
   18:  pragma Profile (No_Implementation_Extensions);
---------------^
*WARNING* Unknown pragma (6.5.2)


ICC Ada Compiler [v9.0.57 Jan 24, 2014] Target x86 Win32
Compiling c:/work/ahven/src/ahven.ads
"ahven.ads", line 18: Warning: Ignored pragma: Profile.

(Yes, I am using Ada 95/2005/2007 compilers, but it is not fair to tease
people with features implemented only in one compiler.)

Yours,
 Tero

Re: What exactly is the licensing situation with GNAT?

[Tero Koskinen]

13.11.2014 3:54, Hubert wrote:
>> Unfortunately, if it is like most of David's other software, it won't
>> work
>> on other Ada compilers. (That is a common problem, not really picking on
>> David here, a lot of supposedly Ada software is really GNAT software.)
>> That
>> locks you into GNAT, and as you note, the costs for getting regular
>> support
>> for GNAT are not really affordable.
> 
> Let's face it: Gnat is the only compiler out there that has any chance
> of making it to mainstream market. I contacted the other two vendors of
> Ada compilers (forgot the names, I refer to them internally as the green
> and the silver/blue website). they dont have prices on their sites, have
> cool pics of fighter jets and only support up to Ada 95. I wanted to ask
> for prices, evaluation version and I didn't even get a response, so I
> guess unless you have "IBM" or "Pentagon" in your email domain, they
> don't even read your email.
...
> Ok, One was GreenHills and the other was Atego, I looked them up

I have managed to contact Atego sales people in Europe about
a year ago. But I admit, it was somewhat hard to do. I had to
pester HR persons (via email) to find me a sales guy who was
answering to his emails.

But in the end, I found two (one of them was vice-president of
sales department iirc), plus one software engineer.

I was even able to get a quote from them for ObjectAda (2005 version).

Otherwise their price was "ok", but
1) They license their compiler only for a year at time. After year
is over, you need to renew the license or you cannot use the compiler
anymore.
2) They only deal with other companies. They don't have procedures
to sell (or give) compilers to invidual people.

Also, I don't know has the situation changed after the latest merger.

Yours,
 Tero

Re: What exactly is the licensing situation with GNAT?

[Tero Koskinen]

13.11.2014 1:23, Britt wrote:
> What is the status of Janus Ada and CLAW with regard to Windows 7 & 8?

Janus/Ada works on 64-bit Windows 8.1. There are some quirks with
filenames (they seem to be partially case sensitive), but otherwise
everything is ok. (I regularly test my Ada software on Windows 8.1
with Janus/Ada.)

On 64-bit Windows 7 everything works fine.

http://build.ada-language.com/view/JanusAda/ provides build logs
for some of my Ada packages compiled on Windows 7.

Yours,
 Tero

Re: What exactly is the licensing situation with GNAT?

[Peter Chapin]

On Thu, 13 Nov 2014, Maciej Sobczak wrote:

>> About what? Stalemate has already acknowledged he wants this. He just
>> couldn't shove it down people's throats far enough at that time. Later on
>> when Linux finishes blotting out all the other desktop and low-end server OS
>> and all the other toolchains have disappeared people will have to swallow
>> whatever the FSF tells them and like it, sir!
>
> By "all the other toolchains" you mean also llvm? Because as far as I 
> know, this toolchain is actually starting to push gcc out of the picture 
> (think FreeBSD, Apple). So, don't worry about the world dominance of gcc 
> and possible tricks that might follow.

I agree with this. It seems like in some circles gcc is seen as 
yesterday's technology. I'd worry more about LLVM taking over the world.

Peter

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> I agree with this. It seems like in some circles gcc is seen as 
> yesterday's technology. I'd worry more about LLVM taking over the world.

About time someone get the fire to Finish the work already started (and was working) for porting the GNAT front end to LLVM or write a new one :)

I'm a bit busy ;) I have a good excuse.

David Botton

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Georg Bauhaus" <bauhaus@futureapps.invalid> wrote in message 
news:m41pge$si1$1@dont-email.me...
> On 13.11.14 02:49, Randy Brukardt wrote:
>> My recollection is that GWindows depended on Unrestricted_Access (a huge
>> amount of GNAT software does), and that really only works with the GCC
>> runtime model.
>
> I understand ICC's compiler has (something like) Unrestricted_Access?

My recollection was that ICC has it, but it only works in limited 
circumstances -- they couldn't implement the entire thing as supported by 
GNAT.

> (But maybe some uses of 'Unrestricted_Access may be supplanted now
> with plain access subprogram parameters of Ada 2005.)

Right, there is a similarity (not 100%). For Janus/Ada, such parameters 
would be (if I ever got around to implementing them), a record containing 
roughly 20 words of memory to carry the call state. A bit expensive to 
initialize, but it would work (generic formal subprograms have a similar 
implementation, but there the memory is associated with the instance rather 
than the individual actual subprogram parameter).

I recall Adam suggesting that some special sort of named 
access-to-subprogram type be defined with similar characteristics to the 
anonymous access-to-subprogram. Such a thing could be made to work, while 
the bare pointer used for normal access-to-subprogram types would not work. 
But of course it would be susceptible to dangling pointers, and won't 
(usually) be compatible with C.

                                  Randy.


                                  Randy.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Hubert" <herrdoktor@fumanchu.com> wrote in message 
news:DbU8w.703256$Fo3.563225@fx09.iad...
>> Unfortunately, if it is like most of David's other software, it won't 
>> work
>> on other Ada compilers. (That is a common problem, not really picking on
>> David here, a lot of supposedly Ada software is really GNAT software.) 
>> That
>> locks you into GNAT, and as you note, the costs for getting regular 
>> support
>> for GNAT are not really affordable.
>
> Let's face it: Gnat is the only compiler out there that has any chance of 
> making it to mainstream market. I contacted the other two vendors of Ada 
> compilers (forgot the names, I refer to them internally as the green and 
> the silver/blue website). they dont have prices on their sites, have cool 
> pics of fighter jets and only support up to Ada 95. I wanted to ask for 
> prices, evaluation version and I didn't even get a response, so I guess 
> unless you have "IBM" or "Pentagon" in your email domain, they don't even 
> read your email.

You obviously never contacted RR Software, because our pricing isn't like 
that. Despite replying directly to me!

Anyway, Atego (in an earlier form), tried a cheaper Ada compiler, but gave 
it up after a number of years (at least 5) because they couldn't make money 
from it. Our experience at RR Software is similar. My guess is that no Ada 
compiler ever could be "mainstream", because the language doesn't contain 
curly brackets -- a for a lot of people, programming can only be done in a 
language with such brackets. (Sadly, I'm serious.) Of course, people could 
prove me wrong by flocking here to buy Janus/Ada. ;-)

                                         Randy.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"David Botton" <david@botton.com> wrote in message 
news:4b1a6407-6c5d-4ccd-8992-0bff7965ed0d@googlegroups.com...
>> Write me with what you have in mind.
>
> I will be in touch soon.
>
>> Not sure what "websocket" you are talking
>
> Is part of HTML5, http://en.wikipedia.org/wiki/WebSocket

I see, it would need some sort of extension to the NC.HTTP package (which is 
of course implemented on top of NC.Sockets). I'll have to look into when I 
get some time.

                                   Randy.

Re: What exactly is the licensing situation with GNAT?

[Mark Carroll]

"Randy Brukardt" <randy@rrsoftware.com> writes:

> My guess is that no Ada compiler ever could be "mainstream", because
> the language doesn't contain curly brackets -- a for a lot of people,
> programming can only be done in a language with such brackets. (Sadly,
> I'm serious.)

I think you may be correct: I believe that was a big part with the
"problem" with Modula-3's popularity. (Again, there was a commercial
company supporting a compiler -- Critical Mass -- they folded years ago
but kindly open-sourced their work which is now on GitHub.) When Java
came out I was kind of disappointed when I learned more about it, but I
think the C-style syntax -- one of the most obvious attributes -- was a
big winner.

-- Mark

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Gour" <gour@atmarama.net> wrote in message 
news:20141113104356.6b2b43a4@atmarama.ddns.net...
> On Wed, 12 Nov 2014 20:10:39 -0600
> "Randy Brukardt" <randy@rrsoftware.com> wrote:
>
>> Windows 8 == Vista to me; I'm waiting for Windows 10 as a system that
>> tried to make the desktop a second-class citizen is near-worthless
>> for programming. So no testing there.
>
> What about Linux (x86_64) and someone wanting to write multi-platform
> open-source desktop app?

Not yet - can't get spread too thin. (Gotta get Windows 7 working right, 
plus some things promised to customers before looking at more targets.) 
There'd be little problem making a 32-bit version for Linux, 64-bit of 
course would need a different code generator so more work but not that 
difficult.

                                       Randy.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"George Curioso" <curiousgeorge@thezoo.net> wrote in message 
news:m41nld$2rh$1@speranza.aioe.org...
> On 2014-11-12, Randy Brukardt <randy@rrsoftware.com> wrote:
>
>> You could of course use a different, commercial Ada compiler, rather than
>> insisting on GNAT. At least Janus/Ada still costs $195 for the personal
>> version and $500 for the professional version. See www.rrsoftware.com.
>> (Disclaimer for new people here, I'm a co-founder and primary author of
>> Janus/Ada, so I'm a bit biased. :-)
>
> It's hard to tell from your website exactly which *NIX are supported. If 
> you
> could clarify that it might be helpful. Many people are no longer using
> Windows and or prefer coding on UNIX or UNIX-like platforms as I'm sure 
> you know.
>
> Will it run on Linux, Solaris (x86 or SPARC), FreeBSD, etc? 32 bits or 64? 
> I
> downloaded your test executables (I think they were old a.out) years ago 
> and
> I couldn't get them to work on anything I had running at the time.
>
>>> Personally I wouldn't mind paying a few 100$ right now for a license 
>>> that
>>> would allow me to write closed source applications even if I get no
>>> support or just some way to report bugs which may or may not be fixed
>>> later.
>>
>> See note about Janus/Ada above. ;-)
>
> Please clarify exactly what platforms and Ada versions are supported. I've
> heard (read) good things about your toolchain but your website doesn't 
> help ;-)

Practically, the toolchain is Windows-only at this point. We don't have 
anything for Linux or FreeBSD, it wouldn't be hard to create such a thing, 
but it's important get one thing right before moving on to other things. 
When I redo the website, I'll remove the Unix references (since I recycled 
the computer that supported those versions this spring in a tax-saving move, 
I couldn't actually provide one even if someone wanted it). Of course, the 
source code is still in our version control, so it could be regenerated if 
necessary -- but it hasn't been updated since 1997.

                                   Randy.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Georg Bauhaus" <bauhaus@futureapps.invalid> wrote in message 
news:m41ojr$rdq$1@dont-email.me...
> On 13.11.14 02:29, Randy Brukardt wrote:
>> I should have noted (beyond spelling better in the above!) that the Ada 
>> 2012
>> pragma Profile (No_Implementation_Extensions) should help a great deal 
>> with
>> that. If that's put into a package,
>
>
> A test case program is another place I sometimes use to make
> sure the language used stays Ada. In particular, the earlier (Ada 95)
>
>  No_Implementation_{Attributes|Pragmas}
>
> restriction identifiers serve these cases well.

Right, but there are a number of other cases that 
No_Implementation_Extensions covers: implementation-defined things in 
language-defined packages (there are a number of such places in the RM, such 
as in System); No_Implementation_Aspect_Specifications (obviously only 
relevant for Ada 2012, but still important); and No_Implementation_Units 
(which covers implementation-defined descendants of Ada, System, and 
Interfaces; implementation-defined children of Ada are banned, but 
grandchildren are allowed).

Still not covered are issues like the representation of predefined types 
(esp. Integer and Float), and implementation-defined behavior (such as what 
happens when a potentially blocking operation is called from a protected 
action). These things can't really be detected at compile-time.

                                        Randy.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Tero Koskinen" <tero.koskinen@iki.fi> wrote in message 
news:m42m41$2vk$1@loke.gir.dk...
> 13.11.2014 3:29, Randy Brukardt wrote:
>> "Randy Brukardt" <randy@rrsoftware.com> wrote in message
>> I should have noted (beyond spelling better in the above!) that the Ada 
>> 2012
>> pragma Profile (No_Implementation_Extensions) should help a great deal 
>> with
>> that. If that's put into a package, the majority of of
>> implementation-defined things would be identified. But it can't identify
>> everything.
>
> Too bad, right now the pragma does not work in practice :)
...
> (Yes, I am using Ada 95/2005/2007 compilers, but it is not fair to tease
> people with features implemented only in one compiler.)

I think it's fair in this case as it's that "one compiler" that most people 
are using. It's pretty easy to erase a single pragma (and note in the 
Janus/Ada, as it is a warning, you don't even have to erase it); if you 
started with GNAT (which 98% of free software will have done), you're not 
likely to introduce any ICC or Janus/Ada extensions anyway.

Of course, beyond that, it's important that other vendors catch up. The 
Contracts stuff in particular is a big advantage for Ada over other 
languages. (And ignore the man behind the curtain. ;-)

                             Randy.

Re: What exactly is the licensing situation with GNAT?

[Jeffrey Carter]

On 11/13/2014 02:57 PM, Randy Brukardt wrote:
> 
> My guess is that no Ada 
> compiler  the language doesn't contain 
> curly brackets -- a for a lot of people, programming can only be done in a 
> language with such brackets. (Sadly, I'm serious.) Of course, people could 
> prove me wrong by flocking here to buy Janus/Ada. ;-)

My guess is that no Ada compiler ever could be "mainstream", because it's a
software-engineering language, and 98% of developers aren't S/W engineers.

But perhaps if we could outlaw languages with braces we could bring that number
down significantly?

Symbols  American     British
()       Parentheses  Brackets
[]       Brackets     Square brackets
{}       Braces       Curly brackets

Since ARM 2.1(15) uses "parenthesis", I guess here on c.l.a we should use the
American terms.

-- 
Jeff Carter
"What's the amount of the insult?"
Never Give a Sucker an Even Break
104

Re: What exactly is the licensing situation with GNAT?

[Gour]

On Thu, 13 Nov 2014 16:06:26 -0600
"Randy Brukardt" <randy@rrsoftware.com> wrote:

Hiya Randy,

> Not yet - can't get spread too thin. (Gotta get Windows 7 working
> right, plus some things promised to customers before looking at more
> targets.) There'd be little problem making a 32-bit version for
> Linux, 64-bit of course would need a different code generator so more
> work but not that difficult.

I have visited your site which needs some love to be more up-to-date,
but let me say that even for writing open-source application(s), I'd be
ready to pay reasonable price for native Ada compiler available for
64-bit Linux with some sort of GUI bindings - e.g. wx so one can write
multi-platform apps.

In regard to the point from another message, I believe there is market
for Ada & SW engineers. Take a look at FPC/Lazarus or check how many
contributors are there for e.g. Julia language which is pretty young. No
need to speak about Python which atrracts many engineering people. Iow,
it's not that everyone is into system programming and I'm sure David's
push of Ada into application's space market is justifying.


Sincerely,
Gour

-- 
Many, many births both you and I have passed. I can remember 
all of them, but you cannot, O subduer of the enemy!

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> I had a meeting this last Monday with AdaCore with a business model to make that possible and lucrative for them.

They did not feel my business model supports the change back to  GMGPL, even for a targeted market, and the available FSF compilers can serve the needs of those other markets.

Respectable position.

<< I would rather do it with them despite what they did to the community with the GPL version, total disregard of it, they have put in the work on the compiler and the language that deserves giving them a chance to be part of the solution.>>

This could be taken out of context of the rest of the thread, so to make clear:

I feel (obviously) very strongly the switch from GMGPL to GPL version of public versions for GNAT was a split of AdaCore away from the Ada community to a business centric model to strengthen their hold in their markets even though it weekend the communities ability to advocate in markets that AdaCore does not feel will work for them.

I respected their decision and their right to make that decision then 10 years ago as I continue to do so now.

The last intention I have is to discourage anyone from the excellent support AdaCore offers if you are in their market. Again very clear from every post.

I think every message I've given has reflected the above which is balanced and extremely fair.

I encourage people to use and improve the FSF version of GNAT and build a stronger community version if Ada is to be advocated beyond the niche markets it is in now.

David Botton

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> My guess is that no Ada compiler ever could be "mainstream", because it's a
> software-engineering language, and 98% of developers aren't S/W engineers.

That is a point that I have been contemplating for a while now but in 
conjunction with Object Oriented Programming. When I look back at my 
career I realize that I became lazier and lazier in terms of designing 
before programming with the advent of OOP. I think OOP is designed to to 
just that: Give you a false sense of "naturalism" and "ease" because 
"objects are so natural to the way humans think" and "everything in 
nature is an object" etc.

And it's true. It is much easier to start with some C++ style objects 
and add some methods that operate on the data and then have some other 
objects call these methods and so on. Everything is easy. Up to a 
certain point. And then it is too late.

In my opinion OOP is a way to make people write programs who should not 
be writing programs. There is a reason that "agile software development" 
and "scrum" rose up in parallel with OOP. I am not a big fan of OOP 
although I am using it out of necessity because the software I'm working 
with is based on it.

Looking back, this should probably be in it's own post and not at the 
10th level of a post regarding licensing questions :)



---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Hubert" <herrdoktor@fumanchu.com> wrote in message 
news:10d9w.55626$8w1.22302@fx12.iad...
...
> In my opinion OOP is a way to make people write programs who should not be 
> writing programs. There is a reason that "agile software development" and 
> "scrum" rose up in parallel with OOP.

IMHO, "agile" is the only sensible way to create software. In hindsight, 
I've always developed software that way, from the early 1980s to now, almost 
exclusively in Ada, and for most of the time, no OOP was in sight. But of 
course "agile" just boils down to short development cycles and frequent 
testing; that just good sense (compared to waterfall as usually used in the 
1980s).

Perhaps you're confusing agile with test-driven development (TDD) and other 
such nonsense? Luckily, they don't have much to do with each other (even if 
they are often used together). TDD, of course is a way to guarentee the 
lowest quality software that still "works" (for some definition of "works"). 
It means the software will certainly break as soon as someone thinks of a 
new way to use it, which is silly (because users are clever and will 
invitably come up with unanticipated ways to use anything) and dangerous 
(because the criminals will find those holes and abuse them).

                                        Randy.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"David Botton" <david@botton.com> wrote in message 
news:19fa65d4-72c9-44ab-b44b-4ea0929c18f2@googlegroups.com...
...
>There is nothing in Gnoga other than the use again of Object'Img preventing 
>it
>from being used on Janus if it ever gets updated to Ada 2012.

Semi-related to this is that we approved Obj'Image as a language-defined 
attribute, to be included in the 2015 Ada Corrigendum. [AdaCore told us that 
they had used 'Img only because the language would not allow them to change 
Image that way. The ARG has no such limitations. ;-)] So there should be 
little reason to use the GNAT extension going forward. Of course, I don't 
know when that will appear in GNAT or other compilers, but it's unlikely to 
be much work and it's obviously used a lot, so I expect it to be relatively 
quick (at least in compilers that are still actively developed; it'll be a 
fairly high priority for Janus/Ada, because it is so handy).

                                        Randy.

Re: What exactly is the licensing situation with GNAT?

[David Botton]

> Semi-related to this is that we approved Obj'Image as a language-defined 
> attribute, to be included in the 2015 Ada Corrigendum.

Very nice.

Do you have a list of which parts of Ada 2005 and 2012 Janus already supports? I'd like to see what is involved in getting Gnoga running on it (outside that AWS would not compile on it as is, although it may be possible to pear down things to just what is needed which is a very small part of AWS and port that).

If not too big a job, even though I am partial to open source tools obviously, I'd consider doing the port.

David Botton

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> Perhaps you're confusing agile with test-driven development (TDD) and other
> such nonsense? Luckily, they don't have much to do with each other (even if
> they are often used together). TDD, of course is a way to guarentee the
> lowest quality software that still "works" (for some definition of "works").
> It means the software will certainly break as soon as someone thinks of a
> new way to use it, which is silly (because users are clever and will
> invitably come up with unanticipated ways to use anything) and dangerous
> (because the criminals will find those holes and abuse them).
>
>                                          Randy.
>
>

I don't know, I dont really follow the latest software development fads 
that much, I have my own ways, but I also realize that my technique is 
flawed because the lure of the "easy to make object" always lures me 
into doing things step by step, that is not to worry about what's down 
the road as long as I'm working on something that must come earlier and 
then I realize that what comes later in the process has requirements 
that were not considered in the early stages and I have to go back and 
change what I did before.

I think that is pretty much "agile" development. I test a lot though, 
usually go through new code with the debugger line by line, so my 
programs basically run every step I take, it's just that later I 
discover I missed some steps or took the wrong path. I'm working in C++ 
at the moment, mind you, so that language might encourage the developer 
to use bad techniques. When I did a small Ada project I deliberately 
took the opportunity to work differently and the result was much more 
satisfying.

I am thinking more along the line of the Waterfall model, however with 
modern designtools which weren't available in the 80s. Diagrams were 
mostly made by hand in those days and changing them was a pain in the 
butt, today that is much easier with tools like Visio or other graphical 
editors.






---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"David Botton" <david@botton.com> wrote in message 
news:25731193-c0b5-4ab7-87ff-ba8c6a42cdbd@googlegroups.com...
>> Semi-related to this is that we approved Obj'Image as a language-defined
>> attribute, to be included in the 2015 Ada Corrigendum.
>
>Very nice.
>
>Do you have a list of which parts of Ada 2005 and 2012 Janus already 
>supports?

Yes, of course, but it's a pretty short list at the moment (mostly stuff 
involving aggregates, including <>). Probably not enough for your purposes.

>  I'd like to see what is involved in getting Gnoga running on it (outside 
> that
> AWS would not compile on it as is, although it may be possible to pear
> down things to just what is needed which is a very small part of AWS and 
> port that).

Or build something on top of NC_Sockets, if it's not too complicated 
(unlikely). One of the example programs for NC_Sockets is a simple web 
server (the one used for Ada-Auth.org/RRSoftware.com is a grown-up version 
of that example).

>If not too big a job, even though I am partial to open source tools 
>obviously, I'd consider doing the port.

If I had to guess, probably too big of a job today, but obviously new stuff 
is coming. It would be interesting to know what Ada 2005/Ada 2012 features 
you need. Probably we should take this off-line (it's not of much general 
interest, and I don't want to start promising stuff publically, I'm not that 
good at delivering as it is. :-)

                                   Randy.


David Botton

community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Gour]

On Thu, 13 Nov 2014 15:56:35 -0800 (PST)
David Botton <david@botton.com> wrote:

Hello David,

> They did not feel my business model supports the change back to
> GMGPL, even for a targeted market, and the available FSF compilers
> can serve the needs of those other markets.

It's a bit sad to hear it, but let's move forward...

>I encourage people to use and improve the FSF version of GNAT and
> build a stronger community version if Ada is to be advocated beyond
> the niche markets it is in now.

I confess being total greenhorn when it comes to Ada, its compilers and
(their) business models, but there is part in me not liking to see
another Betamax vs VHS battle being won by less capable technology.

Yesterday I researched a bit R.R.Software's web site and found that
their Janus/Ada compiler is "...the only compiler on the market that is
written in Ada and self compiled in a personal computer environment."

It's clear that it's behind Adacore's GNAT, but, maybe, it can be basis
of the future's (more) community-based compiler?

Of course, I do not have the slightest idea about their business model
and whether it's possible to do it, but the point is that (the compiler)
being written in Ada might be more approachable for community members to
help and hack on it.

Here I can think about e.g. Bacula - backup & restore application which
exists as Bacula Systems (http://www.baculasystems.com/) providing
features & support for enterprise customers who are often paying for the
features which are later added to the community version
(http://bacula.org/), but the point is that community is actively
contributing with patches, debugging, bugreports etc. while the main
developers still have enough to pay the bills. :-)

Another example might be Julia language which is hosted at Github and at
the moment there are 4611 star-gazers, 935 forks and 298 contributors
and its ecosystem is growing rapidly.

Based on what I've seen/heard, it seems that Ada community is not much
involved in shaping GNAT, even in its FSF incarnation...


Sincerely,
Gour

-- 
Even a man of knowledge acts according to his own nature, for 
everyone follows the nature he has acquired from the three modes. 
What can repression accomplish?

Re: community-based compiler

[Gour]

On Fri, 14 Nov 2014 08:50:46 +0100
Gour <gour@atmarama.net> wrote:

> Based on what I've seen/heard, it seems that Ada community is not much
> involved in shaping GNAT, even in its FSF incarnation...

Of course I forgot to mention yesterday's news about Microsoft
open-sourcing their .NET and today's about Go(lang) moving to Github. ;)

> Sincerely,
> Gour

-- 
He who is satisfied with gain which comes of its own accord, who 
is free from duality and does not envy, who is steady in both 
success and failure, is never entangled, although performing actions.

Re: What exactly is the licensing situation with GNAT?

[George Curioso]

On 2014-11-13, Randy Brukardt <randy@rrsoftware.com> wrote:
> "George Curioso" <curiousgeorge@thezoo.net> wrote in message 
> news:m41nld$2rh$1@speranza.aioe.org...
>> On 2014-11-12, Randy Brukardt <randy@rrsoftware.com> wrote:

>> Will it run on Linux, Solaris (x86 or SPARC), FreeBSD, etc? 32 bits or 64? 
>> I
>> downloaded your test executables (I think they were old a.out) years ago 
>> and
>> I couldn't get them to work on anything I had running at the time.
>>
>> Please clarify exactly what platforms and Ada versions are supported. I've
>> heard (read) good things about your toolchain but your website doesn't 
>> help ;-)
>
> Practically, the toolchain is Windows-only at this point. We don't have 
> anything for Linux or FreeBSD, it wouldn't be hard to create such a thing, 
> but it's important get one thing right before moving on to other things. 

Thanks for the info. My preferences are for Solaris but that is a declining
market. Still you could probably make a few bucks if you can support it
readily. However Linux is surely a growth market. Most developers have a
Linux box around for stuff that won't run on other systems.

> When I redo the website, I'll remove the Unix references (since I recycled 
> the computer that supported those versions this spring in a tax-saving move, 
> I couldn't actually provide one even if someone wanted it). Of course, the 
> source code is still in our version control, so it could be regenerated if 
> necessary -- but it hasn't been updated since 1997.

I'm sure people would agree to host your development in exchange for a copy
of your product on whatever platform(s) you'd like it to run on.

George

Re: What exactly is the licensing situation with GNAT?

[Pete Ballmer]

On 2014-11-13, David Botton <david@botton.com> wrote:

> I encourage people to use and improve the FSF version of GNAT and build a
>stronger community version if Ada is to be advocated beyond the niche
>markets it is in now. 

I don't contribute to GPL projects. I have contributed code, cash, and
hosting for BSD-licensed and other freely licensed projects and will
continue to do so. I'll be happy when FSF closes up shop and Stalemate is
back in the gutter with a bottle of booze where he belongs.

Other systems like LLVM would be ok except they're not supporting anything
but Intel. That is the same kind of destructivness that makes Linux
dangerous only from a different angle. FreeBSD may have gone to it but now
they have the unpleasant decision of writing code that will compile under
gcc and LLVM or ceasing to support non-Intel platforms.

Until people stop using proprietary compiler extensions and learn the value
of portable code and how to write it, moving in this direction or that
direction is just bouncing the problem around and around and it shows no
signs of being recognized let alone any hope to ever be fixed.

Pete

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Thu, 13 Nov 2014 15:51:54 -0600, Randy Brukardt wrote:

> I recall Adam suggesting that some special sort of named 
> access-to-subprogram type be defined with similar characteristics to the 
> anonymous access-to-subprogram. Such a thing could be made to work, while 
> the bare pointer used for normal access-to-subprogram types would not work. 
> But of course it would be susceptible to dangling pointers, and won't 
> (usually) be compatible with C.

I was always wondering why it was not a plain subprogram type. That would
solve a lot of problem, interfacing C included. E.g.

   type procedure Callback;
   pragma Convention (C, Callback);

   procedure Foo (F : Callback);
   pragma Import (C, Foo);

   procedure Bar is
      X : Callback :=
      begin
          ...
      end;
   begin
      Foo (X); -- I know what I am doing
   end Bar;

Certainly there is a danger that C would copy the pointer and use it after
leaving Bar, but that is not Ada's concern. Because it is equally apply to
*any* non-scalar arguments passed to C.

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

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Fri, 14 Nov 2014 00:13:28 -0600, Randy Brukardt wrote:

> Or build something on top of NC_Sockets, if it's not too complicated 
> (unlikely). One of the example programs for NC_Sockets is a simple web 
> server (the one used for Ada-Auth.org/RRSoftware.com is a grown-up version 
> of that example).

Could you elaborate this a bit. Specifically:

1. Do NC_Scokets support socket select? (My HTTP server, presently based on
GNAT.Sockets, needs select).

2. Which platforms are supported?

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

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Thu, 13 Nov 2014 17:36:06 -0800, Hubert wrote:

> That is a point that I have been contemplating for a while now but in 
> conjunction with Object Oriented Programming. When I look back at my 
> career I realize that I became lazier and lazier in terms of designing 
> before programming with the advent of OOP. I think OOP is designed to to 
> just that: 

Hmm, actually OOD and OOP require more upfront design than traditional
procedural approach. Ad-hoch subprograms are much easier and quicker stuff
than ad-hoc type + subprograms (=class) with thinking about possible
inheritance etc.

> Give you a false sense of "naturalism" and "ease" because 
> "objects are so natural to the way humans think" and "everything in 
> nature is an object" etc.

OK, that is OOA religion. You don't need to belive in objects created by
God in order to carefully design types your program is going to use.

In fact Ada was always OO, as you could define new types and provide
operations for these types in Ada 83. It even had some form of inheritance
in the form of type cloning (type X is new Integer). 

Some used to say that Ada 83 was object-based, but not fully
object-oriented.

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

Re: What exactly is the licensing situation with GNAT?

[Stan Mills]

On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
> On Thu, 13 Nov 2014 17:36:06 -0800, Hubert wrote:
>
>> That is a point that I have been contemplating for a while now but in 
>> conjunction with Object Oriented Programming. When I look back at my 
>> career I realize that I became lazier and lazier in terms of designing 
>> before programming with the advent of OOP. I think OOP is designed to to 
>> just that: 
>
> Hmm, actually OOD and OOP require more upfront design than traditional
> procedural approach. Ad-hoch subprograms are much easier and quicker stuff
> than ad-hoc type + subprograms (=class) with thinking about possible
> inheritance etc.

That's if you are responsible for the whole thing or care about doing it properly.

The way OO is used today all the real work is expected to have already been
done by the class library writers and the "coder" just cuts and pastes his
way to the end of the program. Next!

> In fact Ada was always OO, as you could define new types and provide
> operations for these types in Ada 83. It even had some form of inheritance
> in the form of type cloning (type X is new Integer).
>
> Some used to say that Ada 83 was object-based, but not fully
> object-oriented.

True and it was not even the first to do so. OO is supposed to be about a
way to solve problems, not about using somebody else's libraries to avoid
writing any code. But thanks to Java and lately C++ it has degenerated
considerably from the former into the latter.

Stan Mills

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> Hmm, actually OOD and OOP require more upfront design than traditional
> procedural approach. Ad-hoch subprograms are much easier and quicker stuff
> than ad-hoc type + subprograms (=class) with thinking about possible
> inheritance etc.

That maybe the theory, but what I have experienced is that it is 
immensely easy to just start writing code and have great success with 
it. In fact it is much easier than writing subprograms and modules etc. 
That is the stuff that requires planning.

Objects just "flow from the brain into the computer". But later they are 
going to bite you and that is my criticism. That it seems so easy and 
natural in the beginning which gives the programmer a false sense of 
security. But it will backfire. Again I am only referring to C++ here.

Of course I know that UML is intended to be used in the planning 
process, but it is so overcomplicated that many people will never use 
it. I know I don't (except timing diagrams which are pretty handy when 
it comes to multi threading programs).







---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Fri, 14 Nov 2014 09:02:49 +0000 (UTC), Stan Mills wrote:

> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>> On Thu, 13 Nov 2014 17:36:06 -0800, Hubert wrote:
>>
>>> That is a point that I have been contemplating for a while now but in 
>>> conjunction with Object Oriented Programming. When I look back at my 
>>> career I realize that I became lazier and lazier in terms of designing 
>>> before programming with the advent of OOP. I think OOP is designed to to 
>>> just that: 
>>
>> Hmm, actually OOD and OOP require more upfront design than traditional
>> procedural approach. Ad-hoch subprograms are much easier and quicker stuff
>> than ad-hoc type + subprograms (=class) with thinking about possible
>> inheritance etc.
> 
> That's if you are responsible for the whole thing or care about doing it properly.
> 
> The way OO is used today all the real work is expected to have already been
> done by the class library writers and the "coder" just cuts and pastes his
> way to the end of the program. Next!

This is how everything is done today. Certainly it is not OO's fault or
OO's feature. On the contrary, OO, specifically the concepts of inheritance
and instances, addresses software-reuse, which is exactly the opposite to
the cut and paste approach.

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

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Fri, 14 Nov 2014 01:19:04 -0800, Hubert wrote:

>> Hmm, actually OOD and OOP require more upfront design than traditional
>> procedural approach. Ad-hoch subprograms are much easier and quicker stuff
>> than ad-hoc type + subprograms (=class) with thinking about possible
>> inheritance etc.
> 
> That maybe the theory, but what I have experienced is that it is 
> immensely easy to just start writing code and have great success with 
> it. In fact it is much easier than writing subprograms and modules etc. 
> That is the stuff that requires planning.

I don't see how this could be true. One problem with such statements is
that people compare incomparable things or consider usage of ready
components as if it were the program of their own. If you carefully analyse
any of these activities under procedural vs. OO approach you will find
that:

1. Reuse is in order of magnitude easier and safer when with OO.

2. Writing your own new code requires more upfront thinking and writing but
is greatly safer in the long run.

Ergo, OO is good for software engineering, which should surprise nobody,
because in essence OO, leaving OOA/D religion aside, is nothing but an
improved type system.

> Objects just "flow from the brain into the computer". But later they are 
> going to bite you and that is my criticism. That it seems so easy and 
> natural in the beginning which gives the programmer a false sense of 
> security.

This is a logical fallacy. Compare: Ada gives the programmer a false sense
of security, therefore we must stick to ANSI C.

OO is as insecure as the OOPL allows it to be. E.g. Ada requires overriding
the primitive operations returning tagged results. That is secure. Ada does
not require either "overriding" or "not overriding" to appear. That is
insecure. So?

> Of course I know that UML is intended to be used in the planning 
> process, but it is so overcomplicated that many people will never use 
> it. I know I don't (except timing diagrams which are pretty handy when 
> it comes to multi threading programs).

Modeling is a part of OOA/D, not OOP. I am very sceptical about OOA/D.
Regarding modeling it is IMO a plain wrong approach to software
engineering. But again, that is not OOP. You can do OOP without modeling as
well as modeling without OOP or even without having an OOPL.

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

Re: What exactly is the licensing situation with GNAT?

[Stan Mills]

On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
> On Fri, 14 Nov 2014 09:02:49 +0000 (UTC), Stan Mills wrote:
>
>> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>>> On Thu, 13 Nov 2014 17:36:06 -0800, Hubert wrote:
>>>
>>>> That is a point that I have been contemplating for a while now but in 
>>>> conjunction with Object Oriented Programming. When I look back at my 
>>>> career I realize that I became lazier and lazier in terms of designing 
>>>> before programming with the advent of OOP. I think OOP is designed to to 
>>>> just that: 
>>>
>>> Hmm, actually OOD and OOP require more upfront design than traditional
>>> procedural approach. Ad-hoch subprograms are much easier and quicker stuff
>>> than ad-hoc type + subprograms (=class) with thinking about possible
>>> inheritance etc.
>> 
>> That's if you are responsible for the whole thing or care about doing it properly.
>> 
>> The way OO is used today all the real work is expected to have already been
>> done by the class library writers and the "coder" just cuts and pastes his
>> way to the end of the program. Next!
>
> This is how everything is done today. Certainly it is not OO's fault or
> OO's feature.

Oh, I beg to differ. Sun certainly dumbed down programming when they
designed Java. It's about making unqualified people "productive" and the
best way to do that is for qualified people to write as much code as
possible for unqualified people to use. The primary feature of OO in
practice is the huge set of class libraries to reduce the amount of future
coding as much as possible to simple cut and paste of existing bad code. The
only thing a regular programmer can't write in Java or C++ today is
something that doesn't already have a class library to do it for him.

> On the contrary, OO, specifically the concepts of inheritance and
> instances, addresses software-reuse, which is exactly the opposite to the
> cut and paste approach.

That's the theory. But in practice, having all the hard stuff written
already just promotes cutting and pasting of a different color. The code
that *uses* those classes is normally not reusable. That's what is cutting
and pasting. It's been shoved down a level or two.

Don't try and impose your sense of rigor and order on chaos and think
everybody works according to sound software engineering practice ;-)
The reality is unfortunately like I said. People are worse coders than they
were before OO and they are crippled, not enabled, by immense class
libraries. 1/2% of the people are writing 99% of the usable code. The other
guys are just invoking their methods.

I have seen guys who never wrote a program from scratch in any language, and
who can't understand or code any algorithm at all. But they are able to
build huge ivory towers of applications based on nothing but other people's
libaries. Everything is a black box to them and if you ask how it works all
they can explain is how to invoke the methods they used. It was true in C
and it's much worse with Java and C++, not to mention the new OO scripting
languages. In the end OO is about the other guy doing all the work and you
feeling like you accomplished something by using it. It's a big lie. Those
people aren't programmers, they're disabled end-users.

Stan

Re: What exactly is the licensing situation with GNAT?

[Peter Chapin]

On Fri, 14 Nov 2014, Pete Ballmer wrote:

> Other systems like LLVM would be ok except they're not supporting anything
> but Intel.

I'm not sure I understand what you mean. When I look at the LLVM web site 
I see:

"An easily retargettable code generator, which currently supports X86, 
X86-64, PowerPC, PowerPC-64, ARM, Thumb, SPARC, Alpha, CellSPU, MIPS, 
MSP430, SystemZ, and XCore."

Are you saying that only the Intel support is used or gets active 
development?

Peter

Re: What exactly is the licensing situation with GNAT?

[Peter Chapin]

On Fri, 14 Nov 2014, Stan Mills wrote:

> I have seen guys who never wrote a program from scratch in any language, 
> and who can't understand or code any algorithm at all. But they are able 
> to build huge ivory towers of applications based on nothing but other 
> people's libaries. Everything is a black box to them and if you ask how 
> it works all they can explain is how to invoke the methods they used.

Isn't this exactly the idea of abstraction and data hiding, not to mention 
software reuse? In the old days everyone wrote everything from scratch. 
What you described sounds like progress to me.

After all we don't expect programmers, even software engineers, to write 
their own compilers, assemblers, and operating systems. Those things are 
just black boxes.

I suppose one could argue that a professional software engineer should be 
capable of writing such things if they needed to, but that they only 
choose not to because it's not cost effective. So perhaps what you are 
really saying is that 99% of programmers are just not capable of writing 
the kinds of libraries they routinely use.

Peter

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Fri, 14 Nov 2014 10:38:17 +0000 (UTC), Stan Mills wrote:

> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>> On Fri, 14 Nov 2014 09:02:49 +0000 (UTC), Stan Mills wrote:
>>
>>> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>>>> On Thu, 13 Nov 2014 17:36:06 -0800, Hubert wrote:
>>>>
>>>>> That is a point that I have been contemplating for a while now but in 
>>>>> conjunction with Object Oriented Programming. When I look back at my 
>>>>> career I realize that I became lazier and lazier in terms of designing 
>>>>> before programming with the advent of OOP. I think OOP is designed to to 
>>>>> just that: 
>>>>
>>>> Hmm, actually OOD and OOP require more upfront design than traditional
>>>> procedural approach. Ad-hoch subprograms are much easier and quicker stuff
>>>> than ad-hoc type + subprograms (=class) with thinking about possible
>>>> inheritance etc.
>>> 
>>> That's if you are responsible for the whole thing or care about doing it properly.
>>> 
>>> The way OO is used today all the real work is expected to have already been
>>> done by the class library writers and the "coder" just cuts and pastes his
>>> way to the end of the program. Next!
>>
>> This is how everything is done today. Certainly it is not OO's fault or
>> OO's feature.
> 
> Oh, I beg to differ. Sun certainly dumbed down programming when they
> designed Java. It's about making unqualified people "productive" and the
> best way to do that is for qualified people to write as much code as
> possible for unqualified people to use. The primary feature of OO in
> practice is the huge set of class libraries to reduce the amount of future
> coding as much as possible to simple cut and paste of existing bad code.

Well, and the alternative would be? To re-implement everything each time?
Actually, the maturity of an engineering discipline is measured by the
level of reuse of standardised solutions and components.

> The
> only thing a regular programmer can't write in Java or C++ today is
> something that doesn't already have a class library to do it for him.

Maybe. In this context, can the regular programmer do anything better with
any of competing paradigms:

1. Procedural
2. Functional
3. Relational
 
I bet, that anybody is far better off with OO than with any from the above.

>> On the contrary, OO, specifically the concepts of inheritance and
>> instances, addresses software-reuse, which is exactly the opposite to the
>> cut and paste approach.
> 
> That's the theory. But in practice, having all the hard stuff written
> already just promotes cutting and pasting of a different color. The code
> that *uses* those classes is normally not reusable. That's what is cutting
> and pasting. It's been shoved down a level or two.

Maybe. But, again, what would be better?

As a simple example consider Ada's design of, say, Ada.Streams. This is an
OO design. The type Root_Stream_Type is as tagged as it could be.

Now, take either of the paradigms #1, #2, #3 and outline a better design of
streams. Could you?

> Don't try and impose your sense of rigor and order on chaos and think
> everybody works according to sound software engineering practice ;-)
[...]

But this is not an OO problem. The problem is with CS as a whole and with
missing software market. You need two things for having a decent
engineering discipline, that is a sound science (CS is trash) and a working
economical stimulus rewarding quality products and punishing swindlers (SW
market is ruined).

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

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Luke A. Guest]

Gour <gour@atmarama.net> wrote:
> On Thu, 13 Nov 2014 15:56:35 -0800 (PST)
> David Botton <david@botton.com> wrote:
> 
> Yesterday I researched a bit R.R.Software's web site and found that
> their Janus/Ada compiler is "...the only compiler on the market that is
> written in Ada and self compiled in a personal computer environment."

GNAT is written in Ada and can compile itself.

> It's clear that it's behind Adacore's GNAT, but, maybe, it can be basis
> of the future's (more) community-based compiler?

Unlikely it will be open sourced.

> being written in Ada might be more approachable for community members to
> help and hack on it.

I think there needs to be something totally new for that to happen.

> (http://bacula.org/), but the point is that community is actively
> contributing with patches, debugging, bugreports etc. while the main
> developers still have enough to pay the bills. :-)

Difficult with a market as small as ours :(

> 
> Another example might be Julia language which is hosted at Github and at
> the moment there are 4611 star-gazers, 935 forks and 298 contributors
> and its ecosystem is growing rapidly.

Might have a look at that.

> 
> Based on what I've seen/heard, it seems that Ada community is not much
> involved in shaping GNAT, even in its FSF incarnation...

It's more that the community has never been allowed to.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[David Botton]

> It's more that the community has never been allowed to.

What is stopping it? I have not gotten in to compiler development, but I would assume anyone can send patches to the FSF

Re: community-based compiler

[Gour]

On Fri, 14 Nov 2014 14:53:43 +0000 (UTC)
Luke A. Guest <laguest@archeia.com> wrote:

> GNAT is written in Ada and can compile itself.

Why is then GCC in equation and not bootstrapping like with e.g. GHC, D,
Nim, Rust etc...even Go is going that direction?


Sincerely,
Gour

-- 

Things that OO programming lacks (was: What exactly is the licensing situation with GNAT?)

[G.B.]

On 14.11.14 14:35, Dmitry A. Kazakov wrote:
>> That's the theory. But in practice, having all the hard stuff written
>> >already just promotes cutting and pasting of a different color. The code
>> >that*uses*  those classes is normally not reusable. That's what is cutting
>> >and pasting. It's been shoved down a level or two.
> Maybe. But, again, what would be better?

Better? A mode of expressing what we know beyond our objects,
in dedicated language:

Since programmers are starting to know more about patterns
of connecting objects, I suppose something expressing those
patterns more clearly would be useful.
For example, "connections" may refer to order of calls in time,
and to "flow" caused by "data".

A way to express these patterns of OO  programming will avoid
producing intractable state manipulation code (a.k.a. spaghetti).
OO does not prevent programmers from just operating setters
and getters, "knowing" the effects this has on the "other" object.

When a programming method using patterns relies on naming
and conventions, like the GoF patterns do, that's not language,
is it?

Another important example is events.

Consider a system with many inputs, many outputs, and also
some treads. A GUI program, or a control unit, an OS, etc.
There will be events in need of a response.
Events are generated either by programs or by the world.

Then I want to express, at the language level, using
dedicated source text:

-  What are all of the events than can have a normal effect
    on the program?

-  What are the possible orders of these events?

-  How can I arrange for orders of events to be know
    at or after run time?

-  How can I connect events expressly to objects that
    respond to the events?

-  How can I learn, by looking at specific language in
    a program, which objects are connected to an event?

At first, Ada's task type seem to covers order of events,
in bodies (only?). Using the control structure of the
language facilitates expressing possible orders:

   task body ... is
   begin
      ...
      accept first_this;
      ...
      accept then_that (...)
      ...
      loop
       select
         accept either_A (...)
         ...
       or
         accept or_B (...)
         ...
       end select;
      end loop;
   end ;

But this is only half way, since task objects' definition does not,
by design, show possible connections of multiple task objects in
a program.  The other side, that of calling tasks (selectively)
adds to the complexity of analysis.

Similarly, there are ways to place a restriction on the
order of subprogram calls. For example, one might force an order
by having a sequence of functions consume and produce objects
from an ordered sequence of types:

    function A (Obj : T0) return T1:
    function B (Obj : T1) return T2:
    ...
    function M (Obj : T16) return T5:
    ...

Or one could be using condition expressions, like in

   procedure P (Object : in out Typ; ...)
    with
      Pre => Object.State (State_No'(4711));


   function State (Object : in Typ) return State_No;

but both are not specific language, and at least the second,
i.e. Pre referring to object state, require mere conventions.

To me these look like a poor workarounds, Pre more than the types TK,
even when they assist the client programmer writing calls of
subprograms in proper order. Which only shows that a way to
express order, e.g. in interfaces, is valuable.

To have language for expressing connections in a program would
be better.  We only got tools that show graphs of a few arrows,
as in design diagrams for interfaces and models. But we do not
really have source text specifically addressing order of events,
and connections made on the occasion.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Tero Koskinen]

14.11.2014 16:53, Luke A. Guest wrote:
> Gour <gour@atmarama.net> wrote:
>> Yesterday I researched a bit R.R.Software's web site and found
>> that their Janus/Ada compiler is "...the only compiler on the
>> market that is written in Ada and self compiled in a personal
>> computer environment."
> 
> GNAT is written in Ada and can compile itself.

Actually, you need C (and these days C++) compiler also to
compile GNAT. Of course, these days almost every Linux
system has gcc&g++ installed (especially if you have GNAT installed),
so this is not a big issue.

If I have understood correctly, building Janus/Ada can be done
with "plain" Ada compiler and Microsoft linker alone, no other tools needed.

Yours,
 Tero

Re: community-based compiler

[Luke A. Guest]

Gour <gour@atmarama.net> wrote:
> On Fri, 14 Nov 2014 14:53:43 +0000 (UTC)
> Luke A. Guest <laguest@archeia.com> wrote:
> 
>> GNAT is written in Ada and can compile itself.
> 
> Why is then GCC in equation and not bootstrapping like with e.g. GHC, D,
> Nim, Rust etc...even Go is going that direction?

They're going to rewrite go in another language?

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Luke A. Guest]

David Botton <david@botton.com> wrote:
>> It's more that the community has never been allowed to.
> 
> What is stopping it? I have not gotten in to compiler development, but I
> would assume anyone can send patches to the FSF

People have sent patches to AdaCore and ended getting slagged off ending up
in massive arguments. Patches then rejected. Heard this from the person it
happened to.

Any question I have raised re certain things have been met with silence or
one liners explaining nothing and therefore being useless.

Re: community-based compiler

[Gour]

On Fri, 14 Nov 2014 16:16:22 +0000 (UTC)
Luke A. Guest <laguest@archeia.com> wrote:

> They're going to rewrite go in another language?

No, they're converting compiler from C to Go

E.g. http://gophercon.sourcegraph.com/post/83820197495/russ-cox-porting-the-go-compiler-from-c-to-go


Sincerely,
Gour

-- 
Whenever and wherever there is a decline in religious practice, 
O descendant of Bharata, and a predominant rise of irreligion — 
at that time I descend Myself.

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Fri, 14 Nov 2014 16:29:56 +0100, G.B. wrote:

> On 14.11.14 14:35, Dmitry A. Kazakov wrote:
>>> That's the theory. But in practice, having all the hard stuff written
>>> >already just promotes cutting and pasting of a different color. The code
>>> >that*uses*  those classes is normally not reusable. That's what is cutting
>>> >and pasting. It's been shoved down a level or two.
>> Maybe. But, again, what would be better?
> 
> Better? A mode of expressing what we know beyond our objects,
> in dedicated language:
> 
> Since programmers are starting to know more about patterns
> of connecting objects, I suppose something expressing those
> patterns more clearly would be useful.

What objects? There is none, as you thrown OO under the bus...

> For example, "connections" may refer to order of calls in time,
> and to "flow" caused by "data".

For example Ada.Streams show us "connecting patterns".

> Another important example is events.

I didn't list event-driven AKA data-driven paradigm in my list of
paradigms, since it is so horrific, that nobody should seriously consider
it as useful.

> Consider a system with many inputs, many outputs, and also
> some treads.

Which are? Remember the paradigms. If you are not going to introduce a new
one, there are no things you listed. In OO there are objects. In the
procedural paradigm there are subprograms (and a fixed set of types). In
functional there are functions. In relational there are relations (and a
fixed set of types). That is.

If you want going data-driven show how it could be done in the first
approximation at least more safer than randomly generated hexadecimal
code... (Saying no word about reuse)

[...]
> To me these look like a poor workarounds, Pre more than the types TK,
> even when they assist the client programmer writing calls of
> subprograms in proper order.

This is meaningless at best. If subprograms cannot be called freely, this
is a bad [procedural] design, per definition of. You should fix your
decomposition, as it evidently goes along wrong lines = couples
subprograms. Subprograms in procedural decomposition meant independent with
well defined interfaces. BTW, from this immediately follows, for example,
that global variables are bad.

> To have language for expressing connections in a program would
> be better.  We only got tools that show graphs of a few arrows,
> as in design diagrams for interfaces and models. But we do not
> really have source text specifically addressing order of events,
> and connections made on the occasion.

Not at all. There are tons of graphical languages having fancy lines all
over the screen. That helps in no way. In fact all of them are greatly less
safe, unmaintainable and inefficient as a bonus.

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

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[David Botton]

> People have sent patches to AdaCore

Why not deal directly with the FSF, there must be some maintainer on that side?

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Luke A. Guest]

David Botton <david@botton.com> wrote:
>> People have sent patches to AdaCore
> 
> Why not deal directly with the FSF, there must be some maintainer on that side?

Hmm not sure about that as they tend to merge in stuff themselves.

Re: community-based compiler

[Luke A. Guest]

Gour <gour@atmarama.net> wrote:
> On Fri, 14 Nov 2014 16:16:22 +0000 (UTC)
> Luke A. Guest <laguest@archeia.com> wrote:
> 
>> They're going to rewrite go in another language?
> 
> No, they're converting compiler from C to Go
> 
> E.g.
> http://gophercon.sourcegraph.com/post/83820197495/russ-cox-porting-the-go-compiler-from-c-to-go



I read it was written in c++ specifically to get around the bootstrap
issue.

Luke

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Shark8]

I agree with you that there ought to be another open-source 
freely-available Ada compiler -- I started some work on one a while back 
but didn't get too far (other things came up), but there are some things 
that I think we ought to consider essential:

* Tools -- We cannot accept the current norm as acceptable; we need a 
setup that is not so fragile that installing it in an unexpected place 
ruins it.
* The Library -- I've become convinced that the library model really is 
better than the source-file model, especially considering
* Projects -- We need good control for setting up projects and 
subprojects, "related-but-seprate" projects, DSA, managing 'teams', 
source control and so on... and that ties back to tools.

There's a couple interesting papers regarding using databases for 
version-control where the DB is only updated on a consistant state. 
(i.e. you cannot save non-compilable code into the DB.) -- There's also 
some interesting stuff regarding storing source 'code' in Databases. 
(DIANA [Descriptive Intermediate Attributed Notation for Ada], for example.)

There's also the OpenToken project which could be used for the 
tokenizing/parsing.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[David Botton]

> I agree with you that there ought to be another open-source 
> freely-available Ada compiler

What resources are needed to make it happen?

Although I am just as happy to see GNAT get a community project behind it to insure unencumbered runtimes and compilers available freely to all in simple easy install packages.

I am sure many including myself would get involved to work on bugs and issues if it was clear and easy to get a working dev environment and clear path to submit fixes. That may exist now, I just don't know.

Anyone have any links to getting started with building and how to submit to the FSF changes?

David Botton

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Shark8]

On 14-Nov-14 11:55, David Botton wrote:
>> I agree with you that there ought to be another open-source
>> >freely-available Ada compiler
> What resources are needed to make it happen?

Hm, I think there are several things that are needed, and which would 
have different emphasis at different points in development. -- For 
example, a good, clear plan for the overall architecture and underlying 
tech* would be essential. -- Another thing that might be useful is, from 
the ground up, employing formal methods (ie Ada/SPARK and proofs) for 
correctness.**

After the initial stages,*** the "clear path to submit patches and bug 
reports" becomes much more important after getting to an operable state.

* e.g. if it used DIANA for its interface between the front-end and 
back-end (and tools) that should be (a) shown and (b) well documented.
OR if it uses a SCID [ http://mindprod.com/project/scid.html ] approach 
documentation of the underlying DB and interfacing to it.

** In that case, for bootstrapping, it might be worth it to develop a 
Strict Ada 2012 compiler [w/ the corrigenda] in Ada 2012, meaning that 
it doesn't accept obsolescent features, and then add those later.

*** A non-encumbered, correctness-checked RTL, with as much 
implementation-/architecture-dependent stuff isolated as possible [i.e. 
as portable as possible] would be a good offshoot.

> Although I am just as happy to see GNAT get a community project behind
> it to insure unencumbered runtimes and compilers available freely to
> all in simple easy install packages.
>
> I am sure many including myself would get involved to work on bugs and
> issues if it was clear and easy to get a working dev environment and
> clear path to submit fixes. That may exist now, I just don't know.

I haven't found a good path, but then I'm more interested in a whole new 
project rather than tying ourselves down to a single implementation.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Luke A. Guest]

David Botton <david@botton.com> wrote:


> Anyone have any links to getting started with building and how to submit
> to the FSF changes?

I've seen responses on the interweb re building GCC as 'if you have to ask
you shouldn't be doing it.' No joke.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Luke A. Guest]

Shark8 <OneWingedShark@gmail.com> wrote:

> Hm, I think there are several things that are needed, and which would
> have different emphasis at different points in development. -- For
> example, a good, clear plan for the overall architecture and underlying
> tech* would be essential. -- Another thing that might be useful is, from
> the ground up, employing formal methods (ie Ada/SPARK and proofs) for correctness.**

Jesus! That would be hell. A compiler without dynamic memory? Really? No
thanks.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:fo7cw4s3dd6g$.1jh55iopdn64m$.dlg@40tude.net...
> On Thu, 13 Nov 2014 15:51:54 -0600, Randy Brukardt wrote:
>
>> I recall Adam suggesting that some special sort of named
>> access-to-subprogram type be defined with similar characteristics to the
>> anonymous access-to-subprogram. Such a thing could be made to work, while
>> the bare pointer used for normal access-to-subprogram types would not 
>> work.
>> But of course it would be susceptible to dangling pointers, and won't
>> (usually) be compatible with C.
>
> I was always wondering why it was not a plain subprogram type. That would
> solve a lot of problem, interfacing C included. E.g.

I don't know why it is an access rather than just directly a type. Perhaps a 
lack of imagination? But there's insufficient difference to justify the 
change today.

OTOH, I don't see why this would be any different than access types 
vis-a-vis interfacing with C and the like. The type would have a 
representation (likely one similar to access-to-subprogram), and that's the 
problem for 'Unrestricted_Access - it needs a different representation to 
support 'Unrestricted_Access from 'Access. And the representation needed for 
'Unrestricted_Access is incompatible with C (other than on GCC, which is 
unusual). If you simply allowed any subprogram to match a subprogram type, 
you couldn't allow interface to C. Or you'd have to have an accessibility 
check on the use only for interface to C. Or some other messy rule - would 
not gain anything.

                                            Randy.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

I've been using Claw.Sockets for so long that I don't know what the 
underlying implementation is. So I don't know what "select" is used for or 
whether it's implemented in NC_Sockets. Claw.Sockets has a server type 
that's used for implemented servers (like web and mail servers).

As to the platforms, Linux 64-bit (tested under GNAT) and Windows 32-bit 
(tested under GNAT and Janus/Ada) are what I have in hand. I suspect that 
Linux 32-bit would be easy to create based on the 64-bit version, but I've 
had no need to do so.

I'll be posting a NC_Sockets package fairly soon, once I get the last few 
spec updates finished and correct the test programs. (And I have to figure 
out error handling in the Linux version, I don't think it works right, and 
that's a big deal to my servers of course.) My best guess is that I'll get 
this done in January or so (have some ARG and ACATS tasks to do first).

                              Randy.

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:b1qru34mbble.yzrut134ayon$.dlg@40tude.net...
> On Fri, 14 Nov 2014 00:13:28 -0600, Randy Brukardt wrote:
>
>> Or build something on top of NC_Sockets, if it's not too complicated
>> (unlikely). One of the example programs for NC_Sockets is a simple web
>> server (the one used for Ada-Auth.org/RRSoftware.com is a grown-up 
>> version
>> of that example).
>
> Could you elaborate this a bit. Specifically:
>
> 1. Do NC_Scokets support socket select? (My HTTP server, presently based 
> on
> GNAT.Sockets, needs select).
>
> 2. Which platforms are supported?
>
> -- 
> Regards,
> Dmitry A. Kazakov
> http://www.dmitry-kazakov.de 

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Peter Chapin" <PChapin@vtc.vsc.edu> wrote in message 
news:alpine.CYG.2.11.1411140752250.7264@WIL414CHAPIN.vtc.vsc.edu...
...
> After all we don't expect programmers, even software engineers, to write 
> their own compilers, assemblers, and operating systems. Those things are 
> just black boxes.

I don't know about that, I did (and a mail server and web server as well). I 
just I don't play that well with others. ;-)

                               Randy.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Shark8]

On 14-Nov-14 14:07, Luke A. Guest wrote:
> Jesus! That would be hell. A compiler without dynamic memory? Really? No
> thanks.

Ah, right; I'd forgotten about that restriction -- I was thinking more 
along the lines of the prover-/verifier-tools -- though aren't there 
large chunks where you don't need dynamic memory?

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Randy Brukardt]

"Luke A. Guest" <laguest@archeia.com> wrote in message 
news:1315933065437669370.358664laguest-archeia.com@nntp.aioe.org...
> Gour <gour@atmarama.net> wrote:
>> On Thu, 13 Nov 2014 15:56:35 -0800 (PST)
>> David Botton <david@botton.com> wrote:
>>
>> Yesterday I researched a bit R.R.Software's web site and found that
>> their Janus/Ada compiler is "...the only compiler on the market that is
>> written in Ada and self compiled in a personal computer environment."
>
> GNAT is written in Ada and can compile itself.

The front-end is. The back end (GCC) is in C, I believe. Janus/Ada is all 
Ada except for a snippet of assembler in the runtime.

>> It's clear that it's behind Adacore's GNAT, but, maybe, it can be basis
>> of the future's (more) community-based compiler?
>
> Unlikely it will be open sourced.

Why do you say that? It's something I've thought about; I'd certainly do it 
if I decided to stop selling it. I don't think there is any business reason 
that it couldn't be open-sourced at this point (that wouldn't have been true 
10 years ago).

                                     Randy.

Re: What exactly is the licensing situation with GNAT?

[Jeffrey Carter]

On 11/14/2014 03:24 PM, Randy Brukardt wrote:
> 
> I don't know why it is an access rather than just directly a type. Perhaps a 
> lack of imagination? But there's insufficient difference to justify the 
> change today.

IIRC, this was initially discussed for the purpose of passing a subprogram to a
C pointer-to-function, which suggested the access-to-subprogram type with all
the attendant accessibility problems.

-- 
Jeff Carter
"I've got to stay here, but there's no reason
why you folks shouldn't go out into the lobby
until this thing blows over."
Horse Feathers
50

Re: What exactly is the licensing situation with GNAT?

[Hubert]

>> Objects just "flow from the brain into the computer". But later they are
>> going to bite you and that is my criticism. That it seems so easy and
>> natural in the beginning which gives the programmer a false sense of
>> security.
>
> This is a logical fallacy. Compare: Ada gives the programmer a false sense
> of security, therefore we must stick to ANSI C.

I don't think so. You are trying to show that my argument is false by 
giving an unrelated analogy. Consider this instead:

Total government control in a fascist state controls crime and makes 
people safer (for Instance Mussolini practically wiped out the Mafia 
during his reign) therefore we must all live in a non fascist state.

The reality is that you want to live in a non fascist state for totally 
different reasons and the security aspect has nothing to do with it.

My argument was that the ease with which OOP allows the inexperienced 
programmer to achieve quick results hides the fact that the resulting 
programs are bad and hard to manage since it is possible to achieve 
these results without thorough planning, therefore many programmers will 
chose this path because it gives quick initial results with less work. 
Instead sticking with "harder to master" techniques forces one to plan 
ahead since you don't have these "natural" objects that come easy. Not 
everything that's easy is also a progress.

There is a fair amount of criticism about OO design and programming. I 
dont think we will be able to solve that discussion here and I won't 
repeat all the arguments either since there are tons, but you are 
welcome to check out the granddaddy of all OO critics which is archived 
here:

http://reocities.com/tablizer/oopbad.htm






---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Luke A. Guest]

"Randy Brukardt" <randy@rrsoftware.com> wrote:
> "Luke A. Guest" <laguest@archeia.com> wrote in message 

> Why do you say that? It's something I've thought about; I'd certainly do it 
> if I decided to stop selling it. I don't think there is any business reason 
> that it couldn't be open-sourced at this point (that wouldn't have been true 
> 10 years ago).

Given that it's your business, I would've thought opening it up would my be
conducive to selling it any longer. Fine if you stop selling it, but you
haven't yet.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Luke A. Guest]

Shark8 <OneWingedShark@gmail.com> wrote:
> On 14-Nov-14 14:07, Luke A. Guest wrote:
>> Jesus! That would be hell. A compiler without dynamic memory? Really? No
>> thanks.
> 
> Ah, right; I'd forgotten about that restriction -- I was thinking more
> along the lines of the prover-/verifier-tools -- though aren't there
> large chunks where you don't need dynamic memory?

Not really no. An entire compiler pretty much uses the heap exclusively,
you'd be hard pressed to build a compiler using ore allocated memory or
just static amounts in general.

Re: What exactly is the licensing situation with GNAT?

[Hubert]

I don't know if I made myself clear enough.

You were trying to show that my argument was false by giving an analogy 
that sounded absurd and then concluding that my argument was equally absurd.

I tried to show that the conclusion I drew was valid, but not based on 
an argument like the one you gave but instead for other reasons. The 
fact that Ada is safer than C has nothing to do with the fact that the 
OO techniques that are present in Ada as well as C++, Java and a host of 
other modern language lead people to write badly planned software. 
Writing procedural software will instead lead to better planned software 
because it forces people to do more planning.

Hope that makes it clearer.




---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Gour]

On Fri, 14 Nov 2014 17:00:32 -0800
Hubert <herrdoktor@fumanchu.com> wrote:

> There is a fair amount of criticism about OO design and programming.
> I dont think we will be able to solve that discussion here and I
> won't repeat all the arguments either since there are tons, but you
> are welcome to check out the granddaddy of all OO critics which is
> archived here:

Or this one:

"Object-oriented programming is an exceptionally bad idea which could
only have originated in California.” – Edsger Dijkstra


Sincerely,
Gour

-- 
Never was there a time when I did not exist, 
nor you, nor all these kings; nor in the future 
shall any of us cease to be.

Re: community-based compiler

[Gour]

On Fri, 14 Nov 2014 16:40:39 -0600
"Randy Brukardt" <randy@rrsoftware.com> wrote:

> Why do you say that? It's something I've thought about; I'd certainly
> do it if I decided to stop selling it. I don't think there is any
> business reason that it couldn't be open-sourced at this point (that
> wouldn't have been true 10 years ago).

Well, I'd be glad if you could find business model to do it prior to
that.

Let me mention notable example here what is possible to achieve: Nim(rod) langauge
(http://nim-lang.org/) where its main dev (Andreas) designed nice
langauge and wrote, practically single-handedly, without support from any
company, MIT-licensed compiler written in Nim(rod) itself and today has
870 star-gazers at Github as well as ~60 contributors. All these, by
working on it in his spare time!! (Personally, I'd be happy if he
manages to make this work as source of his living as well).


With the current state of affairs, it's hard that Ada will penetrate
more into open-source market and/or fill application's space as
envisioned by David with his Gnoga project.


Sincerely,
Gour

-- 
As a strong wind sweeps away a boat on the water, 
even one of the roaming senses on which the mind 
focuses can carry away a man's intelligence.

Re: What exactly is the licensing situation with GNAT?

[Mart van de Wege]

Peter Chapin <PChapin@vtc.vsc.edu> writes:

> On Fri, 14 Nov 2014, Pete Ballmer wrote:
>
>> Other systems like LLVM would be ok except they're not supporting anything
>> but Intel.
>
> I'm not sure I understand what you mean. When I look at the LLVM web
> site I see:
>
> "An easily retargettable code generator, which currently supports X86,
> X86-64, PowerPC, PowerPC-64, ARM, Thumb, SPARC, Alpha, CellSPU, MIPS,
> MSP430, SystemZ, and XCore."
>
> Are you saying that only the Intel support is used or gets active
> development?
>
I think that might be the case yes.

The LLVM guys have a habit of claiming support for features when they
are barely out of alpha. For example, their language support is mostly
'in development' with the exception of the C family and Haskell, and yet
they claim support for multiple languages beyond that. The rather shaky
state of Ada support by way of dragonegg is a case in point.

It's a good project, and competition brings new ideas, but their and
their supporters' marketing should be taken with a grain of salt.

Mart

-- 
"We will need a longer wall when the revolution comes."
    --- AJS, quoting an uncertain source.

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Fri, 14 Nov 2014 16:24:14 -0600, Randy Brukardt wrote:

> OTOH, I don't see why this would be any different than access types 
> vis-a-vis interfacing with C and the like. The type would have a 
> representation (likely one similar to access-to-subprogram), and that's the 
> problem for 'Unrestricted_Access - it needs a different representation to 
> support 'Unrestricted_Access from 'Access. And the representation needed for 
> 'Unrestricted_Access is incompatible with C (other than on GCC, which is 
> unusual). If you simply allowed any subprogram to match a subprogram type, 
> you couldn't allow interface to C. Or you'd have to have an accessibility 
> check on the use only for interface to C. Or some other messy rule - would 
> not gain anything.

Except that whatever checks needed they will not include pointer checks. If
a nested subprogram cannot be passed to C, then it cannot. But the reason
shall not be accessibility pointer check. The only reason allowed is
"cannot implement pragma Convention".

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

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Fri, 14 Nov 2014 16:29:59 -0600, Randy Brukardt wrote:

> I've been using Claw.Sockets for so long that I don't know what the 
> underlying implementation is. So I don't know what "select" is used for or 
> whether it's implemented in NC_Sockets. Claw.Sockets has a server type 
> that's used for implemented servers (like web and mail servers).

Select() is essential for heavy duty and light weight servers as it allows
one task to handle multiple sockets without blocking. AdaSockets, the only
alternative to GNAT.Sockets I know, does not support select.

(I don't know if AWS uses blocking sockets for its server or socket-select)

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

Re: What exactly is the licensing situation with GNAT?

[Pascal Obry]

Le samedi 15 novembre 2014 à 10:29 +0100, Dmitry A. Kazakov a écrit : 
> Select() is essential for heavy duty and light weight servers as it allows
> one task to handle multiple sockets without blocking. AdaSockets, the only
> alternative to GNAT.Sockets I know, does not support select.
> 
> (I don't know if AWS uses blocking sockets for its server or socket-select)

Select of course :)

-- 
  Pascal Obry /  Magny Les Hameaux (78)

  The best way to travel is by means of imagination

  http://v2p.fr.eu.org
  http://www.obry.net

  gpg --keyserver keys.gnupg.net --recv-key F949BD3B

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Fri, 14 Nov 2014 17:24:10 -0800, Hubert wrote:

> I tried to show that the conclusion I drew was valid, but not based on 
> an argument like the one you gave but instead for other reasons. The 
> fact that Ada is safer than C has nothing to do with the fact that the 
> OO techniques that are present in Ada as well as C++, Java and a host of 
> other modern language lead people to write badly planned software.

No, this requires a demonstration, e.g. two similar projects designed by
two similar teams. 
 
> Writing procedural software will instead lead to better planned software 
> because it forces people to do more planning.

But procedural approach does not require more planning. No such thing at
all. You can start writing much easier with procedural than with OO!

It seems that you imply that since programmers know that procedural
approach is somewhat inferior, crude and unsafe, they would pay more
attention to the architecture and design. They *won't*.

And procedural is indeed crude, inferior and unsafe.

And this is exactly the argument why C would be better than Ada. Somebody
compared C with a hand grenade. Handling hand grenades makes you attentive
... but you get killed in the end, nonetheless.

And it is a strange kind of promotion by stated inferiority.

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

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Sat, 15 Nov 2014 08:22:55 +0100, Gour wrote:

> On Fri, 14 Nov 2014 17:00:32 -0800
> Hubert <herrdoktor@fumanchu.com> wrote:
> 
>> There is a fair amount of criticism about OO design and programming.
>> I dont think we will be able to solve that discussion here and I
>> won't repeat all the arguments either since there are tons, but you
>> are welcome to check out the granddaddy of all OO critics which is
>> archived here:
> 
> Or this one:
> 
> "Object-oriented programming is an exceptionally bad idea which could
> only have originated in California.” – Edsger Dijkstra

"From a scientific point of view all further attention paid to Ada is a
waste of effort." – Edsger Dijkstra

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

Re: What exactly is the licensing situation with GNAT?

[Hubert]

> No, this requires a demonstration, e.g. two similar projects designed by
> two similar teams.

To my knowledge, no such studies have ever been conducted, yet the OO 
proponents always claim that their way is superior. Over the past 20 
years there hasn't been any improvement in the usability of software I 
can see. Microsoft for instance has already moved away from the big 
"foundation classes". Most of what I see in the STL and the Ada 
libraries are templates / generics.

OOP has it's merit, for instance in UI design where it actually fits the 
reality of widgets.

I stand by my opinion that OO is dangerous because it gives the false 
impression of being easy to handle when in fact it is not.

However, this discussion is fruitless here and elsewhere. Software 
Design principles are a bit like religions especially since Software 
Design is not science but rather art and craftsmanship, otherwise two 
different teams would come to the same solution given the same problem 
and the same set of tools, which we know they will not, so we can 
continue this ad infinitum and won't find a common denominator. Besides, 
the OOP side has already won since there is basically no alternative in 
today's curriculum at universities to my knowledge.









---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: What exactly is the licensing situation with GNAT?

[Gour]

On Sat, 15 Nov 2014 10:57:14 +0100
"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote:

> "From a scientific point of view all further attention paid to Ada is
> a waste of effort." – Edsger Dijkstra

Well, considering that (for me) Ada is fine language for software
*engineerng* (and not CS), I have no problem accepting both
quotes as relevant.


Sincerely,
Gour

-- 
When your intelligence has passed out of the dense forest 
of delusion, you shall become indifferent to all that has 
been heard and all that is to be heard.

Re: What exactly is the licensing situation with GNAT?

[Tero Koskinen]

15.11.2014 11:29, Dmitry A. Kazakov wrote:
> On Fri, 14 Nov 2014 16:29:59 -0600, Randy Brukardt wrote:
> 
>> I've been using Claw.Sockets for so long that I don't know what the 
>> underlying implementation is. So I don't know what "select" is used for or 
>> whether it's implemented in NC_Sockets. Claw.Sockets has a server type 
>> that's used for implemented servers (like web and mail servers).

(Not_)Claw_Sockets does not provide select at API level. However, it
uses select() internally.

-- Taken from my Linux port
package NC.Sockets is
   ...
private
   ...
   function Select_function(Ignored           : Claw.Int;
                             Read_FD_Set       : access FD_SET_Type;
                             Write_FD_Set      : access FD_SET_Type;
                             Exceptions_FD_Set : access FD_SET_Type;
                             Timeout           : access Timeval_Type)
             return Claw.Int;
    pragma Import(C, Select_function, "select_wrapper");
end NC.Sockets;

> Select() is essential for heavy duty and light weight servers as it allows
> one task to handle multiple sockets without blocking. AdaSockets, the only
> alternative to GNAT.Sockets I know, does not support select.

C API for select() is not pretty and you need to be very careful when
using it to avoid FD_SET overflows, for example.

Many prefer to use poll() instead of select(), since API for poll() is
much cleaner.

It is also a nightmare to create Ada bindings to select(). I ended up
using a wrapper C function when creating Linux port of NC.Sockets:
https://bitbucket.org/tkoskine/not-claw-sockets-linux-x86/src/4bc1528f59f910d4ea596d6aa63936b313b293bf/select_wrapper.c?at=default

Operating system specific kqueue/epoll APIs are also popular, since
they offer some performance advantages over select/poll.

They are of course tied to specific systems, but people have
created "wrapper" libraries like libevent[1], which allow one
to choose their favorite polling mechanism and use same API
on all systems.

Yours,
 Tero

[1] http://libevent.org/

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Sat, 15 Nov 2014 11:51:16 +0100, Gour wrote:

> On Sat, 15 Nov 2014 10:57:14 +0100
> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote:
> 
>> "From a scientific point of view all further attention paid to Ada is
>> a waste of effort." – Edsger Dijkstra
> 
> Well, considering that (for me) Ada is fine language for software
> *engineerng* (and not CS), I have no problem accepting both
> quotes as relevant.

Ignoring absurdity of the idea that engineering could exist without an
underlying scientific discipline, if your interpretation of Dijkstra were
that Ada is bad science and [maybe, he never said so] good engineering,
then why you interpret his quote about OO differently?

Maybe this one would go better:

   "At one of his visits, Andrei asked my opinion about Ada. I told him
that Ada was such a mess that I shuddered at the thought that Western
security would depend on it and that I would feel much safer if the Red
Army were to adopt it as well. Andrei smiled and gave the now famous answer
"Don't worry...."." – Edsger Dijkstra

Is it about "Red Army science"? And note, this is 1989, Ada 83. If he meant
Ada bad, that was not because of OO!

Wouldn't it be simpler just to accept that Dijkstra as ingenious he
certainly was, regardless his enormous contribution to software engineering
principles, e.g. "correct by construction", didn't understand software
engineering well?

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

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Sat, 15 Nov 2014 13:18:02 +0200, Tero Koskinen wrote:

> C API for select() is not pretty and you need to be very careful when
> using it to avoid FD_SET overflows, for example.

All socket API is awful stuff.
 
> Many prefer to use poll() instead of select(), since API for poll() is
> much cleaner.
> 
> It is also a nightmare to create Ada bindings to select().

The approach should be similar to GNAT.Sockets, e.g. a medium- or
higher-level socket API with all nasty and OS-dependent details hidden.
GNAT.Sockets is medium level. Ideally, it could be a bit higher, e.g. have
a protected object waitable for a socket event.

> They are of course tied to specific systems, but people have
> created "wrapper" libraries like libevent[1], which allow one
> to choose their favorite polling mechanism and use same API
> on all systems.

Yes, that's the right way to do it.

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

Re: What exactly is the licensing situation with GNAT?

[Gour]

On Sat, 15 Nov 2014 12:26:02 +0100
"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote:

> Ignoring absurdity of the idea that engineering could exist without an
> underlying scientific discipline, 

Engineering is about being pragmatic and solving the (practical)
problems, while science is, supposed to, about finding the truth.

> if your interpretation of Dijkstra were that Ada is bad science and
> [maybe, he never said so] good engineering, then why you interpret his
> quote about OO differently?

Simply because OOP is not science, but just craft about one of many ways
how to solve problems.

> Wouldn't it be simpler just to accept that Dijkstra as ingenious he
> certainly was, regardless his enormous contribution to software
> engineering principles, e.g. "correct by construction", didn't
> understand software engineering well?

I hope you understand that I do not hold opinion that Dijkstra is
all-knowing God, but that does not mean that his quote about OOP as 'way
of solving problems' and Ada as 'science' are to be dismissed.


Sincerely,
Gour

-- 
Perform your prescribed duty, for doing so is better than not 
working. One cannot even maintain one's physical body without work.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Brian Drummond]

On Fri, 14 Nov 2014 13:53:33 -0700, Shark8 wrote:

> On 14-Nov-14 11:55, David Botton wrote:
>>> I agree with you that there ought to be another open-source
>>> >freely-available Ada compiler
>> What resources are needed to make it happen?
> 
> Hm, I think there are several things that are needed, and which would
> have different emphasis at different points in development. -- For
> example, a good, clear plan for the overall architecture and underlying
> tech* would be essential. -- Another thing that might be useful is, from
> the ground up, employing formal methods (ie Ada/SPARK and proofs) for
> correctness.**
> 
> After the initial stages,*** the "clear path to submit patches and bug
> reports" becomes much more important after getting to an operable state.
> 
> * e.g. if it used DIANA for its interface between the front-end and
> back-end (and tools) that should be (a) shown and (b) well documented.
> OR if it uses a SCID [ http://mindprod.com/project/scid.html ] approach
> documentation of the underlying DB and interfacing to it.

Having just bought the book (DIANA : An intermediate language for Ada) it 
appears to me that DIANA was effectively obsoleted by ASIS (though 
perhaps a simple ASIS <-> DIANA translation might be feasible, assuming 
compatible Ada versions). I don't believe DIANA was ever updated for 
Ada-95 for one thing, so at this point ASIS looks like a better starting 
point.

And there is an ASIS implementation independent of Adacore, which builds 
quite easily. This would seem to be a good starting point for a future 
compiler (it was originally targeted at the TENDra project which seem so 
be ... drifting. There is still some work being done on it, but without 
reference to Ada, and the GELA-Tendra interface seems to eb unavailable 
in any reasonably complete form)

Updating Gela-ASIS for Ada-2012 could be useful in its own right, and 
done approximately independently of using Gela-ASIS to supply an 
intermediate representation to an existing back-end (gcc,llvm,etc)

I am (very tentatively) looking at ghdl's intermediate representation. 
which currently interfaces to three compiler backends - gcc, 
(experimentally) LLVM, and its own 32-bit x86 JIT compiler.

A translation between ASIS and this IR would (based on the equivalent 
translation layer in ghdl) be something like a 30,000 line project in 
itself. Big, but more manageable than an entire compiler.

> I haven't found a good path, but then I'm more interested in a whole new
> project rather than tying ourselves down to a single implementation.

At this stage, I'm happy to see several paths followed, some will 
inevitably turn out to be dead ends.

-- Brian

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Sat, 15 Nov 2014 13:41:57 +0100, Gour wrote:

> On Sat, 15 Nov 2014 12:26:02 +0100
> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote:
> 
>> Ignoring absurdity of the idea that engineering could exist without an
>> underlying scientific discipline, 
> 
> Engineering is about being pragmatic and solving the (practical)
> problems,

by *applying* a specific science. E.g. mechanical engineering. Solving
practical problems is not necessary engineering. Without mechanics solving
mechanical problems is merely artisanship.

> while science is, supposed to, about finding the truth.
>
>> if your interpretation of Dijkstra were that Ada is bad science and
>> [maybe, he never said so] good engineering, then why you interpret his
>> quote about OO differently?
>
> Simply because OOP is not science, but just craft about one of many ways
> how to solve problems.

Yes. OOP is would-be engineering, the corresponding would-be science is the
types theory.

>> Wouldn't it be simpler just to accept that Dijkstra as ingenious he
>> certainly was, regardless his enormous contribution to software
>> engineering principles, e.g. "correct by construction", didn't
>> understand software engineering well?
>
> I hope you understand that I do not hold opinion that Dijkstra is
> all-knowing God, but that does not mean that his quote about OOP as 'way
> of solving problems' and Ada as 'science' are to be dismissed.

IMO his interest and competence lied elsewhere.

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

Re: What exactly is the licensing situation with GNAT?

[Florian Weimer]

* Randy Brukardt:

> Semi-related to this is that we approved Obj'Image as a language-defined 
> attribute, to be included in the 2015 Ada Corrigendum. [AdaCore told us that 
> they had used 'Img only because the language would not allow them to change 
> Image that way. The ARG has no such limitations. ;-)]

Did they drop leading space characters while they were at it? :-)

Re: What exactly is the licensing situation with GNAT?

[Robert A Duff]

Hubert <herrdoktor@fumanchu.com> writes:

>...Besides,
> the OOP side has already won since there is basically no alternative in
> today's curriculum at universities to my knowledge.

There is little emphasis on OOP at Carnegie-Mellon University in the
Computer Science curriculum.  Put "carnegie-mellon cs curriculum object
oriented" in google for more information.

- Bob

Re: Things that OO programming lacks

[Georg Bauhaus]

On 14.11.14 17:32, Dmitry A. Kazakov wrote:
>  But, again, what would be better?

>> Better? A mode of expressing what we know beyond our objects,
>> in dedicated language:

I mean our objects, not OO objects. This is about expressing notions.

>> For example, "connections" may refer to order of calls in time,
>> and to "flow" caused by "data".
>
> For example Ada.Streams show us "connecting patterns".

Ada.Streams doesn't show much, since some connections are implicit.
Which is the point. "Open" would be a hint at the object to/from
which data will flow, but you'd still have questions if a different
task object somehow has access to the stream. You look at the task's
definition, and you still miss the part that caused the I/O disaster.
That's because "connecting" data to the stream can happen anywhere
this stream is visible, and if you do *not* apply C-style discipline,
then the *language* won't help. (Broken record: "bad design, bad
design, bad design, ..." Another broken record: "use int properly,
use int properly, use int properly, ...")

Any competent engineer can write perfectly good programs in
the assembly language he knows, for the machine he knows.
That's beside the point, though, and it hides all the difficulty
that an undefined (before the fact) word like "competent engineer"
must produce.

>> Another important example is events.
>
> I didn't list event-driven ...  nobody should seriously consider
> it as useful.

GUI...  Suppose it could be made less of a burden to program
any advanced multithreaded GUI, adding controls and interactions.

> In relational there are relations (and a
> fixed set of types).

(I learned that in "relational" there are arbitrarily many types
("domains"). Even in some of its restricted SQL incarnations.)

> If you want going data-driven

I don't want to be driven. ;-) Starting from my universe, I notice that
it determines orders which cannot be designed away:

"First the water, then the acid, otherwise it won't be placid!"
"Be sure to open the lid before you add further ingredients,
  then close the lid again."

I need necessary orders to be expressed, not denied for methodological
reasons of a foreign universe. In short, I want a higher level:

- procedural includes assembly power (minus a bit)
- OO includes procedural power (minus a bit)
- ??? includes OO power (minus a bit)  <-- this I want

I want a program text to tell its readers what is supposed to happen
in certain situations.  I want that information to be explicitly
stated directly in source text, without inference, with the help
of dedicated visible language features.

By analogy, monads are a way of integrating I/O with functionism.
I want something like this in the OO programming world, at the level
of language definition, so that I can answer questions I might
be asked about a program and its effects simply by pointing my finger
at some one line of text.

If Obj_1 and Obj_2 are objects, then I would like the language
to have syntax, say "(*)", for

    Obj_1 (*) Obj_2

which would *not* be a function call.  I would like the language
to have syntax, say "{<#}" or "{#>}", for

   Event_1 {#>}  Obj_1, Obj_2, Obj_3

The cheap language version would start to make these pieces of syntax
mark relationSHIPs first, and then the compiler would check that these
relationships actually exist. If the marks turn into relations, fine,
but that makes relations just a way to formalize specific relationships
behind the scene.

'Image (was: What exactly is the licensing situation with GNAT?)

[Georg Bauhaus]

On 15.11.14 18:32, Florian Weimer wrote:
> * Randy Brukardt:
>
>> Semi-related to this is that we approved Obj'Image as a language-defined
>> attribute, to be included in the 2015 Ada Corrigendum. [AdaCore told us that
>> they had used 'Img only because the language would not allow them to change
>> Image that way. The ARG has no such limitations. ;-)]
>
> Did they drop leading space characters while they were at it? :-)

Of course not, they know about the possibility of a '-', and how
are you going to write orderly column layout if in Ada there is no space!

Perfect ground for debate.

Will 'Image be user definable?  Like Python's __str__? Very good
for obfuscation, then. Will the encoding be part of the definition,
so that I can use it in our existing trace logs?

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Shark8]

On 15-Nov-14 05:44, Brian Drummond wrote:
>> I haven't found a good path, but then I'm more interested in a whole new
>> >project rather than tying ourselves down to a single implementation.
> At this stage, I'm happy to see several paths followed, some will
> inevitably turn out to be dead ends.

Agreed.
I do hope, however, that we don't get "watered-down" or "spread too 
thin" by having too many paths.

> I am (very tentatively) looking at ghdl's intermediate representation.
> which currently interfaces to three compiler backends - gcc,
> (experimentally) LLVM, and its own 32-bit x86 JIT compiler.
>
> A translation between ASIS and this IR would (based on the equivalent
> translation layer in ghdl) be something like a 30,000 line project in
> itself. Big, but more manageable than an entire compiler.

An interesting approach.

I do wonder about VHDL though: since it's a hardware-description 
language, could it be feasible to base a compiler backend on it so that 
targeting a new system is merely a matter of feeding it the description 
of that hardware? -- Or am I completely misinterpreting what its purpose is?

> Having just bought the book (DIANA : An intermediate language for Ada) it
> appears to me that DIANA was effectively obsoleted by ASIS (though
> perhaps a simple ASIS <-> DIANA translation might be feasible, assuming
> compatible Ada versions). I don't believe DIANA was ever updated for
> Ada-95 for one thing, so at this point ASIS looks like a better starting
> point.

I can see it both ways; the ASIS, having been updated through Ada-95, 
would have a lot of the Ada 2005 stuff in-place -- on the other hand, 
updating DIANA for Ada 2012 could allow for a bit of regularizing the IR 
to handle things in a more uniform manner, as well as [possibly] 
redefining the interface in terms of GENERICs and/or INTERFACEs.*

ASIS <-> DIANA translation you mention might be possible via a 
Translation-grammar; I came across them in a paper [I think on DIANA] 
and they sound pretty interesting even if I've not heard of them before.

* Another thing that might be interesting is an [portable] IR-executor, 
this would have much of the benefit of bytecode w/o [directly] depending 
on DOTNET or JVM... heck, if that translation-grammar module works very 
well we could, in theory, make it so that adding a new target is simply 
writing a new translation-grammar.

Re: What exactly is the licensing situation with GNAT?

[Pete Ballmer]

On 2014-11-14, Peter Chapin <PChapin@vtc.vsc.edu> wrote:
> On Fri, 14 Nov 2014, Pete Ballmer wrote:
>
>> Other systems like LLVM would be ok except they're not supporting anything
>> but Intel.
>
> I'm not sure I understand what you mean. When I look at the LLVM web site 
> I see:
>
> "An easily retargettable code generator, which currently supports X86, 
> X86-64, PowerPC, PowerPC-64, ARM, Thumb, SPARC, Alpha, CellSPU, MIPS, 
> MSP430, SystemZ, and XCore."
>
> Are you saying that only the Intel support is used or gets active 
> development?

They make a lot of wild claims. Empirically it would seem "easily
retargettable" is somewhat of a stretch and "currently supports" is pure
wishful thinking or written by marketing wonks. If you actually make the
mistake of downloading the whole thing and read through the doc you find out
nothing is expected to work today except Intel. The plus side is the non-GPL
license. The downside is killing off all non-Intel platforms in major
projects. FreeBSD is going to have some real soul searching to do. And
frankly I think the architecture is overkill given what they actually
accomplish with it.

Honestly I gave up on LLVM ever running except on Intel. I bet money it
won't ever be complete on any other platform. I have a fair selection of
non-Intel hardware and after checking LLVM again and again over a few years
to see if any of it was supported and always finding it wasn't I gave up
looking. If anybody was serious about getting it to work on alternative
hardware I think it would have been available a long time ago.

Pete

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Sat, 15 Nov 2014 20:46:54 +0100, Georg Bauhaus wrote:

> On 14.11.14 17:32, Dmitry A. Kazakov wrote:
>>  But, again, what would be better?
> 
>>> Better? A mode of expressing what we know beyond our objects,
>>> in dedicated language:
> 
> I mean our objects, not OO objects. This is about expressing notions.

There is no "our objects" in non-object-oriented paradigms.

>>> For example, "connections" may refer to order of calls in time,
>>> and to "flow" caused by "data".
>>
>> For example Ada.Streams show us "connecting patterns".
> 
> Ada.Streams doesn't show much, since some connections are implicit.
> Which is the point. "Open" would be a hint at the object to/from
> which data will flow, but you'd still have questions if a different
> task object somehow has access to the stream.

Again, what paradigm are you talking about? Task is an object in OO. In
other paradigms there no such thing. E.g. in the procedural paradigm there
will be a set of subprograms to start, stop implicit tasks, proxy data
types like task ID, but never an explicit task object.

> You look at the task's definition,

And this is where you must start. Since the task is not an object, how a
task is spelled in your paradigm?

>>> Another important example is events.
>>
>> I didn't list event-driven ...  nobody should seriously consider
>> it as useful.
> 
> GUI...  Suppose it could be made less of a burden to program
> any advanced multithreaded GUI, adding controls and interactions.

GUI frameworks you are talking about are not written or interfaced in a
data-driven language (DDL). They are in OOPLs. The event-driven
architecture of such applications /= the programming paradigm, which is
still OO and partially procedural. 

When GUI applications are written in a DDL they are disaster, example:
LabView.

 > I want a program text to tell its readers what is supposed to happen
> in certain situations.  I want that information to be explicitly
> stated directly in source text, without inference, with the help
> of dedicated visible language features.

This is what *any* programming language does. Its text (program) describes
behavior (in some computational environment). What you probably missed is
that the behavior is *always* described in the language terms. Thus
"happens" and "situation" are the language domain terms, not the reality
terms. If you accept that, your statement is a truism. If you mean the
reality, the statement is just meaningless. Only God speaks the language
which computational environment is the reality.

> If Obj_1 and Obj_2 are objects, then I would like the language
> to have syntax, say "(*)", for
> 
>     Obj_1 (*) Obj_2
> 
> which would *not* be a function call.

Then these are not objects. The only thing you can do with objects is to
use the operations of. This is called typing.

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

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Brian Drummond]

On Sat, 15 Nov 2014 15:47:41 -0700, Shark8 wrote:

> On 15-Nov-14 05:44, Brian Drummond wrote:
>>> I haven't found a good path, but then I'm more interested in a whole
>>> new
>>> >project rather than tying ourselves down to a single implementation.
>> At this stage, I'm happy to see several paths followed, some will
>> inevitably turn out to be dead ends.
> 
> Agreed.
> I do hope, however, that we don't get "watered-down" or "spread too
> thin" by having too many paths.
> 
>> I am (very tentatively) looking at ghdl's intermediate representation.
>> which currently interfaces to three compiler backends - gcc,
>> (experimentally) LLVM, and its own 32-bit x86 JIT compiler.
>>
>> A translation between ASIS and this IR would (based on the equivalent
>> translation layer in ghdl) be something like a 30,000 line project in
>> itself. Big, but more manageable than an entire compiler.
> 
> An interesting approach.
> 
> I do wonder about VHDL though: since it's a hardware-description
> language, could it be feasible to base a compiler backend on it so that
> targeting a new system is merely a matter of feeding it the description
> of that hardware? -- Or am I completely misinterpreting what its purpose
> is?

VHDL is indeed a hardware description language. However GHDL is a VHDL 
simulator : its gcc and llvm forms create executables which run as any 
other. If you use logic simulation types, they will be slow and 
inefficient executables, but if you use integer, boolean, array, record 
there need be no speed penalty (beyond that arising from the one man 
spare time effort, vs however large Adacore's team is). 

Its author now works for Adacore (or did, last I heard) so I don't want 
to use his pre-existing work for anything more than experiments without 
clearing up any possible conflict of interest concerns he might have.

> * Another thing that might be interesting is an [portable] IR-executor,
> this would have much of the benefit of bytecode w/o [directly] depending
> on DOTNET or JVM... heck, if that translation-grammar module works very
> well we could, in theory, make it so that adding a new target is simply
> writing a new translation-grammar.

Heh. Back in the Linn Rekursiv days where you could microcode arbitrarily 
complex instructions, I wanted to experiment with a genuinely recursive 
instruction set, that would execute directly off a parse tree...

- Brian

Re: Things that OO programming lacks

[Simon Wright]

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

> I didn't list event-driven AKA data-driven paradigm in my list of
> paradigms, since it is so horrific, that nobody should seriously
> consider it as useful.

The event-driven approach to (real-time) software is the only way to
build such systems: any other way is bound to lead to confusion and
disaster.

£0.02

Re: Things that OO programming lacks

[Shark8]

On 16-Nov-14 03:18, Dmitry A. Kazakov wrote:
> There is no "our objects" in non-object-oriented paradigms.

Sure there is:
Ada 83 LRM 3.2, first sentence:
"An object is an entity that contains (has) a value of a given type."

It's widely acknowledged that Ada 83 is/was not object-oriented; 
therefore either the definition (LRM) is wrong, or your assertion is.

Re: Things that OO programming lacks

[Niklas Holsti]

On 14-11-16 19:54 , Simon Wright wrote:
> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
> 
>> I didn't list event-driven AKA data-driven paradigm in my list of
>> paradigms, since it is so horrific, that nobody should seriously
>> consider it as useful.
> 
> The event-driven approach to (real-time) software is the only way to
> build such systems: any other way is bound to lead to confusion and
> disaster.
> 
> £0.02

"No Sale" even at that price (meaning I disagree).

But of course this depends on what, precisely, is meant by "event-driven
approach".

It is true that any system that must react to asynchronous inputs, be
they called "events" or whatever, must in its design be "event-driven"
to some extent. But this does NOT mean that the internal architecture of
the SW should be based on message-passing, or FSAs communicating by
events, or anything like that. Such internal architectures
(unfortunately, often the result of the autocode generators of
single-minded model-based design tools) can be HUGELY complex,
inefficient, and beastly to analyse or understand. In my not-so-humble
opinion.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .

Re: Things that OO programming lacks

[Simon Wright]

Niklas Holsti <niklas.holsti@tidorum.invalid> writes:

> On 14-11-16 19:54 , Simon Wright wrote:
>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
>> 
>>> I didn't list event-driven AKA data-driven paradigm in my list of
>>> paradigms, since it is so horrific, that nobody should seriously
>>> consider it as useful.
>> 
>> The event-driven approach to (real-time) software is the only way to
>> build such systems: any other way is bound to lead to confusion and
>> disaster.
>> 
>> £0.02
>
> "No Sale" even at that price (meaning I disagree).
>
> But of course this depends on what, precisely, is meant by
> "event-driven approach".
>
> It is true that any system that must react to asynchronous inputs, be
> they called "events" or whatever, must in its design be "event-driven"
> to some extent. But this does NOT mean that the internal architecture
> of the SW should be based on message-passing, or FSAs communicating by
> events, or anything like that. Such internal architectures
> (unfortunately, often the result of the autocode generators of
> single-minded model-based design tools) can be HUGELY complex,
> inefficient, and beastly to analyse or understand. In my not-so-humble
> opinion.

I was only trying to make as evidence-free an assertion as Dmitry's.

I don't think that we are going to agree on this point, or even have an
actual argument, partly because I'm not in a position to produce any
evidence myself.

Re: community-based compiler

[Florian Weimer]

* Luke A. Guest:

>> Yesterday I researched a bit R.R.Software's web site and found that
>> their Janus/Ada compiler is "...the only compiler on the market that is
>> written in Ada and self compiled in a personal computer environment."
>
> GNAT is written in Ada and can compile itself.

It's just the front end, though.

There are some non-GCC back ends, but I'm not sure if any of them
compiles down to machine code for a real CPU.

>> Based on what I've seen/heard, it seems that Ada community is not much
>> involved in shaping GNAT, even in its FSF incarnation...
>
> It's more that the community has never been allowed to.

Some time ago, I contributed a few patches.  Nothing significant, but
it is possible.  Contributions to the actual compiler (instead of
ports to more obscure GNU/Linux platforms) are still rare, though.
There are bound to be some process glitches initially if external
contributors showed up.  So far, coordination with an outside
community about compiler internals hasn't been necessary.

Re: community-based compiler

[Florian Weimer]

* David Botton:

>> People have sent patches to AdaCore
>
> Why not deal directly with the FSF, there must be some maintainer on
> that side?

You'd have to send them not the FSF, but the GCC project, after doing
the copyright assignment paperwork.

Re: community-based compiler

[Florian Weimer]

* Luke A. Guest:

> I read it was written in c++ specifically to get around the bootstrap
> issue.

The Go front end in GCC is written in C++.  The official Go
implementation has a different front end, and the toolchain is not
based on GNU, but the Plan 9 toolchain.

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Sun, 16 Nov 2014 11:51:03 -0700, Shark8 wrote:

> On 16-Nov-14 03:18, Dmitry A. Kazakov wrote:
>> There is no "our objects" in non-object-oriented paradigms.
> 
> Sure there is:
> Ada 83 LRM 3.2, first sentence:
> "An object is an entity that contains (has) a value of a given type."
> 
> It's widely acknowledged that Ada 83 is/was not object-oriented; 
> therefore either the definition (LRM) is wrong, or your assertion is.

Sure there are computational object. The question is whether the paradigm
promotes them or tries to abstract away.

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

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Sun, 16 Nov 2014 17:54:06 +0000, Simon Wright wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
> 
>> I didn't list event-driven AKA data-driven paradigm in my list of
>> paradigms, since it is so horrific, that nobody should seriously
>> consider it as useful.
> 
> The event-driven approach to (real-time) software is the only way to
> build such systems: any other way is bound to lead to confusion and
> disaster.

On the contrary, real-time software requires predictability, which leads to
rather to polling-based architectures oriented to the worst case scenario.

But architecture of given piece of software /= programming paradigm,
anyway.

Examples data/even-driven languages are MatLab/SIMULINK, LabView, Diadem.

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

Re: What exactly is the licensing situation with GNAT?

[Florian Weimer]

* Peter Chapin:

> Are you saying that only the Intel support is used or gets active
> development?

I think these days, llvmpipe runs well enough on ppc64 to be useful.

Apple as a downstream also has a working ARM toolchain that uses LLVM.
I don't know how much of that they contribute back.

Re: Things that OO programming lacks

[Simon Wright]

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

> On Sun, 16 Nov 2014 17:54:06 +0000, Simon Wright wrote:
>
>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
>> 
>>> I didn't list event-driven AKA data-driven paradigm in my list of
>>> paradigms, since it is so horrific, that nobody should seriously
>>> consider it as useful.
>> 
>> The event-driven approach to (real-time) software is the only way to
>> build such systems: any other way is bound to lead to confusion and
>> disaster.
>
> On the contrary, real-time software requires predictability, which
> leads to rather to polling-based architectures oriented to the worst
> case scenario.

My experience is with relatively soft real-time (I mean, the
requirements from the system engineers were mostly quite a bit broader
than was easily achievable).

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Shark8]

On 16-Nov-14 04:12, Brian Drummond wrote:
> Heh. Back in the Linn Rekursiv days where you could microcode arbitrarily
> complex instructions, I wanted to experiment with a genuinely recursive
> instruction set, that would execute directly off a parse tree...

That sounds like it would be a really interesting project.

Re: What exactly is the licensing situation with GNAT?

[Stan Mills]

On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
> On Fri, 14 Nov 2014 01:19:04 -0800, Hubert wrote:
>
>>> Hmm, actually OOD and OOP require more upfront design than traditional
>>> procedural approach. Ad-hoch subprograms are much easier and quicker stuff
>>> than ad-hoc type + subprograms (=class) with thinking about possible
>>> inheritance etc.
>> 
>> That maybe the theory, but what I have experienced is that it is 
>> immensely easy to just start writing code and have great success with 
>> it. In fact it is much easier than writing subprograms and modules etc. 
>> That is the stuff that requires planning.

Yes, this is part of the problem. OO appears to make productivity better but
it comes with costs that are apparently too high like people being unable to
troubleshoot large applications because they used stuff without
understanding it.

> I don't see how this could be true. One problem with such statements is
> that people compare incomparable things or consider usage of ready
> components as if it were the program of their own. If you carefully analyse
> any of these activities under procedural vs. OO approach you will find
> that:
>
> 1. Reuse is in order of magnitude easier and safer when with OO.

That's when it's done properly and qualified people write the objects *and*
qualified people deploy the objects. The way OO is used now is as a crutch
to allow labor-quality "coders" work over their heads. This is dangerous.
Just because the top scientists discover cures for terrible diseases doesn't
mean the guy who takes out the trash in your office building is qualified to
be a doctor just by filling a syringe with the stuff the scientists developed.

> 2. Writing your own new code requires more upfront thinking and writing but
> is greatly safer in the long run.

True. Now what about the benefits of reusability? Can we conclude software
reusability is only good locally when the guy reuses his own good code, but
unqualified people using other people's code is harmful? I think so.

> Ergo, OO is good for software engineering, which should surprise nobody,
> because in essence OO, leaving OOA/D religion aside, is nothing but an
> improved type system.

Agreed! But it comes with a very negative side effect. See above.

> This is a logical fallacy. Compare: Ada gives the programmer a false sense
> of security, therefore we must stick to ANSI C.

Haha. I can only respond to this by saying yeah that's pretty much what
happens ;-)

Stan

Re: What exactly is the licensing situation with GNAT?

[Stan Mills]

On 2014-11-14, Peter Chapin <PChapin@vtc.vsc.edu> wrote:
> On Fri, 14 Nov 2014, Stan Mills wrote:
>
>> I have seen guys who never wrote a program from scratch in any language, 
>> and who can't understand or code any algorithm at all. But they are able 
>> to build huge ivory towers of applications based on nothing but other 
>> people's libaries. Everything is a black box to them and if you ask how 
>> it works all they can explain is how to invoke the methods they used.
>
> Isn't this exactly the idea of abstraction and data hiding, not to mention 
> software reuse? In the old days everyone wrote everything from scratch. 
> What you described sounds like progress to me.

It's not. It only sounds like it. We used abstraction and data hiding many
decades ago without any of the bad effects of the way the OO environment
seems to be going in the Java and C++ age.

We could call it progress would if the quality and professionalism of coders
using these systems either increased or at least didn't decrease and if the
coders using those abstractions were capable of designing and coding them
themselves but just that the work was already done so they can do other
stuff instead. That's value. The way things are now abstractions are things
99.9% of "coders" can't understand (too abstract) and the hiding is from the
programmer's understanding. It has created a bizarro world where knowing how
things work is considered worthless. That's disabling and wrong.

The point people seem to be missing here is all this stuff only helps if it
was done right and saves work but not at the expense of dumbing down the
profession and enabling unqualified people to be "productive". If it only
saves work up front (because things that are done wrong and break are very
costly to fix- and this is comp.lang.ada so we're all somewhat aware of the
benefit of discipline, planning, and using qualified people) then programming
is reduced to essentially unqualified people cutting and pasting that's
bad. The state of coding today shows this doesn't work. People can't get
even web stuff right and how much more so serious, major systems in Java and
C++.

It's bad because these systems grow out of control, beyond any person
or persons understanding and they get to the point where things break and
nobody can fix them. The breakage takes various forms from obvious bad
results to tougher things like unacceptable performance and the costs of
fixing those things are too high. The driving force in OO is to reduce
personnel costs not software costs and in my experience that is a false
economy. Hiring the best people always pays for itself, and it has ever
since Brook's book showed real numbers.

> After all we don't expect programmers, even software engineers, to write 
> their own compilers, assemblers, and operating systems. Those things are 
> just black boxes.

But when people were closer to compilers, assemblers, and operating systems
the quality of the code and the ability to fix it were much higher than they
are now. The other problem with class libraries and libraries generally is
there is a lot more thrashing and fingerpointing when something goes wrong.
If you control the product end to end you have nobody to blame but yourself
and you learn very quickly to suspect your own work and to find and fix it
then if you can waste a few weeks chasing your tail without anybody thinking
it's unusual.

> I suppose one could argue that a professional software engineer should be 
> capable of writing such things if they needed to, but that they only 
> choose not to because it's not cost effective. So perhaps what you are 
> really saying is that 99% of programmers are just not capable of writing 
> the kinds of libraries they routinely use.

Yes but more than that I am saying this state of affairs is a problem. It
causes succeeding generations of programmers to be less qualified to
program and it encourages and enables unqualified people to work over their
heads. And I think the major software failures we have seen in the last 15
years whether in C or OO languages are a result of this.

Stan

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Mon, 17 Nov 2014 08:11:03 +0000 (UTC), Stan Mills wrote:

> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:

>> 1. Reuse is in order of magnitude easier and safer when with OO.
> 
> That's when it's done properly and qualified people write the objects *and*
> qualified people deploy the objects. The way OO is used now is as a crutch
> to allow labor-quality "coders" work over their heads. This is dangerous.

Yes. But you cannot hire topnotch guys for every project. It is all about
engineering vs art. Engineers are average guys. The tools they handle must
fit an average guy. How otherwise could you predict the costs and quality
of a product?

[Yes,  SW engineering is not a proper engineering yet]

> Just because the top scientists discover cures for terrible diseases doesn't
> mean the guy who takes out the trash in your office building is qualified to
> be a doctor just by filling a syringe with the stuff the scientists developed.
> 
>> 2. Writing your own new code requires more upfront thinking and writing but
>> is greatly safer in the long run.
> 
> True. Now what about the benefits of reusability? Can we conclude software
> reusability is only good locally when the guy reuses his own good code, but
> unqualified people using other people's code is harmful? I think so.

No. Reusability is the only way to move forward. Complexity will continue
growing and there is no other means to fight it than per reuse.

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

Re: What exactly is the licensing situation with GNAT?

[Stan Mills]

On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
> On Fri, 14 Nov 2014 10:38:17 +0000 (UTC), Stan Mills wrote:
>
>> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>>> On Fri, 14 Nov 2014 09:02:49 +0000 (UTC), Stan Mills wrote:
>>>
>>>> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>>>>> On Thu, 13 Nov 2014 17:36:06 -0800, Hubert wrote:
>>>>>
>> Oh, I beg to differ. Sun certainly dumbed down programming when they
>> designed Java. It's about making unqualified people "productive" and the
>> best way to do that is for qualified people to write as much code as
>> possible for unqualified people to use. The primary feature of OO in
>> practice is the huge set of class libraries to reduce the amount of future
>> coding as much as possible to simple cut and paste of existing bad code.
>
> Well, and the alternative would be? To re-implement everything each time?

No, the alternative is if the qualified people who were involved in
engineering the class libraries actually designed coded and maintained the
whole application using those class libraries. Barring that, using qualified
people would be a good start.

> Actually, the maturity of an engineering discipline is measured by the
> level of reuse of standardised solutions and components.

That works for engineering but large software systems are not successful
when built entirely or even in major part with foreign components. Large
software systems may be engineering, but they are not manufacturing.

And engineers still have standards and best practices and those are well
enough known. In the software world all we have is ....

>
>> The
>> only thing a regular programmer can't write in Java or C++ today is
>> something that doesn't already have a class library to do it for him.
>
> Maybe. In this context, can the regular programmer do anything better with
> any of competing paradigms:
>
> 1. Procedural

Bad programmers are exposed more quickly by procedural methodology more than
OO. They can't deliver stuff that works, on time, so you fire them.

> 2. Functional

Not sure it has any use in most commerce and industry.

> 3. Relational

What? ;-)

>  
> I bet, that anybody is far better off with OO than with any from the
>above.

I don't agree and the problem is not limited to OO. It's just magnitudes
worse with OO because all the "hard" stuff is done by the other guy. This
allows people to work over their heads and in my experience that is never
ever a good thing. The main thing OO hides is unqualified programmers.

Not that OO couldn't be used well. Just that it isn't. The costs turned out
to be much higher than the benefits. Then again when 99.9% of all code is
web and phone apps maybe we're wasting our time worrying about it.

>>> On the contrary, OO, specifically the concepts of inheritance and
>>> instances, addresses software-reuse, which is exactly the opposite to the
>>> cut and paste approach.
>> 
>> That's the theory. But in practice, having all the hard stuff written
>> already just promotes cutting and pasting of a different color. The code
>> that *uses* those classes is normally not reusable. That's what is cutting
>> and pasting. It's been shoved down a level or two.
>
> Maybe. But, again, what would be better?

Using qualified people end to end. Then the problem goes away.

> But this is not an OO problem. The problem is with CS as a whole and with
> missing software market.

Yes but I think OO masks the problem to a great extent and that is what I
have been trying to say.

> You need two things for having a decent
> engineering discipline, that is a sound science (CS is trash) and a working
> economical stimulus rewarding quality products and punishing swindlers (SW
> market is ruined).

Agreed!

Stan

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Sun, 16 Nov 2014 20:33:21 +0000, Simon Wright wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
> 
>> On Sun, 16 Nov 2014 17:54:06 +0000, Simon Wright wrote:
>>
>>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
>>> 
>>>> I didn't list event-driven AKA data-driven paradigm in my list of
>>>> paradigms, since it is so horrific, that nobody should seriously
>>>> consider it as useful.
>>> 
>>> The event-driven approach to (real-time) software is the only way to
>>> build such systems: any other way is bound to lead to confusion and
>>> disaster.
>>
>> On the contrary, real-time software requires predictability, which
>> leads to rather to polling-based architectures oriented to the worst
>> case scenario.
> 
> My experience is with relatively soft real-time (I mean, the
> requirements from the system engineers were mostly quite a bit broader
> than was easily achievable).

Even so. I try to explain why I believe that event-driven is bad as a
paradigm. The fundamental problem with events is that they are not
composable. You can split an event into new events, but you cannot join
events. Where they came from, in physical processes, you can always combine
events because in the Newtonian physics time and values are continuous.
Thus you can group things into a process vector at will. This is not so in
digital computing. Let you have two signals X, Y and want to produce Z=X+Y.
This is a trivial task in procedural, functional OO decomposition (not in
relational one). With events, when X and Y are sampled (asynchronously),
digitized (stochastically) and propagated through the system layers
([bounded] random delays), this does not work. You immediately run into a
race condition. So even tasks considered trivial in other paradigms are
hard problems in the event-driven one.

P.S. Nonetheless, most of a hardware is event-driven and of software
middleware frameworks have an event-driven architecture.

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

Re: What exactly is the licensing situation with GNAT?

[Stan Mills]

On 2014-11-17, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
> On Mon, 17 Nov 2014 08:11:03 +0000 (UTC), Stan Mills wrote:
>
>> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>
>>> 1. Reuse is in order of magnitude easier and safer when with OO.
>> 
>> That's when it's done properly and qualified people write the objects *and*
>> qualified people deploy the objects. The way OO is used now is as a crutch
>> to allow labor-quality "coders" work over their heads. This is dangerous.
>
> Yes. But you cannot hire topnotch guys for every project. It is all about
> engineering vs art. Engineers are average guys. The tools they handle must
> fit an average guy. How otherwise could you predict the costs and quality
> of a product?

Yes you can hire topnotch guys for every project and you should because
hiring the best guys is the best way to save money! See Mythical Man
Month. He shows real numbers about how much more productive in terms of
correct code the best guys are vs. not the best guys. This is what I have
seen. I have seen guys that were paid 20 or 30% more than average save or
make the company tens or hundreds of millions and the middle guys cost the
company money. Why this isn't tattooed on every manager's head is hard to
figure. Topnotch guys don't cost you anything, they pay for themselves and
then some. The whole idea people costing you is what allows OO to make
things worse.

>> True. Now what about the benefits of reusability? Can we conclude software
>> reusability is only good locally when the guy reuses his own good code, but
>> unqualified people using other people's code is harmful? I think so.
>
> No. Reusability is the only way to move forward. Complexity will continue
> growing and there is no other means to fight it than per reuse.

Again there are two forms of reuse. There is the dumb form where reuse
enables people to use unqualified people to work over their heads, above
their abilities. This is a mistake and costs people money.

The form of reuse where it's only reuse in that it was done properly and can
be used by qualified people who could have done all that work, only it was
already done and they fully understand it so now they can save time and do
other things.

Certainly the transition from a more traditional approach of services and
consumers to the current status of endless layers of middleware have made
things more complex. Complexity growth is the problem and it's a symptom of
bad design. Saying it can be fought is the wrong approach and it is the
approach of OO, which is clearly losing the battel. Complexity has to be
eliminated by changing the model from middleware uberalles to sensible
ground-up designs that may not reuse existing code or use other class
libraries, but can themselves offer reusable components to future projects.

Stan

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Mon, 17 Nov 2014 08:48:55 +0000 (UTC), Stan Mills wrote:

> On 2014-11-17, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>> On Mon, 17 Nov 2014 08:11:03 +0000 (UTC), Stan Mills wrote:
>>
>>> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>>
>>>> 1. Reuse is in order of magnitude easier and safer when with OO.
>>> 
>>> That's when it's done properly and qualified people write the objects *and*
>>> qualified people deploy the objects. The way OO is used now is as a crutch
>>> to allow labor-quality "coders" work over their heads. This is dangerous.
>>
>> Yes. But you cannot hire topnotch guys for every project. It is all about
>> engineering vs art. Engineers are average guys. The tools they handle must
>> fit an average guy. How otherwise could you predict the costs and quality
>> of a product?
> 
> Yes you can hire topnotch guys for every project and you should because
> hiring the best guys is the best way to save money!

There is not enough such people per definition. If only X % were suitable
for hiring what other 100 - X % would do? If they cannot earn money for
living you won't get enough programmers base to select topnotch X guys from
them. Economics does not work that way.

In engineering you cannot rely on excellence. Excellence is unreliable.
Engineering is, because it is based on average people and average tools.

> Topnotch guys don't cost you anything, they pay for themselves and
> then some.

It is not a question of money. They are not there for any price.

>>> True. Now what about the benefits of reusability? Can we conclude software
>>> reusability is only good locally when the guy reuses his own good code, but
>>> unqualified people using other people's code is harmful? I think so.
>>
>> No. Reusability is the only way to move forward. Complexity will continue
>> growing and there is no other means to fight it than per reuse.
> 
> Again there are two forms of reuse. There is the dumb form where reuse
> enables people to use unqualified people to work over their heads, above
> their abilities. This is a mistake and costs people money.

The only good reuse is dumb reuse.

> The form of reuse where it's only reuse in that it was done properly and can
> be used by qualified people who could have done all that work, only it was
> already done and they fully understand it so now they can save time and do
> other things.

You are contradicting to yourself. If you rely on extraordinary people,
they certainly could reuse unsafe, overcomplicated components. Compare this
to usual C advocacy: "no competent programmer would do that stupid bug."

> Complexity growth is the problem and it's a symptom of bad design.

No. It is a result of the natural process of maturity. Modern cars are
incomparably more complex than first cars. Nevertheless they are better
designed and safer. Modern software does more functionally with more
constrains set upon it (non-functionally), this necessarily makes it more
complex. Engineering is the only way to maintain complexity, not reducing
complexity, that is not possible.

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

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Mon, 17 Nov 2014 08:36:49 +0000 (UTC), Stan Mills wrote:

> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>> On Fri, 14 Nov 2014 10:38:17 +0000 (UTC), Stan Mills wrote:
>>
>>> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>>>> On Fri, 14 Nov 2014 09:02:49 +0000 (UTC), Stan Mills wrote:
>>>>
>>>>> On 2014-11-14, Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>>>>>> On Thu, 13 Nov 2014 17:36:06 -0800, Hubert wrote:
>>>>>>
>>> Oh, I beg to differ. Sun certainly dumbed down programming when they
>>> designed Java. It's about making unqualified people "productive" and the
>>> best way to do that is for qualified people to write as much code as
>>> possible for unqualified people to use. The primary feature of OO in
>>> practice is the huge set of class libraries to reduce the amount of future
>>> coding as much as possible to simple cut and paste of existing bad code.
>>
>> Well, and the alternative would be? To re-implement everything each time?
> 
> No, the alternative is if the qualified people who were involved in
> engineering the class libraries actually designed coded and maintained the
> whole application using those class libraries. Barring that, using qualified
> people would be a good start.

Where is a difference? If your program is going to use TCP/IP sockets, you
either hire gray-haired pensioners who wrote the Berkeley API (horrific
stuff, BTW) or you redesign it from scratch. Since the former is not
possible, only the later remains.

>> Actually, the maturity of an engineering discipline is measured by the
>> level of reuse of standardised solutions and components.
> 
> That works for engineering but large software systems are not successful
> when built entirely or even in major part with foreign components.

It is a risk which must be evaluated and contained. If the risk quite
frequently is too high that indicates immaturity of software engineering.
Nobody denies that fact.

>>> The
>>> only thing a regular programmer can't write in Java or C++ today is
>>> something that doesn't already have a class library to do it for him.
>>
>> Maybe. In this context, can the regular programmer do anything better with
>> any of competing paradigms:
>>
>> 1. Procedural
> 
> Bad programmers are exposed more quickly by procedural methodology more than
> OO. They can't deliver stuff that works, on time, so you fire them.

Which is why OO is better than procedural. The goal of software engineering
is to develop programs. It is not exposure of fools.
 
>> 2. Functional
> 
> Not sure it has any use in most commerce and industry.

Yep.

>> 3. Relational
> 
> What? ;-)

Like with functional there are a lot of people crazy enough to believe in
this paradigm.

>> I bet, that anybody is far better off with OO than with any from the
>>above.
> 
> I don't agree and the problem is not limited to OO. It's just magnitudes
> worse with OO because all the "hard" stuff is done by the other guy. This
> allows people to work over their heads and in my experience that is never
> ever a good thing.

This is called division of labor. Why is it bad thing in programming when
being good everywhere else?

> The main thing OO hides is unqualified programmers.

Yes, just like bus traffic hides unqualified horse riders...

> Using qualified people end to end. Then the problem goes away.

There are no people qualified to redesign everything needed by an average
SW project.

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

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Natasha Kerensikova]

Hello,

On 2014-11-15, Brian Drummond <brian3@shapes.demon.co.uk> wrote:
> And there is an ASIS implementation independent of Adacore, which builds 
> quite easily. This would seem to be a good starting point for a future 
> compiler (it was originally targeted at the TENDra project which seem so 
> be ... drifting. There is still some work being done on it, but without 
> reference to Ada, and the GELA-Tendra interface seems to eb unavailable 
> in any reasonably complete form)
>
> Updating Gela-ASIS for Ada-2012 could be useful in its own right, and 
> done approximately independently of using Gela-ASIS to supply an 
> intermediate representation to an existing back-end (gcc,llvm,etc)

Just for the record, I have started doing exactly that.

You can follow my progress on the following github repository:
https://github.com/faelys/gela-asis

Currently there is only the official 0.3.2 release, because I'm still
trying several different things to make it work with AdaControl, and I
will publish whatever works when it does.

If anyone manages to complete it before I do, merge requests are
more-than-welcome. Similarly, if anyone wants to contribute to Gela
improvement, I will happily work as curator/reviewer/coordinator of
patches, though you might want to delay improvement patches to after
AdaControl-based validation is operational.

Short term I will probably go towards mimicking ASIS-for-GNAT behaviour
(since it's the only post-Ada95 reference anyway), e.g. lazy loading of
compilation unit, defaulting to loading everything in the current
directory, decoding ADA_SEARCH_PATH environment, etc. It will make
AdaControl intergration much easier, which will help tremendously
the validation of ASIS part of GELA.

> I am (very tentatively) looking at ghdl's intermediate representation. 
> which currently interfaces to three compiler backends - gcc, 
> (experimentally) LLVM, and its own 32-bit x86 JIT compiler.
>
> A translation between ASIS and this IR would (based on the equivalent 
> translation layer in ghdl) be something like a 30,000 line project in 
> itself. Big, but more manageable than an entire compiler.

I would have went through the direct Ada-to-LLVM route, which also feels
small enough to be handle by a single person or a few people, but I
agree without your (snipped) comment about following several paths.
Please let us know how it goes :-)


Natasha

Re: What exactly is the licensing situation with GNAT?

[G.B.]

On 17.11.14 12:03, Dmitry A. Kazakov wrote:
>> Using qualified people end to end. Then the problem goes away.
> There are no people qualified to redesign everything needed by an average
> SW project.

The definition of qualified people is when the problem
has apparently gone away? Vicious circle, there.

Re: Things that OO programming lacks

[Simon Wright]

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

> Let you have two signals X, Y and want to produce Z=X+Y.  This is a
> trivial task in procedural, functional OO decomposition (not in
> relational one). With events, when X and Y are sampled
> (asynchronously), digitized (stochastically) and propagated through
> the system layers ([bounded] random delays), this does not work. You
> immediately run into a race condition.

I gree with you on this one. We never really ended up with a
satisfactory pattern. _Something_ has to remember the states so that
when one of them changes it can go and check the other one to decide
whether they're both set.

Very untidy-feeling to have two intermediate states, 'A set, waiting for
B' and 'B set, waiting for A', but possibly worth it to minimise the
amount of logic in code rather than having it visible in the state
machine.

> So even tasks considered trivial in other paradigms are hard problems
> in the event-driven one.

And the reverse? Nothing is the perfect approach for all problems.

Re: Things that OO programming lacks

[G.B.]

On 16.11.14 11:18, Dmitry A. Kazakov wrote:

>> I mean our objects, not OO objects. This is about expressing notions.
>
> There is no "our objects" in non-object-oriented paradigms.

[...](*)

To establish a paradigm of something that does not exist yet
seems premature.

What does exist, though, is a problem of expressive incompleteness.


Here is the situation:
there always are questions about what the heck happened
as a consequence of the execution of a program, e.g. failure.
The questions are formulated in a language used by companies,
by heads of departments, by customers, by lawyers etc. These
need to be answered, and the answer will, at some stage,
involve the programmer. A good PL will provide for answers
with the help of dedicated source text. That's the idea.
If you find that a truism, I wonder why nothing changes,
but in any case, it won't stop scrutinizing the facts.
(The idea is thus not to start with some paradigm at
the level of finished formalism.)

For example, an FSM situation (cf. Niklas' post) that could
be bridled by narrowing the error space with the help of
new language seems clearly better than trying to find the
cause by divide and conquer.


>> If Obj_1 and Obj_2 are objects, then I would like the language
>> to have syntax, say "(*)", for
>>
>>      Obj_1 (*) Obj_2
>>
>> which would *not* be a function call.
>
> Then these are not objects. The only thing you can do with objects is to
> use the operations of. This is called typing.

Let's say you can't think of any interpretation of

   Obj_1 (*) Obj_2

other than in terms of operations of the types of Obj_N.
Is this reason enough to say that other interpretations
are impossible? In particular, they could reflect the
intention of introducing (*).

(ow would any paradigm have been created if its creators would
have had to start from the paradigm?

__
(*) Objects are inevitably part of thinking when programming,
even before all OO-related notional strictures applied to
the word. Engineers would never arrive at anything new if they
just re-iterated learned procedures.

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Mon, 17 Nov 2014 16:17:59 +0100, G.B. wrote:

> Here is the situation:
> there always are questions about what the heck happened
> as a consequence of the execution of a program, e.g. failure.
> The questions are formulated in a language used by companies,
> by heads of departments, by customers, by lawyers etc. These
> need to be answered, and the answer will, at some stage,
> involve the programmer. A good PL will provide for answers
> with the help of dedicated source text. That's the idea.
> If you find that a truism, I wonder why nothing changes,
> but in any case, it won't stop scrutinizing the facts.

Because nothing can happen. No language can describe the program's meaning.
It is always up to the programmer to map program entities to the outer
world's meanings.

> For example, an FSM situation (cf. Niklas' post) that could
> be bridled by narrowing the error space with the help of
> new language seems clearly better than trying to find the
> cause by divide and conquer.

Why is it clear? I don't see it clear. FSM are proven to be extremely
complex to use, error-prone and unmaintainable. That is because states are
as uncomposable as events are. If you add new or remove old states you are
in deep trouble.

>>> If Obj_1 and Obj_2 are objects, then I would like the language
>>> to have syntax, say "(*)", for
>>>
>>>      Obj_1 (*) Obj_2
>>>
>>> which would *not* be a function call.
>>
>> Then these are not objects. The only thing you can do with objects is to
>> use the operations of. This is called typing.
> 
> Let's say you can't think of any interpretation of
> 
>    Obj_1 (*) Obj_2
> 
> other than in terms of operations of the types of Obj_N.

No, I cannot. For anybody the notation x*y means take x, take y, apply *,
get the result. This is the basic language structure of nouns bound by
verbs.

> Is this reason enough to say that other interpretations
> are impossible?

Like what?

> In particular, they could reflect the intention of introducing (*).

Why anybody liked to introduce (*)?

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

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Mon, 17 Nov 2014 14:29:29 +0000, Simon Wright wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
> 
>> So even tasks considered trivial in other paradigms are hard problems
>> in the event-driven one.
> 
> And the reverse? Nothing is the perfect approach for all problems.

True. Some tasks are elegantly solved when represented as events. That does
not matter because the power of a paradigm lies in decomposition: can I
decompose my huge, ill-specified, ever changing problem into those tasks? 

IMO, only OO and procedural paradigms actually can.

Even when several paradigms are used in the same system (e.g. a relational
DB, or code generated from some model) the glue between components is
always procedural or OO.

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

Re: Things that OO programming lacks

[G.B.]

On 17.11.14 18:28, Dmitry A. Kazakov wrote:

>  No language can describe the program's meaning.

Interestingly, we have a manual that does just that,
WRT some frame of reference, and WRT to a meaning
of "meaning", and even using occasional hints at the
world ("environment", "file", ...).

Also, English can help predicting or explaining what an Ada program
means. Programmers and authors doing this will refer to the source
text, I think? It seems fair, too, to say that "Volatile" conveys
a good idea of what will happen to a storage cell. This
means something.

> It is always up to the programmer to map program entities to the outer
> world's meanings.

<academic?>A change of program text, back and fro, is effective
in creating an outer world that is measurably different each
time, accordingly. So, yes, the programmer needs to be able
to match source entities to effects in the outer world,
and describe the relationship.</academic?>

>> For example, an FSM situation (cf. Niklas' post) that could
>> be bridled by narrowing the error space with the help of
>> new language seems clearly better than trying to find the
>> cause by divide and conquer.
>
> Why is it clear? I don't see it clear. FSM are proven to be extremely
> complex to use, error-prone and unmaintainable. That is because states are
> as uncomposable as events are. If you add new or remove old states you are
> in deep trouble.

Assuming there is a way to pick important states,
e.g. measured by the fraction of customers affected.
Assuming further that they are textually connected
alongside the FSM definition.
Then, if this additional information helps isolate effects
affecting more customers, e.g. via hooks, the rest can go into
the "others" clauses, or be otherwise listed as not important.
That is, importance of states is not part of the definition of
the FSM, but it results from the definition of the situation
that warrants payed programming in the first place and therefore
should have an influence on the program text.


>> Let's say you can't think of any interpretation of
>>
>>     Obj_1 (*) Obj_2
>>
>> other than in terms of operations of the types of Obj_N.
>
> No, I cannot. For anybody the notation x*y means take x, take y, apply *,
> get the result.

Say, "(*)" stands for →. I don't think that many Ada programmers
will then have an idea of how to "apply →" to those objects,
or indeed, how to interpret "x→y". The arrow needs introduction,
and we are free to make it stand for what we need it to stand for.

Example:

"Obj_1 exists while Obj_2 exists".

If Obj_1 and Obj_2 are not, and cannot be in the same dynamic scope
because of conflicting requirements, then this states their
relationship explicitly. Yes, one could program some emulation
of a co-existence check, such as a registry of objects. But this
only works around the problem (of not having expressive language).

(I'm expecting at least one occurrence of "Bad design!" now,
but I'm curious about how an existing paradigm, or indeed
a pattern, will resolve those conflicting requirements WRT scopes. ;-)

>> In particular, they could reflect the intention of introducing (*).
>
> Why anybody liked to introduce (*)?

The "(*)" can mean a way to formally describe relationships of entities
named in the program and considered important, if by comparison
the relationships are only implicit in the current programming
language.

Re: Things that OO programming lacks

[Shark8]

On 17-Nov-14 10:28, Dmitry A. Kazakov wrote:
> FSM are proven to be extremely
> complex to use, error-prone and unmaintainable. That is because states are
> as uncomposable as events are. If you add new or remove old states you are
> in deep trouble.

Not really; in Ada we'd just say:

Type Event is ( 'a', 'b', 'c', 'd' );
Type State is ( Start, middle_1, middle_2, Stop );

Type Transition_Table is array (Event, State) of State;

Type FSM(<>) is private;
Function  Create( Transitions : Transition_Table ) return FSM;
Procedure Do_Event( State_Machine : in out FSM; Action : Event );

private
   Type FSM(Transitions : not null access Transition_Table) is record
     Current : State:= Start;
   end record;

-- in the Body ...

Function Create( Transitions : Transition_Table ) return FSM is
( Transitions => New Transition_Table'(Transitions), others => <> );

Procedure Do_Event( State_Machine : in out FSM; Action : Event ) is
begin
   case Action is
    when others => null; -- Attach particular/special actions here.
                         -- Also allow Ada to do case-coverage where
                         -- possible.
   end case;

   State_Machine.Current:=
      State_Machine.Transitions(Action, State_Machine.Current);
end Do_Event;

Re: Things that OO programming lacks

[Georg Bauhaus]

On 17.11.14 19:23, G.B. wrote:
> If Obj_1 and Obj_2 are not, and cannot be in the same dynamic scope

This should have been:

If Obj_1 and Obj_2 are not, and cannot be declared in the same place /
depend on the same master ...

Although existence in two different tasks might be interesting.
Sorry.

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Mon, 17 Nov 2014 12:21:42 -0700, Shark8 wrote:

> On 17-Nov-14 10:28, Dmitry A. Kazakov wrote:
>> FSM are proven to be extremely
>> complex to use, error-prone and unmaintainable. That is because states are
>> as uncomposable as events are. If you add new or remove old states you are
>> in deep trouble.
> 
> Not really; in Ada we'd just say:
> 
> Type Event is ( 'a', 'b', 'c', 'd' );
> Type State is ( Start, middle_1, middle_2, Stop );
> 
> Type Transition_Table is array (Event, State) of State;
> 
> Type FSM(<>) is private;
> Function  Create( Transitions : Transition_Table ) return FSM;
> Procedure Do_Event( State_Machine : in out FSM; Action : Event );
> 
> private
>    Type FSM(Transitions : not null access Transition_Table) is record
>      Current : State:= Start;
>    end record;
> 
> -- in the Body ...
> 
> Function Create( Transitions : Transition_Table ) return FSM is
> ( Transitions => New Transition_Table'(Transitions), others => <> );
> 
> Procedure Do_Event( State_Machine : in out FSM; Action : Event ) is
> begin
>    case Action is
>     when others => null; -- Attach particular/special actions here.
>                          -- Also allow Ada to do case-coverage where
>                          -- possible.
>    end case;
> 
>    State_Machine.Current:=
>       State_Machine.Transitions(Action, State_Machine.Current);
> end Do_Event;

In Ada you can implement Post-Turing machine in few lines. Should we run to
redesign everything in the tape language?

However my personal favorite would be Brainfuck, it should be 100-200 lines
in Ada. Have fun!

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

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Mon, 17 Nov 2014 19:23:10 +0100, G.B. wrote:

> On 17.11.14 18:28, Dmitry A. Kazakov wrote:
> 
>>  No language can describe the program's meaning.
> 
> Interestingly, we have a manual that does just that,
> WRT some frame of reference, and WRT to a meaning
> of "meaning", and even using occasional hints at the
> world ("environment", "file", ...).

Nope. RM describes language semantics in terms of computational
environment. This has nothing to do with the program meaning. Meaning /=
behavior.

> Also, English can help predicting or explaining what an Ada program
> means. Programmers and authors doing this will refer to the source
> text, I think? It seems fair, too, to say that "Volatile" conveys
> a good idea of what will happen to a storage cell. This
> means something.

It means exactly nothing in the problem space [without the program
designer].

>>> For example, an FSM situation (cf. Niklas' post) that could
>>> be bridled by narrowing the error space with the help of
>>> new language seems clearly better than trying to find the
>>> cause by divide and conquer.
>>
>> Why is it clear? I don't see it clear. FSM are proven to be extremely
>> complex to use, error-prone and unmaintainable. That is because states are
>> as uncomposable as events are. If you add new or remove old states you are
>> in deep trouble.
> 
> Assuming there is a way to pick important states,
> e.g. measured by the fraction of customers affected.
> Assuming further that they are textually connected
> alongside the FSM definition.
> Then, if this additional information helps isolate effects
> affecting more customers, e.g. via hooks, the rest can go into
> the "others" clauses, or be otherwise listed as not important.
> That is, importance of states is not part of the definition of
> the FSM, but it results from the definition of the situation
> that warrants payed programming in the first place and therefore
> should have an influence on the program text.

Assuming there is a way to pick important sequences of memory bits starting
at the address 0, measured by affected customers. [I love to see how memory
dumps would affect our customers!] They are certainly connected to the
machine hexadecimal code. Then continue the absurdity you wrote above
further...

>>> Let's say you can't think of any interpretation of
>>>
>>>     Obj_1 (*) Obj_2
>>>
>>> other than in terms of operations of the types of Obj_N.
>>
>> No, I cannot. For anybody the notation x*y means take x, take y, apply *,
>> get the result.
> 
> Say, "(*)" stands for →. I don't think that many Ada programmers
> will then have an idea of how to "apply →" to those objects,
> or indeed, how to interpret "x→y". The arrow needs introduction,
> and we are free to make it stand for what we need it to stand for.
> 
> Example:
> 
> "Obj_1 exists while Obj_2 exists".

In Ada *every* object exists when named! Try to write an Ada program where
you could name a non-existing object.

> (I'm expecting at least one occurrence of "Bad design!" now,
> but I'm curious about how an existing paradigm, or indeed
> a pattern, will resolve those conflicting requirements WRT scopes. ;-)

It is no design.

[In 60's relationships between names and objects was hotly debated. I
vaguely remember some lengthy and quite stupid passages on this subject in
ancient books I read thirty or so years ago. Already then in late 80's it
was nothing but eyebrows raising.]

>>> In particular, they could reflect the intention of introducing (*).
>>
>> Why anybody liked to introduce (*)?
> 
> The "(*)" can mean a way to formally describe relationships of entities
> named in the program and considered important, if by comparison
> the relationships are only implicit in the current programming
> language.

Relationship between *objects*, if computable, is a Boolean-valued
*operation*:

   xRy -> Boolean

If not computable or not objects, what are you talking about?

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

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:1se4bvo6gaqft.16cfjaiketlz0$.dlg@40tude.net...
> On Fri, 14 Nov 2014 16:29:59 -0600, Randy Brukardt wrote:
>
>> I've been using Claw.Sockets for so long that I don't know what the
>> underlying implementation is. So I don't know what "select" is used for 
>> or
>> whether it's implemented in NC_Sockets. Claw.Sockets has a server type
>> that's used for implemented servers (like web and mail servers).
>
> Select() is essential for heavy duty and light weight servers as it allows
> one task to handle multiple sockets without blocking. AdaSockets, the only
> alternative to GNAT.Sockets I know, does not support select.
>
> (I don't know if AWS uses blocking sockets for its server or 
> socket-select)

Incoming or outgoing? Since Janus/Ada only uses one thread per Ada program, 
no server would work at all if everything was blocking. I know the server 
type works well distributing accesses to different Ada tasks (even on 
Janus/Ada, where everything is done by one thread).

OTOH, we implemented non-blocking sockets for outbound traffic in Claw 
sockets as well. I implemented a version of the web server using those 
sockets, and it turned out the performance (at least on Windows 2K/XP) was 
something like 10 times slower using non-blocking sockets compared to 
busy-waiting the blocking sockets. Apparently, Windows launches threads for 
the non-blocking socket operations, which is SLOW. I made the busy-waiting 
much smarter in the web server (using a increasing wait for each iteration) 
and got much better overall performance than either alternative.

                                                   Randy.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:dilqwcbqc502$.l6p0xx7myoiu.dlg@40tude.net...
> On Fri, 14 Nov 2014 16:24:14 -0600, Randy Brukardt wrote:
>
>> OTOH, I don't see why this would be any different than access types
>> vis-a-vis interfacing with C and the like. The type would have a
>> representation (likely one similar to access-to-subprogram), and that's 
>> the
>> problem for 'Unrestricted_Access - it needs a different representation to
>> support 'Unrestricted_Access from 'Access. And the representation needed 
>> for
>> 'Unrestricted_Access is incompatible with C (other than on GCC, which is
>> unusual). If you simply allowed any subprogram to match a subprogram 
>> type,
>> you couldn't allow interface to C. Or you'd have to have an accessibility
>> check on the use only for interface to C. Or some other messy rule - 
>> would
>> not gain anything.
>
> Except that whatever checks needed they will not include pointer checks. 
> If
> a nested subprogram cannot be passed to C, then it cannot. But the reason
> shall not be accessibility pointer check. The only reason allowed is
> "cannot implement pragma Convention".

Huh? The problem is that (some) nested subprograms cannot be passed to C. 
And allowing them to be passed in Ada is unconsonably expensive (at the very 
least, you'll need a mechanism to say that you don't want to pay for that 
overhead). What does pragma convention have to do with it?

                                      Randy.

Re: 'Image (was: What exactly is the licensing situation with GNAT?)

[Randy Brukardt]

"Georg Bauhaus" <bauhaus@futureapps.invalid> wrote in message 
news:m48b93$ke0$1@dont-email.me...
> On 15.11.14 18:32, Florian Weimer wrote:
...
> Will 'Image be user definable?

No, not in the Corrigendum (at least). We spent some time looking at ideas 
for that, but nothing practical has appeared. (We would want any 
user-definable 'Image to work like streams, so that there would be automatic 
composition for composite types.)

                                         Randy.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Randy Brukardt]

"Luke A. Guest" <laguest@archeia.com> wrote in message 
news:464563264437706207.500344laguest-archeia.com@nntp.aioe.org...
> Shark8 <OneWingedShark@gmail.com> wrote:
>> On 14-Nov-14 14:07, Luke A. Guest wrote:
>>> Jesus! That would be hell. A compiler without dynamic memory? Really? No
>>> thanks.
>>
>> Ah, right; I'd forgotten about that restriction -- I was thinking more
>> along the lines of the prover-/verifier-tools -- though aren't there
>> large chunks where you don't need dynamic memory?
>
> Not really no. An entire compiler pretty much uses the heap exclusively,
> you'd be hard pressed to build a compiler using ore allocated memory or
> just static amounts in general.

That's not really true with Janus/Ada, as many things (types, compilation 
units, subprograms) are stored in static tables. That's a left-over from the 
early MS-DOS days, where those tables could be paged to disk or stored in 
"extended" memory rather than taking up limited main memory space. I've been 
slowly removing the paging code (it's just a complication that introduces 
bugs), but the static tables remain for the most part. (Some have become 
expandable by allocating them en-mass from the heap.)

There's still some major heap use for managing expression trees and the 
symbol table, but there's a lot that doesn't use it.

                                                 Randy.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Luke A. Guest]

"Randy Brukardt" <randy@rrsoftware.com> wrote:

> That's not really true with Janus/Ada, as many things (types, compilation 
> units, subprograms) are stored in static tables. That's a left-over from the 
> early MS-DOS days, where those tables could be paged to disk or stored in 
> "extended" memory rather than taking up limited main memory space. I've been 
> slowly removing the paging code (it's just a complication that introduces 
> bugs), but the static tables remain for the most part. (Some have become 
> expandable by allocating them en-mass from the heap.)
> 
> There's still some major heap use for managing expression trees and the 
> symbol table, but there's a lot that doesn't use it.

Given the various input sizes of source you cannot statically define the
runtime data.

Re: 'Image

[Björn Lundin]

On 2014-11-18 01:39, Randy Brukardt wrote:
> "Georg Bauhaus" <bauhaus@futureapps.invalid> wrote in message 
> news:m48b93$ke0$1@dont-email.me...
>> On 15.11.14 18:32, Florian Weimer wrote:
> ...
>> Will 'Image be user definable?
> 
> No, not in the Corrigendum (at least).

Is it conceptually the same as T'Image(varible) where T is a scalar type
? That is, it will not apply to records ?

--
Björn

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Mon, 17 Nov 2014 18:37:28 -0600, Randy Brukardt wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
> news:dilqwcbqc502$.l6p0xx7myoiu.dlg@40tude.net...
>> On Fri, 14 Nov 2014 16:24:14 -0600, Randy Brukardt wrote:
>>
>>> OTOH, I don't see why this would be any different than access types
>>> vis-a-vis interfacing with C and the like. The type would have a
>>> representation (likely one similar to access-to-subprogram), and that's 
>>> the
>>> problem for 'Unrestricted_Access - it needs a different representation to
>>> support 'Unrestricted_Access from 'Access. And the representation needed 
>>> for
>>> 'Unrestricted_Access is incompatible with C (other than on GCC, which is
>>> unusual). If you simply allowed any subprogram to match a subprogram 
>>> type,
>>> you couldn't allow interface to C. Or you'd have to have an accessibility
>>> check on the use only for interface to C. Or some other messy rule - 
>>> would
>>> not gain anything.
>>
>> Except that whatever checks needed they will not include pointer checks. If
>> a nested subprogram cannot be passed to C, then it cannot. But the reason
>> shall not be accessibility pointer check. The only reason allowed is
>> "cannot implement pragma Convention".
> 
> Huh? The problem is that (some) nested subprograms cannot be passed to C. 
> And allowing them to be passed in Ada is unconsonably expensive (at the very 
> least, you'll need a mechanism to say that you don't want to pay for that 
> overhead). What does pragma convention have to do with it?

If you want to reject a subprogram being passed to C then that should be
because of pragma Convention.

Passing a subprogram to Ada should be always possible. If you wanted, for
whatever reason, disable certain cases that would be still possible to do
using type or subtype errors.

My argument is that the cases where you might want to prohibit are not
exactly the cases where accessibility checks fail, they are much fewer or
non-existent.

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

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Mon, 17 Nov 2014 18:28:42 -0600, Randy Brukardt wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
> news:1se4bvo6gaqft.16cfjaiketlz0$.dlg@40tude.net...
>> On Fri, 14 Nov 2014 16:29:59 -0600, Randy Brukardt wrote:
>>
>>> I've been using Claw.Sockets for so long that I don't know what the
>>> underlying implementation is. So I don't know what "select" is used for 
>>> or
>>> whether it's implemented in NC_Sockets. Claw.Sockets has a server type
>>> that's used for implemented servers (like web and mail servers).
>>
>> Select() is essential for heavy duty and light weight servers as it allows
>> one task to handle multiple sockets without blocking. AdaSockets, the only
>> alternative to GNAT.Sockets I know, does not support select.
>>
>> (I don't know if AWS uses blocking sockets for its server or 
>> socket-select)
> 
> Incoming or outgoing?

Both and connect, disconnect as well.

> Since Janus/Ada only uses one thread per Ada program, 
> no server would work at all if everything was blocking. I know the server 
> type works well distributing accesses to different Ada tasks (even on 
> Janus/Ada, where everything is done by one thread).
> 
> OTOH, we implemented non-blocking sockets for outbound traffic in Claw 
> sockets as well. I implemented a version of the web server using those 
> sockets, and it turned out the performance (at least on Windows 2K/XP) was 
> something like 10 times slower using non-blocking sockets compared to 
> busy-waiting the blocking sockets.

Depends on how you measured it. Latencies may increase for obvious reason
of context switching. The rest should have no influence.

> Apparently, Windows launches threads for 
> the non-blocking socket operations, which is SLOW.

No, that cannot be. We are using non-blocking sockets massively e.g. tens
of thousands, needed to fiddle system settings to allow so many. It
certainly does not start threads because Windows cannot have so many.

> I made the busy-waiting 
> much smarter in the web server (using a increasing wait for each iteration) 
> and got much better overall performance than either alternative.

Did you use this:

http://msdn.microsoft.com/en-us/library/windows/desktop/ms741576%28v=vs.85%29.aspx

This a simpler alternative with more control over the policies as compared
to the traditional select:

http://msdn.microsoft.com/en-us/library/windows/desktop/ms740141%28v=vs.85%29.aspx

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

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Georg Bauhaus]

On 18.11.14 04:06, Luke A. Guest wrote:
> Given the various input sizes of source you cannot statically define the
> runtime data.

Computer memory is statically sized, so in a sense a compiler
can never adapt to all input sizes, if that's good enough for
an excuse.  SNOBOL-4 (its incarnation CSNOBOL4) uses a switch
for increasing "dynamic storage" for program code and data.

Generalizing the reverse, a statically sized storage can prevent the
compiler from using memory swapped to disk, and then terminate
after a very slow run.  Which is a feature of gcc when it creates
larger data objects that it finds declared in the source text.

Re: Things that OO programming lacks

[Georg Bauhaus]

On 17.11.14 22:05, Dmitry A. Kazakov wrote:

> It means exactly nothing in the problem space [without the program
> designer].

It [the source text] means a lot with the program designer present,
also to a reader. Which is the text's important use in the programming
situations described, which is also the reason source text should be
expressive.

>> Example:
>>
>> "Obj_1 exists while Obj_2 exists".
>
> In Ada *every* object exists when named! Try to write an Ada program where
> you could name a non-existing object.

Sure. And even unnamed objects can be known to likely co-exist. The statement

   X := S'(...) + T'(...);

has two (Ada-wise) unnamed objects. But just names, somewhere in a program,
plus things like calls using the names are not expressive enough for some
quick answers that programmers need to give by referring to the source text.
Which was the point. Sometimes there are no dedicated designators for things
like these properties of the program. (As there are, approximately,
for learning about the order in time of some intended effects from textual
order of accept statements.)

> Relationship between *objects*, if computable, is a Boolean-valued
> *operation*:
>
>     xRy -> Boolean

Certainly every computation is Boolean valued operations if you reduce it
to logic. But since for the reasons you named (when mentioning Post-Turing)
we shy way from Boolean valued operations for everything, why not invent
something that expresses what programmers need to known in order to make
those answers?

In particular, I am free to work with the assumption that a relationship
is not just a binary relation, since the latter is determined, invisibly,
by just the objects. Somehow. Can every relationship be expressed *well*
by only producing enough dummy objects to help determine the relationship
of other objects? Is this expressive, or does it add unnecessary complexity
to program design, and to program analysis?

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Tue, 18 Nov 2014 11:14:20 +0100, Georg Bauhaus wrote:

> On 17.11.14 22:05, Dmitry A. Kazakov wrote:
> 
>> It means exactly nothing in the problem space [without the program
>> designer].
> 
> It [the source text] means a lot with the program designer present,
> also to a reader. Which is the text's important use in the programming
> situations described, which is also the reason source text should be
> expressive.

Still as a *program* it means nothing, but bit shuffling. Any other meaning
is in the programmer and customer heads.

>>> Example:
>>>
>>> "Obj_1 exists while Obj_2 exists".
>>
>> In Ada *every* object exists when named! Try to write an Ada program where
>> you could name a non-existing object.
> 
> Sure. And even unnamed objects can be known to likely co-exist. The statement
> 
>    X := S'(...) + T'(...);
> 
> has two (Ada-wise) unnamed objects. But just names, somewhere in a program,
> plus things like calls using the names are not expressive enough for some
> quick answers that programmers need to give by referring to the source text.

Name them better.

> Which was the point. Sometimes there are no dedicated designators for things
> like these properties of the program.

Which is mere bad design. Important things must have corresponding language
entities. E.g. objects, types, operations, modules etc. You must talk about
them, in the language.

Your point was that object, types, operations, modules might be not enough
to maintain this mapping. Which would constitute a new paradigm. Yet, you
failed to present anything beyond objects, types, operations, modules.

> (As there are, approximately,
> for learning about the order in time of some intended effects from textual
> order of accept statements.)

That is not a language term, so far. And unlikely it would.

In order to spell constraints there are correctness provers. Such
constraints (like preconditions, post-conditions, invariants) are expressed
in a meta-language of the prover, e.g. in SPARK. This is not a new
paradigm. You could use a prover in most of paradigms with different
chances of success. The best it works with OO, because OO adds a lot of
things at which you could hang your constraints on.

And, importantly, you cannot fuse prover with the compiler. It is
inherently inconsistent. Both language must be kept apart.
 
>> Relationship between *objects*, if computable, is a Boolean-valued
>> *operation*:
>>
>>     xRy -> Boolean
> 
> Certainly every computation is Boolean valued operations if you reduce it
> to logic.

Relation is a logical term.

> But since for the reasons you named (when mentioning Post-Turing)
> we shy way from Boolean valued operations for everything, why not invent
> something that expresses what programmers need to known in order to make
> those answers?

To which questions? A relation between object is a part of the program
behavior expressed in the form of an operation. All answers the programmer
wants is in the implementation of the operation. E.g.

   function ">" (Left, Right : List_Element) return Boolean;

Ada already has everything needed to have this.

> In particular, I am free to work with the assumption that a relationship
> is not just a binary relation, since the latter is determined, invisibly,
> by just the objects. Somehow. Can every relationship be expressed *well*
> by only producing enough dummy objects to help determine the relationship
> of other objects? Is this expressive, or does it add unnecessary complexity
> to program design, and to program analysis?

I suppose you are confusing relationships between objects with
relationships between types and correctness statements.

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

Re: Things that OO programming lacks

[G.B.]

On 18.11.14 14:42, Dmitry A. Kazakov wrote:
> ... meaning is in the programmer and customer heads.

Right, and meaning follows communication using languages like
English and also programming formalisms.

> Name them better.

It's not just names, but also anything important in the programming
situation. Co-existence of objects, in Ada and other languages,
is not expressible well insofar as they have no dedicated language
entities for co-existence in general.

> Important things must have corresponding language
> entities. E.g. objects, types, operations, modules etc. You must talk about
> them, in the language.

Precisely my point.

> Your point was that object, types, operations, modules might be not enough
> to maintain this mapping. Which would constitute a new paradigm. Yet, you
> failed to present anything beyond objects, types, operations, modules.

That was your judgment, while my perspective is above a
formalism that confines your meaning, I think. And here you say it:

> That is not a language term, so far. And unlikely it would.

But OO is still lacking such terms, right? One way to find
something is by extensional definition, starting at the level of
a suitable metalanguage, and experimenting. Starting from a new
paradigm would be quite a feat.

>> Certainly every computation is Boolean valued operations if you reduce it
>> to logic.
>
> Relation is a logical term.

Which is why I preferred relationship, which is more open
to new interpretation.

>> But since for the reasons you named (when mentioning Post-Turing)
>> we shy way from Boolean valued operations for everything, why not invent
>> something that expresses what programmers need to known in order to make
>> those answers?
>
> To which questions?

To those listed so far. Variations of things, tiny or not:

"Why did the effect of Obj_1's doings occur before those of Obj_2's?
  Are they not ordered here?
  Does Obj_4 respond to Event_B if user/input has arranged for Obj_2
  to become alive?"

(Some say, I think, that event aware object oriented systems
are (worth) a new paradigm waiting to be formalized for the
very reason that those FSMs and global variables are nasty,
be they dressed as OO or not.)

> I suppose you are confusing relationships between objects with
> relationships between types and correctness statements.

I don't think that time is involved in a relationship between
types in general, or can I express that relationship in Ada OO types?

There are cases where in Ada I can approximate order of types
in time, so to speak, thanks to nesting:

   procedure Stage_0 is
      type T is ...;
   begin ...
   end Stage_0;

   procedure Stage_1 is
      type T is ...;
   begin ...
   end Stage_1;
begin
   Stage_0;
   Stage_1;

Due to the order of calls, it is now fairly certain that objects
of type Stage_0.T all exist and "cease to exist" before any object
of type Stage_1.T starts to exist.
Is this conclusion(!) perfection of expressiveness already?
I don't think so.


I suppose I'm thinking merely in term of objects, not just OO-ish,
but just objects that have identity, and any property, shared or
emerging, that is derived from the formal properties of the objects,
the program, as well as from the interpretation of (non-OO-)objects
discussed by the people involved. So that the model developed
during discussion can adequately be turned into program text, where
adequacy requires modes of expression that aren't in the language yet.

Re: Things that OO programming lacks

[Dmitry A. Kazakov]

On Tue, 18 Nov 2014 19:50:23 +0100, G.B. wrote:

> On 18.11.14 14:42, Dmitry A. Kazakov wrote:
>> That is not a language term, so far. And unlikely it would.
> 
> But OO is still lacking such terms, right?

No. You didn't presented any. If you did, you should also show why it would
be impossible or difficult to express the thing as an object, operation
etc.

>> Relation is a logical term.
> 
> Which is why I preferred relationship, which is more open
> to new interpretation.

I don't see which relationships between specifically objects were useful
while incomputable. Some relationships are non-terms on purpose, some are
computable but undesirable (e.g. Unchecked_Conversion stuff). So you should
also show usefulness and preservation of abstraction.

>>> But since for the reasons you named (when mentioning Post-Turing)
>>> we shy way from Boolean valued operations for everything, why not invent
>>> something that expresses what programmers need to known in order to make
>>> those answers?
>>
>> To which questions?
> 
> To those listed so far. Variations of things, tiny or not:
> 
> "Why did the effect of Obj_1's doings occur before those of Obj_2's?

What is effect of an object? It is breaking abstraction at least. All
effect of an object is in its state. That is the fundamental principle of
OO decomposition.

> (Some say, I think, that event aware object oriented systems
> are (worth) a new paradigm waiting to be formalized for the
> very reason that those FSMs and global variables are nasty,
> be they dressed as OO or not.)

Why event is not a primitive operation or not an object?

>> I suppose you are confusing relationships between objects with
>> relationships between types and correctness statements.
> 
> I don't think that time is involved in a relationship between
> types in general, or can I express that relationship in Ada OO types?

Why should you? Time aspects are almost never functional and thus do not
belong to types.

> There are cases where in Ada I can approximate order of types
> in time, so to speak, thanks to nesting:
> 
>    procedure Stage_0 is
>       type T is ...;
>    begin ...
>    end Stage_0;
> 
>    procedure Stage_1 is
>       type T is ...;
>    begin ...
>    end Stage_1;
> begin
>    Stage_0;
>    Stage_1;
> 
> Due to the order of calls, it is now fairly certain that objects
> of type Stage_0.T all exist and "cease to exist" before any object
> of type Stage_1.T starts to exist.
> Is this conclusion(!) perfection of expressiveness already?

I see. You are confusing correctness with the language. In procedural and
OO decomposition when anybody chooses to factor out two procedures like
Stage_0 and Stage_1 these are designed independent. This is again a
fundamental design principle of minimal coupling.

If the client of these entities, carefully observe, this is a third party,
needs to call them in a certain order, that must follow from the
pre-conditions and post-conditions of these procedures. This is what makes

   Stage_1
   Stage_0

incorrect and

   Stage_0
   Stage_1

correct. Under other circumstances the conditions might evaluate
differently making other orders correct. If you don't like this you should
use different decomposition, not procedural or OO. Which is the point. The
paradigm goes first.

> I suppose I'm thinking merely in term of objects, not just OO-ish,
> but just objects that have identity, and any property, shared or
> emerging, that is derived from the formal properties of the objects,
> the program, as well as from the interpretation of (non-OO-)objects
> discussed by the people involved.

No idea what this means.

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

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:13efsbp4ynti1.1qsb6buqa4a60.dlg@40tude.net...
> On Mon, 17 Nov 2014 18:28:42 -0600, Randy Brukardt wrote:
...
>> Since Janus/Ada only uses one thread per Ada program,
>> no server would work at all if everything was blocking. I know the server
>> type works well distributing accesses to different Ada tasks (even on
>> Janus/Ada, where everything is done by one thread).
>>
>> OTOH, we implemented non-blocking sockets for outbound traffic in Claw
>> sockets as well. I implemented a version of the web server using those
>> sockets, and it turned out the performance (at least on Windows 2K/XP) 
>> was
>> something like 10 times slower using non-blocking sockets compared to
>> busy-waiting the blocking sockets.
>
> Depends on how you measured it. Latencies may increase for obvious reason
> of context switching. The rest should have no influence.

I probably mispoke; I think I was mainly concerned about server load than 
raw performance (the public Internet, after all, is relatively slow compared 
to a computer). And it made the web server use 10 times the CPU (or 
something in that range) compared to "smart" busy-waiting using blocking 
sockets. The resulting server load made the server unusable (it would have 
taken 100-150% of the available CPU to provide decent performance).

> Apparently, Windows launches threads for
>> the non-blocking socket operations, which is SLOW.
>
> No, that cannot be. We are using non-blocking sockets massively e.g. tens
> of thousands, needed to fiddle system settings to allow so many. It
> certainly does not start threads because Windows cannot have so many.

Possibly. Or perhaps its changed in more recent Windows versions. Something 
was taking a whole lot of CPU in the OS (not in our code, based on 
profiling).

>> I made the busy-waiting
>> much smarter in the web server (using a increasing wait for each 
>> iteration)
>> and got much better overall performance than either alternative.

No, everything I did was in Ada; I didn't try to stress Winsock any more 
than I had to (it's quite fragile in W2K and crashes the computer 
regularly). "Smart" busy-waiting just means to wait amounts of time based on 
likely response times (they're not linear!). Either data becomes ready very 
soon (within an ms or so), or it probably needs to wait for additional 
packets, so a longer wait is needed. In the later case, we use delay so that 
other tasks can run (as noted, in Janus/Ada without that the program would 
effectively be blocked).

Of course, the sorts of things I did might not work as well on GNAT (which 
does use threads), there might be a lot of context switching overhead. I 
expect to be trying that sometime this winter once I get further along in 
the porting project.

                                              Randy.

Re: 'Image

[Randy Brukardt]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1226 bytes --]

"Björn Lundin" <b.f.lundin@gmail.com> wrote in message 
news:m4evds$bru$1@dont-email.me...
> On 2014-11-18 01:39, Randy Brukardt wrote:
>> "Georg Bauhaus" <bauhaus@futureapps.invalid> wrote in message
>> news:m48b93$ke0$1@dont-email.me...
>>> On 15.11.14 18:32, Florian Weimer wrote:
>> ...
>>> Will 'Image be user definable?
>>
>> No, not in the Corrigendum (at least).
>
> Is it conceptually the same as T'Image(varible) where T is a scalar type
> ? That is, it will not apply to records ?

Yes, exactly. Specifically:

 For a prefix X that denotes an object of a scalar type[ (after any implicit 
dereference)], the following attributes are defined:

X'Image  X'Image denotes the result of calling function S'Image with Arg 
being X, where S is the nominal subtype of X.

and similarly for Wide_Image and Wide_Wide_Image.

We've looked at ideas for allowing Image on record types, but it gets messy 
in a hurry, especially if user-defined Image is involved. (User-defined 
'Image only makes sense if there is some additional functionally associated 
with that, as in the stream case; otherwise, just defining a normal function 
is good enough [and fewer characters to write, too].)

                                Randy.

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Randy Brukardt]

"Luke A. Guest" <laguest@archeia.com> wrote in message 
news:790775817437972682.294390laguest-archeia.com@nntp.aioe.org...
> "Randy Brukardt" <randy@rrsoftware.com> wrote:
>
>> That's not really true with Janus/Ada, as many things (types, compilation
>> units, subprograms) are stored in static tables. That's a left-over from 
>> the
>> early MS-DOS days, where those tables could be paged to disk or stored in
>> "extended" memory rather than taking up limited main memory space. I've 
>> been
>> slowly removing the paging code (it's just a complication that introduces
>> bugs), but the static tables remain for the most part. (Some have become
>> expandable by allocating them en-mass from the heap.)
>>
>> There's still some major heap use for managing expression trees and the
>> symbol table, but there's a lot that doesn't use it.
>
> Given the various input sizes of source you cannot statically define the
> runtime data.

Of course you can. The proportions of data used is proportional to the size 
of the input source, and is fairly consistent between compilation units, so 
there isn't much waste for a maximum-sized unit. Perhaps you're objecting to 
the idea of a maximum-sized unit, but the amount of memory available to the 
compiler is limited, so there's always a practical limit. (Janus/Ada was 
designed to host of small, memory-limited machines; it was never really 
intended to be used on machines with vast amounts of memory. Which is fine, 
because I've never had a machine with vast amounts of memory. :-)

                                           Randy.

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Tue, 18 Nov 2014 16:25:03 -0600, Randy Brukardt wrote:

>> Depends on how you measured it. Latencies may increase for obvious reason
>> of context switching. The rest should have no influence.
> 
> I probably mispoke; I think I was mainly concerned about server load than 
> raw performance (the public Internet, after all, is relatively slow compared 
> to a computer). And it made the web server use 10 times the CPU (or 
> something in that range) compared to "smart" busy-waiting using blocking 
> sockets. The resulting server load made the server unusable (it would have 
> taken 100-150% of the available CPU to provide decent performance).

I see. However measuring load under Windows is a tricky part. You might
have 10% visible load and 100% real load, because the performance counters
count only fully used time quants. So, I would guess, that polling, which
does not actually switches, threads would show system load close to the
reality, while in the case of blocking it could be much lesser than actual.

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

Re: 'Image (was: What exactly is the licensing situation with GNAT?)

[Brian Drummond]

On Sat, 15 Nov 2014 20:58:39 +0100, Georg Bauhaus wrote:

> On 15.11.14 18:32, Florian Weimer wrote:
>> * Randy Brukardt:
>>
>>> Semi-related to this is that we approved Obj'Image as a
>>> language-defined attribute,

>> Did they drop leading space characters while they were at it? :-)
> 
> Of course not, they know about the possibility of a '-', and how are you
> going to write orderly column layout if in Ada there is no space!
> 
> Perfect ground for debate.
> 
> Will 'Image be user definable?  Like Python's __str__? Very good for
> obfuscation, then. Will the encoding be part of the definition,
> so that I can use it in our existing trace logs?

Something similar just came up in a VHDL context, where the question was 
asked, is '&' overloadable for non-string-or-character types. 

And it appears it is, so that you can simplify the creation of 
complicated strings (and eliminate leading spaces if you wish) by a 
package of functions overloading '&' to wrap 'Image for integer and 
similar types.

The testcase (minimally translated) seems to work in Ada too (Gnat 4.9.1 
at least), extension from single characters to 'image and strings should 
be obvious.

--------------------------------------------------------
with Ada.Text_IO;

procedure foo is
    function "&" (l: string; r: natural) return string is  
    begin
        return  l & character'VAL(r);
    end "&";
    
    a: constant string := "abcd";
    b: constant string := "efgh";
begin
    Ada.Text_IO.put_line( "concatenated string is " & a &  -- Line 18 
            character'VAL(16#42#) & b & 
            "  " &  a & 16#42# & b );
end foo;
--------------------------------------------------------

-- Brian

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Brian Drummond]

On Mon, 17 Nov 2014 11:28:42 +0000, Natasha Kerensikova wrote:

> Hello,
> 
> On 2014-11-15, Brian Drummond <brian3@shapes.demon.co.uk> wrote:
>> And there is an ASIS implementation independent of Adacore, which
>> builds quite easily.
...
>> Updating Gela-ASIS for Ada-2012 could be useful in its own right, and
>> done approximately independently of using Gela-ASIS to supply an
>> intermediate representation to an existing back-end (gcc,llvm,etc)
> 
> Just for the record, I have started doing exactly that.
> 
> You can follow my progress on the following github repository:
> https://github.com/faelys/gela-asis
> 

Perfect. I've adopted this as my Gela-Asis repo of choice.

Thanks,
- Brian

Re: 'Image

[G.B.]

On 19.11.14 14:46, Brian Drummond wrote:

> --------------------------------------------------------
> with Ada.Text_IO;
>
> procedure foo is
>      function "&" (l: string; r: natural) return string is
>      begin
>          return  l & character'VAL(r);
>      end "&";
>
>      a: constant string := "abcd";
>      b: constant string := "efgh";
> begin
>      Ada.Text_IO.put_line( "concatenated string is " & a &  -- Line 18
>              character'VAL(16#42#) & b &
>              "  " &  a & 16#42# & b );
> end foo;
> --------------------------------------------------------

This is from GNAT's Spitbol support package:

    function "&" (Num : Integer; Str : String)  return String;
    function "&" (Str : String;  Num : Integer) return String;
    function "&" (Num : Integer; Str : VString) return VString;
    function "&" (Str : VString; Num : Integer) return VString;
    --  In all these concatenation operations, the integer is converted to
    --  its corresponding decimal string form, with no leading blank.

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:1lxkqa97hflr0.1c0bm39tzl8ty$.dlg@40tude.net...
> On Tue, 18 Nov 2014 16:25:03 -0600, Randy Brukardt wrote:
>
>>> Depends on how you measured it. Latencies may increase for obvious 
>>> reason
>>> of context switching. The rest should have no influence.
>>
>> I probably mispoke; I think I was mainly concerned about server load than
>> raw performance (the public Internet, after all, is relatively slow 
>> compared
>> to a computer). And it made the web server use 10 times the CPU (or
>> something in that range) compared to "smart" busy-waiting using blocking
>> sockets. The resulting server load made the server unusable (it would 
>> have
>> taken 100-150% of the available CPU to provide decent performance).
>
> I see. However measuring load under Windows is a tricky part. You might
> have 10% visible load and 100% real load, because the performance counters
> count only fully used time quants. So, I would guess, that polling, which
> does not actually switches, threads would show system load close to the
> reality, while in the case of blocking it could be much lesser than 
> actual.

True, server load could be undercounted because of that Windows bug. But it 
can't be anywhere near 100%, since the mail filter and the various monitors 
and tools all use their share of CPU as well (the monitors and especially 
the spam reviewing tool were near unusable with the non-blocking 
implementation, they couldn't get enough CPU time).

Remember, there isn't much blocking going on with a Janus/Ada program. The 
runtime will only block if all tasks are blocked or waiting on delays (in 
the web server case, 20 worker tasks plus a couple management tasks) [and 
only if the delays are long enough that the OS will usually wake up the 
program with plenty of time to spare]. You might get some blocking from 
reading in files (web pages in this case) or from reading from a socket that 
is already ready, but the latter makes little sense and the former also 
should happen infrequently (if caching and pre-reads are working as they 
should). So I wouldn't expect a vast difference caused by truncated time 
slices in a Janus/Ada (GNAT might be very different).

                                   Randy.

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Wed, 19 Nov 2014 17:59:11 -0600, Randy Brukardt wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
> news:1lxkqa97hflr0.1c0bm39tzl8ty$.dlg@40tude.net...
>> On Tue, 18 Nov 2014 16:25:03 -0600, Randy Brukardt wrote:
>>
>>>> Depends on how you measured it. Latencies may increase for obvious 
>>>> reason
>>>> of context switching. The rest should have no influence.
>>>
>>> I probably mispoke; I think I was mainly concerned about server load than
>>> raw performance (the public Internet, after all, is relatively slow 
>>> compared
>>> to a computer). And it made the web server use 10 times the CPU (or
>>> something in that range) compared to "smart" busy-waiting using blocking
>>> sockets. The resulting server load made the server unusable (it would 
>>> have
>>> taken 100-150% of the available CPU to provide decent performance).
>>
>> I see. However measuring load under Windows is a tricky part. You might
>> have 10% visible load and 100% real load, because the performance counters
>> count only fully used time quants. So, I would guess, that polling, which
>> does not actually switches, threads would show system load close to the
>> reality, while in the case of blocking it could be much lesser than 
>> actual.
> 
> True, server load could be undercounted because of that Windows bug. But it 
> can't be anywhere near 100%, since the mail filter and the various monitors 
> and tools all use their share of CPU as well (the monitors and especially 
> the spam reviewing tool were near unusable with the non-blocking 
> implementation, they couldn't get enough CPU time).
> 
> Remember, there isn't much blocking going on with a Janus/Ada program. The 
> runtime will only block if all tasks are blocked or waiting on delays (in 
> the web server case, 20 worker tasks plus a couple management tasks) [and 
> only if the delays are long enough that the OS will usually wake up the 
> program with plenty of time to spare]. You might get some blocking from 
> reading in files (web pages in this case) or from reading from a socket that 
> is already ready, but the latter makes little sense and the former also 
> should happen infrequently (if caching and pre-reads are working as they 
> should). So I wouldn't expect a vast difference caused by truncated time 
> slices in a Janus/Ada (GNAT might be very different).

The difference appears when a worker task gets blocked before it spent its
quant. The shorter wake-up intervals are, and the more worker tasks exist,
the bigger is the error. If individual filtering action is not time
consuming (does not spread across hundreds of quants) the error might be
considerable.

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

Re: 'Image

[Brian Drummond]

On Wed, 19 Nov 2014 15:21:19 +0100, G.B. wrote:

> On 19.11.14 14:46, Brian Drummond wrote:
> 
>> --------------------------------------------------------
>> with Ada.Text_IO;
>>
>> procedure foo is
>>      function "&" (l: string; r: natural) return string is begin
>>          return  l & character'VAL(r);
>>      end "&";
...
> This is from GNAT's Spitbol support package:
> 
>     function "&" (Num : Integer; Str : String)  return String;
>     function "&" (Str : String;  Num : Integer) return String;
>     function "&" (Num : Integer; Str : VString) return VString;
>     function "&" (Str : VString; Num : Integer) return VString;
>     --  In all these concatenation operations, the integer is converted
>     to --  its corresponding decimal string form, with no leading blank.

heh, thanks!

- Brian

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:2k62zlcocx1l$.1cg687ltl85l9.dlg@40tude.net...
> On Wed, 19 Nov 2014 17:59:11 -0600, Randy Brukardt wrote:
>
>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
>> news:1lxkqa97hflr0.1c0bm39tzl8ty$.dlg@40tude.net...
>>> On Tue, 18 Nov 2014 16:25:03 -0600, Randy Brukardt wrote:
>>>
>>>>> Depends on how you measured it. Latencies may increase for obvious
>>>>> reason
>>>>> of context switching. The rest should have no influence.
>>>>
>>>> I probably mispoke; I think I was mainly concerned about server load 
>>>> than
>>>> raw performance (the public Internet, after all, is relatively slow
>>>> compared
>>>> to a computer). And it made the web server use 10 times the CPU (or
>>>> something in that range) compared to "smart" busy-waiting using 
>>>> blocking
>>>> sockets. The resulting server load made the server unusable (it would
>>>> have
>>>> taken 100-150% of the available CPU to provide decent performance).
>>>
>>> I see. However measuring load under Windows is a tricky part. You might
>>> have 10% visible load and 100% real load, because the performance 
>>> counters
>>> count only fully used time quants. So, I would guess, that polling, 
>>> which
>>> does not actually switches, threads would show system load close to the
>>> reality, while in the case of blocking it could be much lesser than
>>> actual.
>>
>> True, server load could be undercounted because of that Windows bug. But 
>> it
>> can't be anywhere near 100%, since the mail filter and the various 
>> monitors
>> and tools all use their share of CPU as well (the monitors and especially
>> the spam reviewing tool were near unusable with the non-blocking
>> implementation, they couldn't get enough CPU time).
>>
>> Remember, there isn't much blocking going on with a Janus/Ada program. 
>> The
>> runtime will only block if all tasks are blocked or waiting on delays (in
>> the web server case, 20 worker tasks plus a couple management tasks) [and
>> only if the delays are long enough that the OS will usually wake up the
>> program with plenty of time to spare]. You might get some blocking from
>> reading in files (web pages in this case) or from reading from a socket 
>> that
>> is already ready, but the latter makes little sense and the former also
>> should happen infrequently (if caching and pre-reads are working as they
>> should). So I wouldn't expect a vast difference caused by truncated time
>> slices in a Janus/Ada (GNAT might be very different).
>
> The difference appears when a worker task gets blocked before it spent its
> quant. The shorter wake-up intervals are, and the more worker tasks exist,
> the bigger is the error. If individual filtering action is not time
> consuming (does not spread across hundreds of quants) the error might be
> considerable.

But you seem to have missed my point: in Janus/Ada, task blocking is 
irrelevant. If a task blocks in an Ada sense, that just causes the task 
supervisor to select a different task to run. The OS is not involved unless 
there is *no* task ready to run. So, in general, a Janus/Ada program will 
use full quants.

Specifically for the web server, there are three possible reasons for the a 
worker task to block:
(1) No data is ready on the socket. A delay will be executed in that case, 
and some other worker task will run. Only if NO worker is ready to run will 
Sleep be called (and the quant given up). (I'm assuming that checking for 
data on a socket doesn't block the application at all, because if it did, it 
would completely defeat the purpose of the operation.)
[Note that originally, Janus/Ada *never* gave up it's slice. That's a 
relatively recent change intended to make Claw programs better citizens when 
sitting in the background doing nothing. They used to use 10% of the CPU 
even then.]
(2) The socket reports it has data to read, and it blocks for some reason in 
returning that data. This is possible, I suppose, but it makes no sense to 
me.
(3) The socket is not ready for writing. This is the same as (1).
(4) A socket write blocks when it reports that it can accept data. This 
should be rare (it would mainly occur if some buffering issue came up, and 
we write relatively small amounts of data at a time to reduce the likelyhood 
of overfilling buffers).
(5) Input of a web page blocks. Since that's file I/O, whether or not it 
blocks will depend on caching and pre-reading; clearly it will block 
sometimes.

So, the primary reason that the Janus/Ada-compiled webserver would block and 
give up part of its timeslice is from file input (5). That is going to be 
the same whether blocking or non-blocking sockets are used.

The cost difference suggests that polling is cheaper (for Janus/Ada, which 
doesn't give up its slice easily) than waiting for Windows to send a 
notification that data is ready, even though the basic mechanism is pretty 
similar. (After all, Claw polls Windows for notifications, so the effect is 
essentially the same at the low level.) I had to assume that there was some 
massive expense associated with the non-blocking sockets notifications 
inside of Windows -- profiling showed that the CPU load wasn't in the Ada 
code (not even in the interface code). I gave up at that point and switched 
back to basic polling with blocking sockets.

As I said, the situation would be very different for GNAT, where each worker 
task is a different thread. That would most likely block each worker task 
early for a polling implementation, so hardly anything would be counted. In 
which case your concern would have been justified. But I didn't run this 
test with GNAT.

                                    Randy.

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Thu, 20 Nov 2014 15:23:14 -0600, Randy Brukardt wrote:

> But you seem to have missed my point: in Janus/Ada, task blocking is 
> irrelevant. If a task blocks in an Ada sense, that just causes the task 
> supervisor to select a different task to run.

I see. But how a Janus/Ada task could use blocking sockets then?

> (4) A socket write blocks when it reports that it can accept data. This 
> should be rare (it would mainly occur if some buffering issue came up, and 
> we write relatively small amounts of data at a time to reduce the likelyhood 
> of overfilling buffers).

A non-blocking socket should accept as much data it can and then
immediately return.

> The cost difference suggests that polling is cheaper (for Janus/Ada, which 
> doesn't give up its slice easily) than waiting for Windows to send a 
> notification that data is ready, even though the basic mechanism is pretty 
> similar.

That happens only if all sockets are not ready and thus should not impose
any overhead.

> (After all, Claw polls Windows for notifications, so the effect is 
> essentially the same at the low level.) I had to assume that there was some 
> massive expense associated with the non-blocking sockets notifications 
> inside of Windows -- profiling showed that the CPU load wasn't in the Ada 
> code (not even in the interface code). I gave up at that point and switched 
> back to basic polling with blocking sockets.

If notification was done per Windows messages mechanism then certainly yes,
this is a heavy burden. However usually all notification is just pulsing an
event associated with the socket. Single pulse event is shared by all
sockets to wake up a thread that then restarts polling sockets status. I
don't know how much overhead is in signaling an event. It should not be
much.
 
> As I said, the situation would be very different for GNAT, where each worker 
> task is a different thread. That would most likely block each worker task 
> early for a polling implementation, so hardly anything would be counted. In 
> which case your concern would have been justified. But I didn't run this 
> test with GNAT.

And it would be an awful kind of server design anyway...

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

Re: What exactly is the licensing situation with GNAT?

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:1u2gy6fhz9fpr$.vzj1o4ueae0g$.dlg@40tude.net...
> On Thu, 20 Nov 2014 15:23:14 -0600, Randy Brukardt wrote:
>
>> But you seem to have missed my point: in Janus/Ada, task blocking is
>> irrelevant. If a task blocks in an Ada sense, that just causes the task
>> supervisor to select a different task to run.
>
> I see. But how a Janus/Ada task could use blocking sockets then?

A combination of two things: smart polling (don't try to read anything if 
not ready) and setting an imediate timeout for reading (so you get whatever 
is read and nothing more). Essentially, we're using blocking sockets in a 
non-blocking manner. But setting the sockets to non-blocking initially 
caused a lot of additional overhead.

>> (4) A socket write blocks when it reports that it can accept data. This
>> should be rare (it would mainly occur if some buffering issue came up, 
>> and
>> we write relatively small amounts of data at a time to reduce the 
>> likelyhood
>> of overfilling buffers).
>
> A non-blocking socket should accept as much data it can and then
> immediately return.

Maybe, but that's not how it worked when I investigated. Of course, that was 
years ago (and on W2K), so it could have changed.

...
>> (After all, Claw polls Windows for notifications, so the effect is
>> essentially the same at the low level.) I had to assume that there was 
>> some
>> massive expense associated with the non-blocking sockets notifications
>> inside of Windows -- profiling showed that the CPU load wasn't in the Ada
>> code (not even in the interface code). I gave up at that point and 
>> switched
>> back to basic polling with blocking sockets.
>
> If notification was done per Windows messages mechanism then certainly 
> yes,
> this is a heavy burden. However usually all notification is just pulsing 
> an
> event associated with the socket. Single pulse event is shared by all
> sockets to wake up a thread that then restarts polling sockets status. I
> don't know how much overhead is in signaling an event. It should not be
> much.

Event? Windows doesn't have anything like that (the only events I know about 
are messages). Windows does have some sort of Mutex (forget what they're 
called), but I've never paid any attention to them because they are useless 
within the Janus/Ada universe. That's because the whole point of a mutex is 
to block a thread until something sets the mutex, but that would block the 
entire Janus/Ada program. I suppose you could poll one, but you can poll the 
socket (or whatever) directly so there's no benefit to having a mutex.

I suppose one could use some assembler to set up a thread specifically for 
these notifications (that's what we had to do for DNS, not something I'd 
recommend for the faint-of-heart :-), but I don't see any real advantage to 
it.

>> As I said, the situation would be very different for GNAT, where each 
>> worker
>> task is a different thread. That would most likely block each worker task
>> early for a polling implementation, so hardly anything would be counted. 
>> In
>> which case your concern would have been justified. But I didn't run this
>> test with GNAT.
>
> And it would be an awful kind of server design anyway...

Well, it's the way my servers are designed, and it works great (at least for 
typical Internet protocols ike HTTP, SMTP, FTP, etc.). It probably would be 
too slow if one needed much faster latencies (1 millisecond rather than 100 
milliseconds), but I don't need that, and I see no reason to overdesign 
things.

                                               Randy.

Re: What exactly is the licensing situation with GNAT?

[Dmitry A. Kazakov]

On Fri, 21 Nov 2014 16:12:15 -0600, Randy Brukardt wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
> news:1u2gy6fhz9fpr$.vzj1o4ueae0g$.dlg@40tude.net...

>> If notification was done per Windows messages mechanism then certainly yes,
>> this is a heavy burden. However usually all notification is just pulsing an
>> event associated with the socket. Single pulse event is shared by all
>> sockets to wake up a thread that then restarts polling sockets status. I
>> don't know how much overhead is in signaling an event. It should not be
>> much.
> 
> Event? Windows doesn't have anything like that (the only events I know about 
> are messages).

Now (since NT 4.0? (:-)) but I am not sure) it does:

http://msdn.microsoft.com/en-us/library/windows/desktop/ms682396%28v=vs.85%29.aspx

> Windows does have some sort of Mutex (forget what they're 
> called), but I've never paid any attention to them because they are useless 
> within the Janus/Ada universe.

It has two of them. A full-blown mutex (can be system-wide) and a
light-weight critical section (local to the process). Full mutex is an
expensive thing. Critical section is very fast.

> That's because the whole point of a mutex is 
> to block a thread until something sets the mutex, but that would block the 
> entire Janus/Ada program. I suppose you could poll one, but you can poll the 
> socket (or whatever) directly so there's no benefit to having a mutex.

Yes

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

Re: community-based compiler (was Re: What exactly is the licensing situation with GNAT?)

[Brian Drummond]

On Mon, 17 Nov 2014 11:28:42 +0000, Natasha Kerensikova wrote:

> Hello,

>> Updating Gela-ASIS for Ada-2012 could be useful in its own right, and
>> done approximately independently of using Gela-ASIS to supply an
>> intermediate representation to an existing back-end (gcc,llvm,etc)
> 
> Just for the record, I have started doing exactly that.
> 
> You can follow my progress on the following github repository:
> https://github.com/faelys/gela-asis

Browsing the OpenHub link someone posted here today, I see
https://www.openhub.net/p/11234
which shows new commits to the original Gela project, allegedly including 
some work towards Ada-2012. 

Worth keeping an eye on.

- Brian