What is the best license to use for open source software?

What is the best license to use for open source software?

[Hubert]

Hi,
I am working on a tool program that I want to make available as open 
source. Since I am using Gnat GPL, I am not sure if I have to make my 
source GPL too or can I change the license? I don't really want to 
impose any restrictions on the user, so I dont want to force anybody to 
make their code open source because they use my code, but since it's 
based on Gnat, I don't know if that's possible.

What do others here do with their open source code? Is there a template 
license that I can just copy into my source files?

Thanks

---
This email has been checked for viruses by Avast antivirus software.
http://www.avast.com

Re: What is the best license to use for open source software?

[Jeffrey Carter]

On 01/04/2015 12:43 PM, Hubert wrote:
> Hi,
> I am working on a tool program that I want to make available as open source.
> Since I am using Gnat GPL, I am not sure if I have to make my source GPL too or
> can I change the license? I don't really want to impose any restrictions on the
> user, so I dont want to force anybody to make their code open source because
> they use my code, but since it's based on Gnat, I don't know if that's possible.

It depends on what you're releasing.

If you only release the source code, then you can give it any license you like.
It doesn't matter what compiler you use to compile it for your personal use.

If you release a binary compiled with GNAT GPL, then the binary and so the
source must be released under the GPL.

I don't know of any compiler other that GNAT GPL that imposes the GPL on
programs compiled with it, so if you release a binary compiled with another
compiler you should be able to use any license you like.

> What do others here do with their open source code? Is there a template license
> that I can just copy into my source files?

I release open-source programs under the GPL. I release source-only libraries
under the GMGPL.

-- 
Jeff Carter
"Clear? Why, a 4-yr-old child could understand this
report. Run out and find me a 4-yr-old child. I can't
make head or tail out of it."
Duck Soup
94

Re: What is the best license to use for open source software?

[David Botton]

You can put any license on your code but if compiled with shareware GNAT it will be virused into GPL (if compatible) or be in violation of the GPL, but that is only once compiled, some one else compiling your source code on an open gcc/ada compiler your license would apply as intended.

Unless writing a tool that you would want under the full GPL, I recommend BSD/MIT or GMGPL. You can copy the GMGPLv3 from the Gnoga files if you like. Or do a search for BSD or MIT license, etc.

David Botton

Re: What is the best license to use for open source software?

[Ludovic Brenta]

David Botton writes:
> You can put any license on your code but if compiled with shareware

Please use correct words; you are creating confusion.  No version of
GNAT is shareware.

> GNAT it will be virused into GPL (if compatible) or be in violation of
> the GPL, but that is only once compiled, some one else compiling your
> source code on an open gcc/ada compiler your license would apply as
> intended.
>
> Unless writing a tool that you would want under the full GPL, I
> recommend BSD/MIT or GMGPL. You can copy the GMGPLv3 from the Gnoga
> files if you like. Or do a search for BSD or MIT license, etc.

The GMGPL has been superseded by GPL version 3 with run-time library
exception.

--
Ludovic Brenta.

Re: What is the best license to use for open source software?

[David Botton]

> Please use correct words; you are creating confusion.  No version of
> GNAT is shareware.

GNAT GPL is shareware, a try before you buy product for GNAT PRO. I see no issue with calling it was it is and stopping the clear confusion that it has created that it is the "standard" gcc/ada GNAT tool chain available to the community.  Clarity doesn't come from making "believe" a GPL run-time designed to prevent commercial use is not shareware. They have the right to do it, we have the right to call it what it is. There is no shame in creating and promoting a shareware / trialware product. It ain't cool, but they have the right.

It is important that others not create confusion by trying to imply otherwise and continue to point people in the direction of a shareware product instead of a product that advocates Ada at the expense of promoting a specific product.

I am happy to state to any one from experience about the fantastic "Gnat PRO product" a cutting edge build of gcc/ada build with maintenance contract.

Those of use not in the AdaCore "niche" should be using, testing and contributing to distro's like your very own Debian one.

> The GMGPL has been superseded by GPL version 3 with run-time library
> exception.

It does seem that way, however I've noticed that many GPLv3 with run-time exception products include the "modified" text of the old GMGPL. Do you know if that is by design? I've left the "modified" text in Gnoga which is GPLv3 since it seems to be in most AdaCore products. If you tell me is an oversight by others I'll remove it from Gnoga as well.

Thanks!
David Botton

Re: What is the best license to use for open source software?

[Ludovic Brenta]

David Botton writes:
>> Please use correct words; you are creating confusion.  No version of
>> GNAT is shareware.
>
> GNAT GPL is shareware, a try before you buy product for GNAT PRO. I
> see no issue with calling it was it is and stopping the clear
> confusion that it has created that it is the "standard" gcc/ada GNAT
> tool chain available to the community.  Clarity doesn't come from
> making "believe" a GPL run-time designed to prevent commercial use is
> not shareware. They have the right to do it, we have the right to call
> it what it is. There is no shame in creating and promoting a shareware
> / trialware product. It ain't cool, but they have the right.

No. GPL software is *not* shareware and does *not* prevent commercial
use, except in your opinion.  Do not present your opinion as truth; this
is confusing.

>> The GMGPL has been superseded by GPL version 3 with run-time library
>> exception.
>
> It does seem that way, however I've noticed that many GPLv3 with
> run-time exception products include the "modified" text of the old
> GMGPL. Do you know if that is by design? I've left the "modified" text
> in Gnoga which is GPLv3 since it seems to be in most AdaCore
> products. If you tell me is an oversight by others I'll remove it from
> Gnoga as well.

Yes, it is a mistake to mix GPLv3 with runtime library exception with
GMGPL wording.  Use one or the other, not a mix of the two.

--
Ludovic Brenta.

Re: What is the best license to use for open source software?

[David Botton]

> No. GPL software is *not* shareware and does *not* prevent commercial
> use, except in your opinion.  Do not present your opinion as truth; this
> is confusing.

GPL is a license. Shareware is a sales model. You are trying to compare apples and oranges. There is no confusion on my part or in my statements only making something crystal clear, even if painful for some to face.

In this case the company openly and intentionally publishes the run-time using the GPL license to "prevent and restrict" freedom of use in proprietary software and to discourage commercial use to _promote_ their commercial product. That is called shareware, (restricted right product to encourage purchase of less restrictive right product) you may not like it it being called out for what it is, but clarity is important.

Promoting a shareware compiler as a community option is harmful to general Ada advocacy.

There are strong viable gcc/ada distros that are not shareware and it is important to support and build on them to advocate Ada as a long term viable language for general purpose computing not just niche computing for deep pocket systems software. It is important that new users understand that if they are using GNAT GPL they are using a "shareware product" and there are other _professional options_ whatever their budget ranges for Ada use including proprietary software which is frequently needed in every domain.

We all want AdaCore to not just "survive" but to "thrive" because of what they send upstream to the FSF as GPL with run-time exceptions. (Disclaimer, others may have other reasons to like AdaCore, they do much good, even if they are harming the community in this area. Add the run time extension and a become bit more humble and they would be the Arch Angels of Ada :)
 
I am happy that many of my past projects are still being used by their customers and I am happy that Gnoga will be used by their customers (I know of some exploring its use now). That's a happy thought for me. Ada wins - they win and the community wins. You maintain gcc/ada on Debian. It encourages use of Ada and some of those users go on to need AdaCore services or feel the comfort level that Ada is not some niche language because of it, etc. Ada wins, they win and the community wins. The many others that write Ada code with unrestrictive licenses do the same, win win.

GPL runtimes on the compiler (or for that matter not on any "interface" library) are not Ada "win win" solutions, not even RMS, the FSF and the Free software movement (that I consider my self a strong advocate of and have the sloc to prove it).

> Yes, it is a mistake to mix GPLv3 with runtime library exception with
> GMGPL wording.  Use one or the other, not a mix of the two.

Thank you, I'll make the changes this week to the Gnoga headers and I'd encourage then others to inspect their headers as well. I recall seeing similar language in many AdaCore files and parts of AWS.

David Botton

Re: What is the best license to use for open source software?

[Ludovic Brenta]

David Botton writes:
>> No. GPL software is *not* shareware and does *not* prevent commercial
>> use, except in your opinion.  Do not present your opinion as truth; this
>> is confusing.
>
> GPL is a license. Shareware is a sales model. You are trying to
> compare apples and oranges. There is no confusion on my part or in my
> statements only making something crystal clear, even if painful for
> some to face.

Stop it.

Quoting Wikipedia: "The term shareware is used in contrast to
open-source software, in which the source code is available for anyone
to inspect and alter, and freeware, which is software distributed at no
cost to the user but without source code being made available."

https://en.wikipedia.org/wiki/Shareware

And the inventors of the GPL coined the term "free software" with the
specific goal of distinguishing it from "shareware".

https://www.gnu.org/philosophy/categories.html

--
Ludovic Brenta.

Re: What is the best license to use for open source software?

[David Botton]

> Stop it.

No, without debating if wikipedia is even definitive, my definition is supported by that article. The idea that software has to be "proprietary" to be shareware is simply not true. It is just the most common form. Just like the statement in the FSF article says that it "usually doesn't include source" but certainly does sometimes.

GNAT GPL could be called shareware, trialware, demoware, etc. everyone is valid.

It is what it is. A demo of tech that uses the GPL to license virus its output to encourage purchase of a commercial product. It is of questionable benefit to the company, it is harmful to the Ada community and it is not helpful at all to the GPL community (ok, maybe for bootstrap purposes....)

What is important and the only reason for beating this horse that won't die (no offense to horses intended) is that it is imperative that as a community everyone show a consistent message that the fsf gcc/ada versions are the primary Ada compiler and if you are so inclined that there are other great options for those needing high end support and "critical" compilers at AdaCore, i.e. go back to the original ACT approach, even if they want to continue to "scare" or GPL run-time bully away those with out the funds for their commercial product.

To make sure newbie understand they are just using the "shareware" version and that there is a real libre version that has no hidden agenda or license virus just like all the other gcc compilers.

David Botton

Re: What is the best license to use for open source software?

[Hubert]

On 1/4/2015 12:50 PM, David Botton wrote:
> You can put any license on your code but if compiled with shareware GNAT it will be virused into GPL (if compatible) or be in violation of the GPL, but that is only once compiled, some one else compiling your source code on an open gcc/ada compiler your license would apply as intended.
>
> Unless writing a tool that you would want under the full GPL, I recommend BSD/MIT or GMGPL. You can copy the GMGPLv3 from the Gnoga files if you like. Or do a search for BSD or MIT license, etc.
>
> David Botton
>

OK, I have seen the BSD license before, I will take a closer look at it. 
Seems that is a better option than these GPL versions, I don't really 
know where that is now with all the versions and derivations.




---
This email has been checked for viruses by Avast antivirus software.
http://www.avast.com

GNAT GPL is not shareware (was: Re: What is the best license to use for open source software?)

[Dirk Heinrichs]

David Botton wrote:

> It is what it is. A demo of tech...

No, it's not. It's not a demo, it's a fully featured product. If you don't 
like the license, don't use it. Use FSF Gnat instead.

HTH...

	Dirk
-- 
Dirk Heinrichs <dirk.heinrichs@altum.de>
Tel: +49 (0)2471 209385 | Mobil: +49 (0)176 34473913
GPG Public Key CB614542 | Jabber: dirk.heinrichs@altum.de
Tox: heini@toxme.se
Sichere Internetkommunikation: http://www.retroshare.org
Privacy Handbuch: https://www.privacy-handbuch.de

GNAT GPL is not shareware (was: Re: What is the best license to use for open source software?)

[David Botton]

Demos are usually fully featured and the issue is the impression others will have of the availability of Ada. If the impressionion is Ada is available only for open source or high end niche that leaves most of the world in the middle. That is not Ada advocacy that is harmful.

David Botton

Re: GNAT GPL is not shareware

[Mark Carroll]

David Botton <david@botton.com> writes:

> Demos are usually fully featured and the issue is the impression others will have of the availability of Ada. If the impressionion is Ada is available only for open source or high end niche that leaves most of the world in the middle. That is not Ada advocacy that is harmful.

Out of curiosity, am I correct in understanding that we have the GPL one
available at all only because of contractual requirements negotiated by
the DoD? If so, does it actually satisfy their intent? I wondered if
there is some other niche for it that they had in mind.

-- Mark

Re: GNAT GPL is not shareware

[David Botton]

> Out of curiosity, am I correct in understanding that we have the GPL one
> available at all only because of contractual requirements negotiated by
> the DoD?

We are not really discussing the availability of gnat as GPL but a specific build of gnat that is released by Ada core called "GNAT-GPL" and the importance of making sure the community _not_ imply that this is a "community edition" or otherwise allow people to get scare off from Ada as being unusable for proprietary and commercial projects if they are not deep pocket systems projects.

> If so, does it actually satisfy their intent? I wondered if
> there is some other niche for it that they had in mind.

My understanding is they wanted to promote Ada 95 its use and prevent stumbling blocks for wider acceptance.

AdaCore is not in violation of anything and are with in their rights to "convert" the run-time to full GPL to benefit their corporate interests even if at the expense of the Ada advocacy beyond their niche.

As a community interested in Ada advocacy there is no idea here about "stopping" AdaCore or even "changing" their minds, there is though the need to fill in the massive gap left between the shareware/demo/trial/viral GPL edition and the commercial PRO support package. A need for a "PRO Community" edition = the FSF distros.

So what there needs to be is an effort to:

1. Insure that the viral GPL edition is not misrepresented as a community edition.
2. That we improve the image, packaging and tools around the community edition.

GetAdaNow.com is a start in pushing the available community editions. This year time to start making the community edition look sharp and flashy and attractive to pro users.

My invitation to advertise and market AdaCore as part of that Ada advocacy effort in exchange for regular publishing a public version that is not viral still stands if they ever change their minds in the future. (I was never "asking" AdaCore for something, I was and am offering something ;)

My interests are constructive and I am happy that AdaCore will still gain customers even if not directly marketed by a strong community edition.

David Botton

Re: What is the best license to use for open source software?

[G.B.]

On 04.01.15 23:13, David Botton wrote:
> Clarity doesn't come from making "believe" a GPL run-time designed to prevent commercial use is not shareware.

Clarity would be good, indeed. Implied universal quantifiers
about licensing variables are the source of many misunderstandings
here, I think. Granted, these are a requisite of software politics.

"Shareware" and its diverse associations in one's mind
seems an unrelated issue to me, and, moreover, the notion
has the potential of creating confusion whilst there could
be a chance to point out, once again after many years, the
problem of Ada 2005 pricing in general.

As an example of commercial GPL software, our company depends
on some GPLed source commercially in products
that we sell to a customer; however, the contract between
the customer and us requires that we always deliver
the sources, anyway.  This commercial GPL situation may be
particular, but it exists.

It is politics to confuse "commercial" and "GPL" in general
propositions. This confusion doesn't help with deciding whether
or not FSF GCC is a viable option if one need to learn about
the implications of the linking exception.

It is clear from the GPL that *if* the commercial use of
the GPLed software should evolve into a *closed* *source*
distribution of derivative works, *then* the latter use is
illegal. The GPL virus prevents these illicit dealings in
software, in this particular case. The mataphor invoking
"virus" becomes increasingly inadequate, paradoxical actually,
but I understand the political intent.

But is it so hard to admit a preference for a business model that
eventually is, yes, *closed* *source*? I.e., no matter how free
the compiler is or how open source the libraries are, the final
products should be copy protected! The GPL's copyleft openly
prevents some kinds of copy protection. The linking exception
removes that in many cases.

Clarity? I'd find the licensing issues and business issues
much more clearly expressed if arguments would stop
using the big words and the free floating comparatives.

For example, are these facts?

- AdaCore support pricing, which entails the GPL linking
exception, is incompatible with most small businesses.

- If all Ada 2005 pricing is incompatible with small
business, then small business and Ada 2005 are incompatible.


Now imagine RR Software's compiler being updated and
targeting the LLVM.

What would your preferences be, then, WRT licensing and pricing?

Re: GNAT GPL is not shareware

[G.B.]

On 05.01.15 12:38, David Botton wrote:
> Demos are usually fully featured and the issue is the impression others will have of the availability of Ada. If the impressionion is Ada is available only for open source or high end niche that leaves most of the world in the middle. That is not Ada advocacy that is harmful.

2nd WRT impression management.

Dragging in more notions, though, seem counterproductive
to me if clarifying takes adducing their definition as well.
Recursively.

Re: GNAT GPL is not shareware

[Brad Moore]

On 15-01-05 04:38 AM, David Botton wrote:
> If the impressionion is Ada is available only for open source or high end niche that leaves most of the world in the middle. That is not Ada advocacy that is harmful.
>
> David Botton
>

But Ada is not GNAT, and the fact that there is also a free version of 
GNAT available should provide coverage for those in the middle who want 
something for free. In addition, there are also other compilers 
available that have other pricing models.

If the impression is that Ada is available only for open source or high 
end niche, that is a false impression. Changing licenses of GNAT-GPL to 
address a false impression doesn't make sense to me. It would make more 
sense to do a better job of propagating a better impression based on fact.

Are there websites propagating this false impression that need to be 
corrected?

If I search for "Ada Programming Language" the top search result I get 
back is this....

http://en.wikipedia.org/wiki/Ada_%28programming_language%29

On this page, it mentions GNAT, but does not mention other compiler 
vendors, nor does it mention the various flavors of GNAT, except under 
the section on history with this sentence.

"A number of commercial companies began offering Ada compilers and 
associated development tools, including Alsys, Telesoft, DDC-I, Advanced 
Computer Techniques, Tartan Laboratories, TLD Systems, and others."


I think it would be helpful if this page also had a section or a link to 
a more comprehensive list of the various versions of Ada compilers that 
are currently available.

If I follow the hyperlink to GNAT, I end up at a page that describes the 
licensing with the following;

"The compiler is licensed under the terms of the GNU General Public 
License. The "GNAT GPL Edition" of the runtime is licensed under the GNU 
General Public License while the "GNAT Pro Edition" is under the GNAT 
Modified General Public License. All versions leading up to and 
including 3.15p are licensed under the GMGPL. GNAT-FSF is included 
within the GNU Compiler Collection with the GMGPL license governing the 
runtime, it corresponds to the GNAT-GPL version of the previous year 
(about 9 months apart). At version 4.4, the runtime was relicensed under 
the GPL version 3 with the GCC Runtime Library Exception.[2] GNAT-FSF is 
part of most major GNU/Linux or BSD distributions.

The GMGPL license in either GNAT Pro runtime or GNAT-FSF runtime permits 
software that is licensed under a license that is incompatible with the 
GPL to be linked with the output of Ada standard generic libraries that 
are supplied with GNAT without breaching the license agreement. 
Conversely, the GPL license of either GNAT GPL runtime or GNAT GAP 
runtime requires software that is linked with the standard libraries to 
be a GPL-compatible license to avoid being in breach of the license 
agreement."

It seems pretty clear to me how the variants of licensing work, but 
perhaps this could be improved upon to provide better clarity.

For instance, I think the first sentence gives the impression that GNAT 
is GPL. It's not until you read further where you learn about other 
variants. So I think the first sentence should be changed.

Brad

Re: GNAT GPL is not shareware

[G.B.]

On 05.01.15 14:59, Brad Moore wrote:
> If I follow the hyperlink to GNAT, I end up at a page that describes the
> licensing with the following;

https://en.wikipedia.org/wiki/GNAT#License

has been edited accordingly.

Re: What is the best license to use for open source software?

[David Botton]

 > For example, are these facts?
> 
> - AdaCore support pricing, which entails the GPL linking
> exception, is incompatible with most small businesses.

Correct

> - If all Ada 2005 pricing is incompatible with small
> business, then small business and Ada 2005 are incompatible.

No, since there are FSF gcc/ada editions (priced in range, in this case 0 but didn't have to be) that small businesses can use. AdaCore has pointed that out themselves.

> Now imagine RR Software's compiler being updated and
> targeting the LLVM.
> 
> What would your preferences be, then, WRT licensing and pricing?

While I am a strong proponent of "libre" software it matters to me only if they made it available under a "free" license and since a compiler (or interface to system service) I also would hope with a runtime exception.

If they had a free license (and non-viral runtime), regardless if they had pricing in range for small business or not, I'd be pumping them all the time.

David botton

Re: GNAT GPL is not shareware

[David Botton]

> But Ada is not GNAT, and the fact that there is also a free version of 
> GNAT available should provide coverage for those in the middle who want 
> something for free. In addition, there are also other compilers 
> available that have other pricing models.

If that free version is not viral yes, and there is one FSF GNAT and this discussion is about community marketing of the FSF GNAT version over the viral shareware one to make sure the very fact you are talking about is known to all.

 
> If the impression is that Ada is available only for open source or high 
> end niche, that is a false impression.

Correct and why marketing in public forums the versions that advocate Ada across a broader spectrum (including mention when beneficial of other options) is important.


> Changing licenses of GNAT-GPL to 
> address a false impression doesn't make sense to me.

I agree with you. There is no reason AdaCore should not "showcase" their product and if they want a shareware model that is their business.

What is needed is for the community to "showcase" a GNAT-Community edition that clearly shows Ada is viable for all potential markets.

My business proposal was for an AdaCore business edition to fill in the middle market. If they felt that made no business sense to them that is acceptable to me. 

However for good Ada advocacy there needs to be something to fill in the gaps, there is as AdaCore pointed out FSF GNAT.

So I am going to go with AdaCore's own advice to me. That FSF GNAT fulfills that position.

I as an Ada advocate then am pushing for the community to start "showcasing" that "Community" edition and to make sure that a viral edition is never mistaken as being "what is available for that middle position".

> It would make more 
> sense to do a better job of propagating a better impression based on fact.

That is exactly what I am advocating we do and already working on. GetAdaNow.com is the first step, i.e. making peoples first encounter with Ada compilers _not_ a viral edition. Next step is making that encounter a super positive one.

> Are there websites propagating this false impression that need to be 
> corrected?

"False statements" /= "False impressions", "False impressions" /= "False statements"

Impressions are almost always based on careful choice of truths that are marketed.

I've pointed out in previous post "scare tactic" statements from the libre site and other posts and sites.

So, I hope you have some projects for this year to promote Ada, I'll start that thread asap. Be nice for people to start posting what there "Ada Advocacy for 2015" will be.



David Botton

Re: What is the best license to use for open source software?

[Maciej Sobczak]

> OK, I have seen the BSD license before, I will take a closer look at it. 

I have read the GPL flame with great interest (as usual, because it seems to be a periodic phenomenon), but I think the discussion would not be complete if you are left with only two choices.
Some time ago the C++ community (yes, the guys everybody hates here and which happened to do lots of things just right ;-) ) came up with the Boost license, which was explicitly intended to support both open- and closed-source software. The community that relies on this license is now very large, which also means that its legal meaning is well established. For detailed wording see here:

http://opensource.org/licenses/bsl1.0.html

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

Re: What is the best license to use for open source software?

[Tero Koskinen]

5.1.2015, 17:56, Maciej Sobczak kirjoitti:
>
>> OK, I have seen the BSD license before, I will take a closer look
>> at it.
>
> I have read the GPL flame with great interest (as usual, because it
> seems to be a periodic phenomenon), but I think the discussion would
> not be complete if you are left with only two choices. Some time ago
> the C++ community (yes, the guys everybody hates here and which
> happened to do lots of things just right ;-) ) came up with the Boost
> license, which was explicitly intended to support both open- and
> closed-source software. The community that relies on this license is
> now very large, which also means that its legal meaning is well
> established. For detailed wording see here:
>
> http://opensource.org/licenses/bsl1.0.html
>

There are also other permissive open source licenses which supports open
and closed source software.

Ruby and JavaScript projects many times use MIT license.
For example, see Ruby on Rails (http://rubyonrails.org/) or JQuery
(https://jquery.org/license/).

Java and JVM -based projects often use Eclipse License.
Examples: Eclipse IDE itself, Clojure (http://clojure.org/license).

Personally, I prefer ISC license (basically simplified BSD), which comes
from Internet Software Consortium (home for BIND & stuff).
Example: OpenBSD; Ahven, my unit testing library for Ada
http://www.ahven-framework.org/LICENSE.txt

There are some wording differences between these licenses (Boost, MIT,
Eclipse, ISC), but generally they are compatible with each other and you
can include the code to closed source software without needing to
release the source code. (Of course, there might be some exceptions;
check the licenses first before combining code with different licenses.)

Yours,
  Tero

Re: What is the best license to use for open source software?

[David Botton]

On Monday, January 5, 2015 10:56:19 AM UTC-5, Maciej Sobczak wrote:
> > OK, I have seen the BSD license before, I will take a closer look at it. 
> 
> I have read the GPL flame 

No one is flaming the GPL. Most of us (but not all) use it and are happy with it.


> Some time ago the C++ community (yes, the guys everybody hates here and which happened to do lots of things just right ;-) )

Now that is flamebait if I've ever heard it ;)

> came up with the Boost license, which was explicitly intended to support both open- and closed-source software. The community that relies on this license is now very large, which also means that its legal meaning is well established. For detailed wording see here:
> 
> http://opensource.org/licenses/bsl1.0.html

I will take a look, but I've generally been happy with GPL or GMGPL and it carries my intent. But yes the muddy waters in recent times may mean fresh looks at other options in order.

David Botton

Re: GNAT GPL is not shareware

[Jeffrey Carter]

On 01/05/2015 05:02 AM, Mark Carroll wrote:
> 
> Out of curiosity, am I correct in understanding that we have the GPL one
> available at all only because of contractual requirements negotiated by
> the DoD? If so, does it actually satisfy their intent? I wondered if
> there is some other niche for it that they had in mind.

As I understand things, you are not correct.

The AJPO contracted with New York University to produce an Ada-95 compiler that
would fulfill a number of objectives. One was that the source code of the
compiler be freely available so that others could study the way the compiler was
written; this source had to have a GPL-like restriction so that any who used the
source as the basis for another compiler also had to make their source code
available. Another was that programs compiled with the compiler could be closed
source. Another was that NYU provide copies of the compiler for "free" [which
could include a charge for the actual cost of providing the copy, such as the
medium on which it was provided (often a CD in 1996), making the copy, and
sending it via snail mail].

Since some of the source code (standard generics) that had to have the GPL could
be compiled and included in the resulting executable (because of GNAT's
macro-expansion processing of generics), something not dealt with at the time by
any other gcc compiler, a modified license different from the GPL or the LGPL
was needed; the result was the GMGPL.

Later GNAT was transferred from NYU to Ada Core Technologies, with AdaCore
required to abide by the terms of the AJPO contract.

That contract was for an Ada-95 compiler. As the definition of Ada 0X
progressed, AdaCore included many of its features in GNAT. Eventually GNAT
became a full ISO/IEC 8652:2007 compiler, and only functioned as an Ada-95
compiler with a special compiler switch. At this point the compiler no longer
fell under the requirements of the contract. Since the source for this compiler
was derived from the GPL source of the earlier compiler, it continued to be GPL,
but there were no longer the requirements that programs compiled with the
compiler could be closed source or that AdaCore provide the compiler for free.
So the existence of GNAT GPL is not because of the contract; AdaCore must have
another reason for releasing it.

(In fact, early versions of GNAT GPL were Ada-95 compilers by default, and only
acted as ISO/IEC 8652:2007 compilers with a special switch. One could, and some
did, argue that these were Ada-95 compilers and so were covered by the contract
and were in violation of it. Since the DoD never objected, the point is moot.)

-- 
Jeff Carter
"Blessed is just about anyone with a vested interest in the status quo."
Monty Python's Life of Brian
73

Re: GNAT GPL is not shareware

[Jeffrey Carter]

On 01/05/2015 04:24 AM, Dirk Heinrichs wrote:
> David Botton wrote:
> 
>> It is what it is. A demo of tech...
> 
> No, it's not. It's not a demo, it's a fully featured product. If you don't 
> like the license, don't use it. Use FSF Gnat instead.

In my experience, "shareware" has been used for full-featured software released
at no cost with a request that those who find the S/W useful send some money to
the developer(s). There is also the term "crippleware" for S/W released at no
cost but lacking some feature(s) that can be obtained by paying for the
full-featured version.

GNAT GPL does not match this definition of "shareware".

Some might claim that GNAT GPL does match this definition of "crippleware". As
an example of crippleware, see http://www.wolframalpha.com/. Some offered
features result in an exhortation to "Subscribe to Pro", and this is a
characteristic of most crippleware that is not present in GNAT GPL.

It would be easier to think of GNAT GPL as crippleware if every invocation of
the compiler resulted in an encouragement to buy GNAT Pro that required action
by the user before the compilation proceeded.

The GNAT Pro/GNAT GPL dichotomy seems unique: two products with essentially
identical features, differing only in the run-time license. Perhaps we should
dub GNAT GPL "RTL-ware".

-- 
Jeff Carter
"Blessed is just about anyone with a vested interest in the status quo."
Monty Python's Life of Brian
73

Re: What is the best license to use for open source software?

[Michael B.]

On 01/05/15 03:28, David Botton wrote:
> It is what it is. A demo of tech that uses the GPL to license virus its output to encourage purchase of a commercial product.

But GNAT GPL is be used commercially. If you do in-house maintenance of 
applications that are not sold/distributed, the GPL virus can't bite you.

Re: What is the best license to use for open source software?

[David Botton]

> But GNAT GPL is be used commercially. If you do in-house maintenance of 
> applications that are not sold/distributed, the GPL virus can't bite you.

Lots of demo software can be useful in some situations, but that doesn't make it something good for Ada advocacy (or even Free software advocacy in a case of unencumbered run times).

Example, GPL would work for software I write for my medical clinics, however if I decided to sell or give away binaries of software I wrote for my clinics then likely it would not work. However.. If I decide to integrate the software I write with any of the other software, drivers or equipment in my office  I _will_ be in violation of the GPL even if I don't distribute the binaries. If they are not "GPL" compatible.

David Botton

Re: What is the best license to use for open source software?

[sbelmont700]

On Monday, January 5, 2015 3:45:48 PM UTC-5, David Botton wrote:
> 
> If I decide to integrate the software I write with any of the other software, drivers or equipment in my office  I _will_ be in violation of the GPL even if I don't distribute the binaries. If they are not "GPL" compatible.
> 

A license is an agreement between two parties: you and the person you distribute the software to.  If you don't distribute the program, then no license exists, and certainly no violations thereof. License 'incompatibilities' only refer to how it can be RE-licensed, not used (well, normally.  A license can say absolutely anything at all).

Re: GNAT GPL is not shareware

[Dennis Lee Bieber]

On Mon, 5 Jan 2015 05:26:49 -0800 (PST), David Botton <david@botton.com>
declaimed the following:

>
>As a community interested in Ada advocacy there is no idea here about "stopping" AdaCore or even "changing" their minds, there is though the need to fill in the massive gap left between the shareware/demo/trial/viral GPL edition and the commercial PRO support package. A need for a "PRO Community" edition = the FSF distros.

	I'd be happy with a low-cost non-support non-encumbered ACT release...
Say $100-200 to get a version without the GPL passthrough to built
applications, but with no rights to pester them about perceived bugs.

	Mainly because my main environment is M$ Windows -- and having to build
the toolchain first is a pain over having a pre-built native installer.
-- 
	Wulfraed                 Dennis Lee Bieber         AF6VN
    wlfraed@ix.netcom.com    HTTP://wlfraed.home.netcom.com/

Re: GNAT GPL is not shareware

[Dennis Lee Bieber]

On Mon, 05 Jan 2015 11:43:54 -0700, Jeffrey Carter
<spam.jrcarter.not@spam.not.acm.org> declaimed the following:

>The GNAT Pro/GNAT GPL dichotomy seems unique: two products with essentially
>identical features, differing only in the run-time license. Perhaps we should
>dub GNAT GPL "RTL-ware".

	Run time license AND tech support...
-- 
	Wulfraed                 Dennis Lee Bieber         AF6VN
    wlfraed@ix.netcom.com    HTTP://wlfraed.home.netcom.com/

Re: GNAT GPL is not shareware

[Hubert]

> 	I'd be happy with a low-cost non-support non-encumbered ACT release...
> Say $100-200 to get a version without the GPL passthrough to built
> applications, but with no rights to pester them about perceived bugs.

I agree. All these arguments here really sound like nitpicking that 
serve no one.
I think the future of Ada would be better served if there was a low cost 
version of Gnat that can be used in small scale commercial projects. 
Other companies do that a lot, I see that especially in the gaming tool 
industry where there are offers like "Free to use if you make less than 
so much money per year, above that a paid version is required. Could be 
in one or two price levels.




---
This email has been checked for viruses by Avast antivirus software.
http://www.avast.com

Re: GNAT GPL is not shareware

[David Botton]

Can either of you tell me why the FSF gcc/ada doesn't serve that purpose now and at a zero price point?

For windows TDM-GCC (4.9.2) seems to be working well for me. See GetAdaNow.com
Granted the lack of gprtools is annoying, gnatmake still works for my purposes on Windows.

David Botton


On Monday, January 5, 2015 7:48:22 PM UTC-5, Hubert wrote:
> > 	I'd be happy with a low-cost non-support non-encumbered ACT release...
> > Say $100-200 to get a version without the GPL passthrough to built
> > applications, but with no rights to pester them about perceived bugs.
> 
> I agree. All these arguments here really sound like nitpicking that 
> serve no one.
> I think the future of Ada would be better served if there was a low cost 
> version of Gnat that can be used in small scale commercial projects. 
> Other companies do that a lot, I see that especially in the gaming tool 
> industry where there are offers like "Free to use if you make less than 
> so much money per year, above that a paid version is required. Could be 
> in one or two price levels.

Re: GNAT GPL is not shareware

[Hubert]

On 1/5/2015 16:54 PM, David Botton wrote:
> Can either of you tell me why the FSF gcc/ada doesn't serve that purpose now and at a zero price point?

Well for wone, I like an IDE with the compiler. I guess it could be 
possible to use the FSF compiler with Adacore's GPS but I am neitehr a 
Linux nor an Ada crack so I prefer a out of the box solution.

My main point however is this: You can not expect everybody to work for 
free and Gnat is basically the only solution out there if you want Linux 
and Windows Ada 2012 features. So as Eliza Dolitte's father would say:

I'm willing to pay them! I'm wanting to pay them! I'm waiting to pay them!

Just not 10,000$

I would be happy to pay something in the field of 300$ for that system 
as it is now, without tech support, if it allowed me to write small 
closed suorce software.



---
This email has been checked for viruses by Avast antivirus software.
http://www.avast.com

Re: GNAT GPL is not shareware

[Stefan.Lucks]

[-- Attachment #1: Type: TEXT/PLAIN, Size: 1235 bytes --]

On Mon, 5 Jan 2015, Hubert wrote:

>> Can either of you tell me why the FSF gcc/ada doesn't serve that purpose 
>> now and at a zero price point?
>
> Well for wone, I like an IDE with the compiler.

You could develop your software with AdaCore's IDE and compiler, and then 
compile the final executables with the free FSF compiler. I tried this 
some time ago (out of curiosity, not for license reasons).

The FSF and AdaCore-GPL compilers seem to be compatible, though I tried to 
avoid gnat-specifics, anyway. Bug fixes and new features for FSF may be a 
bit behind. But if you avoid the most recently added feature and don't 
run into some exotic bug, your program should compile and run the same.

> I would be happy to pay something in the field of 300$ for that system as it 
> is now, without tech support, if it allowed me to write small closed suorce 
> software.

Agreed. The existence of such a compiler (by AdaCore or someone else) 
would be good for the Ada community.

Stefan

------  I  love  the  taste  of  Cryptanalysis  in  the morning!  ------
     <http://www.uni-weimar.de/cms/medien/mediensicherheit/home.html>
--Stefan.Lucks (at) uni-weimar.de, Bauhaus-Universität Weimar, Germany--

Re: GNAT GPL is not shareware

[J-P. Rosen]

Le 06/01/2015 14:26, Stefan.Lucks@uni-weimar.de a écrit :
>> I would be happy to pay something in the field of 300$ for that system
>> as it is now, without tech support, if it allowed me to write small
>> closed suorce software.
> 
> Agreed. The existence of such a compiler (by AdaCore or someone else)
> would be good for the Ada community.

Unfortunately, I fear that nobody from Atego is reading this
newsgroup... (Yes, they (Alsys at that time) used to have a "personal"
version of the compiler).

-- 
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: GNAT GPL is not shareware

[David Botton]

> Agreed. The existence of such a compiler (by AdaCore or someone else) 
> would be good for the Ada community.

I'll have the Gnoga IDE ready before end of year and packaged dev environments with it.

While certainly someone could package gps and fsf together, I don't think that is a positive approach to things, I'm only in to win win for all. They have willingly contributed back the compiler to the FSF and it itself is a derivative work, so I have no issue building on it on using the same GPL for the community advantage, but they have every right to showcase their version and their tools like GPS and have all the benefit from doing so and I have no interest in taking that away form them.

Even more when simply installing GNAT-GPL and putting the FSF compiler on the command line before it makes it all work anyways.

David Botton

Re: GNAT GPL is not shareware

[David Botton]

> Unfortunately, I fear that nobody from Atego is reading this
> newsgroup... (Yes, they (Alsys at that time) used to have a "personal"
> version of the compiler).

It really wouldn't matter, there is no big profit in the small sales in their minds.

Most of these vendors have the same small minded thinking of only looking at direct sales instead of expanding the user base through mass marketing efforts through free or cheap compiler options.

If Ada doesn't grow in general use and to a larger general user base it is only a matter of time for the niche market to dry up or Ada displaced in those markets.

David Botton

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-06 14:26, Stefan.Lucks@uni-weimar.de wrote:
> On Mon, 5 Jan 2015, Hubert wrote:
> 
>>> Can either of you tell me why the FSF gcc/ada doesn't serve that
>>> purpose now and at a zero price point?
>>
>> Well for wone, I like an IDE with the compiler.
> 
> You could develop your software with AdaCore's IDE and compiler, and
> then compile the final executables with the free FSF compiler. I tried
> this some time ago (out of curiosity, not for license reasons).
> 
> The FSF and AdaCore-GPL compilers seem to be compatible, 

Wait until you build a library with one, and try to link it
with the other. Won't work - at least I can't make it work.

If I build say AWS with Gnat-GPL, I can use the library
if I use Gnat-GPL.
However, If I change path, to use Gnat-FSF,
It won't work, complaining on different Gnat versions.

The solution is to change path first,
and build AWS with Gnat-FSF.
GPS will pick up gnat tools first in path.


--
Björn

Re: GNAT GPL is not shareware

[G.B.]

On 06.01.15 15:45, J-P. Rosen wrote:
> Le 06/01/2015 14:26, Stefan.Lucks@uni-weimar.de a écrit :
>>> I would be happy to pay something in the field of 300$ for that system
>>> as it is now, without tech support, if it allowed me to write small
>>> closed suorce software.
>>
>> Agreed. The existence of such a compiler (by AdaCore or someone else)
>> would be good for the Ada community.
>
> Unfortunately, I fear that nobody from Atego is reading this
> newsgroup... (Yes, they (Alsys at that time) used to have a "personal"
> version of the compiler).
>

Aonix used to sell a Windows compiler for $$$, up to
v7.6 or v8.2, I believe. Atego has been acquired (7/2014)
into the PTC staffing optimization enterprise(*),
together with IBM Ada (then Atego Ada (then Rational Ada)).
So, PTC has two Ada compilers, one rather complete
(Ada 2005), the other using the AdaMagic frontend, which
used to be sold by SofCheck (now AdaCore).

Maybe making available a no-support compiler would
be an addition that is tiny enough to not affect an enterprise's
accounting efforts. (Compare it to keeping track of gift acquisition
and other business expenses of the sales department.)
But, OTOH, bigger enterprises need some incentive to make
smaller products. What would that be?

So, in the end, a reasonably simple Ada compiler for the
non-enterprise Ada market would best be produced and maintained
by ____. Fill in the blanks ;-)

__
(*) http://atego.com/pressreleases/pressitem/ptc-to-acquire-atego
http://de.ptc.com/about/news-room/press-releases/2014/07/ptc-completes-acquisition-of-atego

Re: GNAT GPL is not shareware

[David Botton]

Blank = the community

FSF compiler packeged with community support Dev environment etc.

Coming soon to a comp.lang near you.

David Botton

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-06 17:44, Shark8 wrote:

> On 06-Jan-15 08:09, Björn Lundin wrote:

I did reply to cla, not only to me.


>> The solution is to change path first,
>> and build AWS with Gnat-FSF.
>> GPS will pick up gnat tools first in path.
>
> That's a disgusting solution.
> Not because it works, but because there's any path-manipulation at all.

So? Welcome to the real world.
PATH is an environment _variable_
that is ok to add stuff to.

Having at least 4 version of gnat installed, its dead easy to
switch between.


> The more I see dependencies like this the more convinced I am that the
> general-idea of the APSE (and SCID, in general) is the proper way to do
> things.

bull

 -- This is to say, modern IDEs *don't go far enough*, let's get
> version-control and the build system in there too so there's no
> [variable] external dependencies like the PATH.

Yes, let us remove the freedom to simple config changes,
and put stuff like that in some hidden config file,
so complex that you need a special tool to change it.
And rip out any transparency, so you can get rid of files
and put them in a database.

Lets us kill all text-editors and
only use _your_ soon-to-come-any-decade fantastic
super duper editor


--
Björn

Re: GNAT GPL is not shareware

[Björn Lundin]

> On 2015-01-06 17:44, Shark8 wrote:
> 
>> On 06-Jan-15 08:09, Björn Lundin wrote:
> 
> I did reply to cla, not only to me.
> 
> 
>>> The solution is to change path first,
>>> and build AWS with Gnat-FSF.
>>> GPS will pick up gnat tools first in path.
>>
>> That's a disgusting solution.
>> Not because it works, but because there's any path-manipulation at all.


>>  -- This is to say, modern IDEs *don't go far enough*, let's get
>> version-control and the build system in there too so there's no
>> [variable] external dependencies like the PATH.
> 

Which of course makes me wonder where YOU install
compilers? Somewhere in the system path?
THAT is disgusting.

Quoting wikipedia :
<http://en.wikipedia.org/wiki/PATH_%28variable%29>

second last sentence:

"The PATH variable makes it easy to run commonly used programs located
in their own folders."




--
Björn

Re: GNAT GPL is not shareware

[Ludovic Brenta]

David Botton writes:
> Demos are usually fully featured and the issue is the impression
> others will have of the availability of Ada. If the impressionion is
> Ada is available only for open source or high end niche that leaves
> most of the world in the middle. That is not Ada advocacy that is
> harmful.

80% of all software in the world is never released to anyone, much less
to the public, and is therefore not impacted by the GPL "virus".  If
"most of the world" means the proprietary software sold by vendors then
"most of the world" means maybe 10% of the world, the remaining 10%
being free software.

--
Ludovic Brenta.

Re: GNAT GPL is not shareware

[Ludovic Brenta]

Hubert writes on comp.lang.ada:
> On 1/5/2015 16:54 PM, David Botton wrote:
>> Can either of you tell me why the FSF gcc/ada doesn't serve that
>> purpose now and at a zero price point?
>
> Well for wone, I like an IDE with the compiler. I guess it could be
> possible to use the FSF compiler with Adacore's GPS but I am neitehr a
> Linux nor an Ada crack so I prefer a out of the box solution.

aptitude install gnat gnat-gps

and you get both the FSF compiler (with runtime library exception) and
GPS IDE.

--
Ludovic Brenta.

Re: GNAT GPL is not shareware

[David Botton]

> and is therefore not impacted by the GPL "virus"

I am looking to confirm that in fact linking and using software with incompatible licenses is legal, but if that is true then perhaps more are "covered" for their needs as you say than I would think. I don't believe that statement 100% factual in most corporate environments.

Either way my issue is about the impression and the reality of how people look a language where the "community" compiler is virused. I for one would never ever have written a single line of Ada code had it been this way when I started and almost all my code was written with the then restriction free environment in mind. I invested my time and skills with the idea everyone wins, me the community, AdaCore, customers, etc. (note, post creating it I was paid for one project by Act to support it for their customers, again win win)

We all know of many others that either walked away or won't consider Ada for their projects because of _their_ impressions, reality of FSF gnat or not. I came back only because of work like yours on Debian and in particular Simon on Mac, and I am a GPL software author. My belief this time around, my personal challenge, is that I can put together a package of tools that no corporation can uses licenses as weapons against. (I make my living as a physician now and supplement with code so I may not _need_ this anymore, but I complete what I start out to do, and that is how I got to Ada in the first place).

You go trying to sell a company on the idea you will be writing their software but it will be under the GPL... good laugh and no deal. (there are exceptions of course.. but few and far between)

Ada doesn't need barriers to entry like this. It is an embarrassment to all that have created open source code in Ada over the years. Time to correct it and the _impression_ Ada makes on new developers.

Someone should try Ada and say, wow this is cool! I'll try this on my next project or for my next customer.

It shouldn't be, wow this is cool, uh oh, I can't this, I can't that, I can't this, oh my oh my that much to use for my sisters cake decorating business... oh common this is ridiculous that I should even need to justify how important it is to start pushing a non-viral compiler option to all newbies and keep them away from GPL virused versions unless they are potential customers for AdaCore who I would even encourage to go get it.

For _students_, newbies, hobbyists, and authors of non-safety critical systems a solid dev environment with out "restrictions" is a must. It is a lose lose for everyone even AdaCore (even if they can't see beyond immediate direct dollar sales and are too blind to see it is their lack of creative innovation and R&D for new ways to keep customers that is the real issue not customers feeling they don't need AdaCore if they can use the "free" compilers).

So let it be, if they think that every Ada advocate is some "leach" using "their tech" and their needs irrelevant and the community not worth their time participating in actively, time for us "leaches" to start thinking... Ada advocates need something to advocate to the 99% of the software development world that is not a potential customer of AdaCore or toss out Ada. I'm giving it one more try, we will see where it goes, I gave my self a 2 year trial period (I'm sure that makes some happy ;) to succeed or fail, I'm now 5 months in to that. Gnoga has been a nice start, now an IDE, some tools and beautiful easy to use packages. We will see.

David Botton

Re: GNAT GPL is not shareware

[Randy Brukardt]

"David Botton" <david@botton.com> wrote in message 
news:72ede803-e2e9-4e21-a415-457374bef87d@googlegroups.com...
>
>> Unfortunately, I fear that nobody from Atego is reading this
>> newsgroup... (Yes, they (Alsys at that time) used to have a "personal"
>> version of the compiler).
>
> It really wouldn't matter, there is no big profit in the small sales in 
> their minds.
>
> Most of these vendors have the same small minded thinking of only looking 
> at direct sales
>instead of expanding the user base through mass marketing efforts through 
>free or cheap
>compiler options.

That's not really fair. Both Atego (with ObjectAda) and RRS (with Janus/Ada) 
tried to market low-cost compilers for the mass market, but neither made 
money.

Our experience was that the more money and effort that we put into it, the 
more money that we lost (sales were about the same either way).

I've heard that the personal version of ObjectAda had essentially the same 
results -- Atego put a lot of money into it and didn't even break-even. (And 
it doesn't make sense to lose money on every unit one sells.)

There may be a model out there which works for a low-end Ada compiler, but I 
would expect that it would require low effort in order to be profitable. 
Which makes it problematical, as some sort of support is required (at a 
minimum, packaging and fixing of packaging, which can take an amazing amount 
of time).

                                                      Randy.

Re: GNAT GPL is not shareware

[Ludovic Brenta]

David Botton <david@botton.com> writes:
>> and is therefore not impacted by the GPL "virus"
>
> I am looking to confirm that in fact linking and using software with
> incompatible licenses is legal, but if that is true then perhaps more
> are "covered" for their needs as you say than I would think. I don't
> believe that statement 100% factual in most corporate environments.

Then read up about copyright law.  Copyright says nothing about
"linking" or "using".  The author of a copyrighted work has the right to
control *copy* and *distribution* of their work, nothing more and
nothing less.

--
Ludovic Brenta.

Re: GNAT GPL is not shareware

[Shark8]

On 06-Jan-15 10:37, Björn Lundin wrote:
>
> On 2015-01-06 17:44, Shark8 wrote:
>
>> On 06-Jan-15 08:09, Björn Lundin wrote:
>
> I did reply to cla, not only to me.
>
>
>>> The solution is to change path first,
>>> and build AWS with Gnat-FSF.
>>> GPS will pick up gnat tools first in path.
>>
>> That's a disgusting solution.
>> Not because it works, but because there's any path-manipulation at all.
>
> So? Welcome to the real world.
> PATH is an environment _variable_
> that is ok to add stuff to.

I'm not saying it's not ok to add stuff to it; I'm saying making your 
system dependent upon it is, in a word, stupid.

> Having at least 4 version of gnat installed, its dead easy to
> switch between.
>
>
>> The more I see dependencies like this the more convinced I am that the
>> general-idea of the APSE (and SCID, in general) is the proper way to do
>> things.
>
> bull

Really?
What has file-centric and "distributed among tools" setups brought about 
(a) in terms of configuration complexity? (b) In terms of organization 
complexity/dependence? And (c) in terms of consistency complexity?

(A) How many different "small tools" have their own configuration which 
directly impacts another tool and that other tool doesn't know about the 
first?
(B) Consider how many libraries need to be installed in a certain place 
to get them to work right/easily.
(C) Have you /EVER/ linked to the wrong object because it became out of 
date?

>   -- This is to say, modern IDEs *don't go far enough*, let's get
>> version-control and the build system in there too so there's no
>> [variable] external dependencies like the PATH.
>
> Yes, let us remove the freedom to simple config changes,
> and put stuff like that in some hidden config file,
> so complex that you need a special tool to change it.
> And rip out any transparency, so you can get rid of files
> and put them in a database.

At what cost?
If things are in a database you can get consistency-checking essentially 
for free! You can design the system so that you *NEVER* compiler 
"against the wrong object". You can make it so that you *NEVER* pull an 
'oopsie' with a simple textual search-and-replace rename.

Moreover, if stored in a database things like version-control can be 
made more useful by storing only the semantically meaningful changes. 
Things like "formatting style" become absolutely meaningless because, 
guess what, the textual-representation gets reconstructed and 
redisplayed as-needed... and that can be fully customizable to the 
particular user w/o impacting anyone else.

Seriously, that "the industry" remains fixated on _text_ as the de facto 
medium for storing/maintaining/manipulating programs is disgusting! -- 
It's like a firearm manufacturer that refuses to use firearms in favor 
of bows because "it's simpler".

Hell, if *"because it's simpler"* is a valid reason to embrace 
something, might I suggest you look into PHP, after all its 
implementation (and usage) is "much simpler" than Ada or most any 
compiled language.


> Lets us kill all text-editors and
> only use _your_ soon-to-come-any-decade fantastic
> super duper editor

Who said anything about killing text editors?
Of course it'd need a way to display/manipulate the program, and of 
course it'd need to be able to import/export plain-text.

But the fact still remains: the text-based/file-based model is 
inherently worse because it pushes automatable and verifiable checking 
directly into the user's lap.

Re: GNAT GPL is not shareware

[David Botton]

> That's not really fair. Both Atego (with ObjectAda) and RRS (with Janus/Ada) 
> tried to market low-cost compilers for the mass market, but neither made 
> money.

You missed my point, which was fair. There is _no_ low-cost compiler market. That bottomed out already before OA and RRS started to market their products to a non-existing market. That market is not going to materialize again ever either.

In fact there is no _compiler_ market at all, there is a slightly synthetic market still in the Ada world, but that is just about gone and why shareware license games is a pathetic answer to trying to make believe it is still there (btw it is just about gone for every language I know of).

There is a small enterprise compiler support market for Ada and likely that will remain for some time but not likely to grow much.

There are huge markets and lots of money to be made in many areas, but all things change and the old markets and ways of doing business were already dying as Ada 95 was emerging.

> Our experience was that the more money and effort that we put into it, the 
> more money that we lost (sales were about the same either way).

Of course it did. My point is that vendors that want enterprise business need to expand at any cost including free the other markets for a trickle up affect.


> I've heard that the personal version of ObjectAda had essentially the same 
> results -- Atego put a lot of money into it and didn't even break-even. (And it doesn't make sense to lose money on every unit one sells.)

Sure it does if you see it as marketing dollars not sales figures. Also their personal price point was off, so not so personal.

AdaCore understands this a bit, and so their GAP program, etc. Not enough, but at least shows they are not completely inept at business, just not great at it.


> There may be a model out there which works for a low-end Ada compiler

That market died. Although possible to make a few dollars for a mom and pop in training and high level support.

> Which makes it problematical, as some sort of support is required (at a 
> minimum, packaging and fixing of packaging, which can take an amazing amount 
> of time).

A long time ago, people realized that open source changed where the dollars are in software.

The vendors that can't see beyond compiler sales haven't survived (per se) and those in large support contracts are floating, but not swimming if that is their only real product.

David Botton

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-06 21:52, Shark8 wrote:

>> So? Welcome to the real world.
>> PATH is an environment _variable_
>> that is ok to add stuff to.
> 
> I'm not saying it's not ok to add stuff to it; I'm saying making your
> system dependent upon it is, in a word, stupid.

becasue ?


> 
> Really?
> What has file-centric and "distributed among tools" setups brought about
> (a) in terms of configuration complexity? 
I do not know
And I do not see the relevance

>(b) In terms of organization complexity/dependence? 
I do not know
And I do not see the relevance

And (c) in terms of consistency complexity?
I do not know
And I do not see the relevance

> (A) How many different "small tools" have their own configuration which
> directly impacts another tool and that other tool doesn't know about the
> first?

I do not know
And I do not see the relevance here either.

> (B) Consider how many libraries need to be installed in a certain place
> to get them to work right/easily.
> (C) Have you /EVER/ linked to the wrong object because it became out of
> date?

No. Unheard of. Did not think it was possible.


> 
> At what cost?
> If things are in a database you can get consistency-checking essentially
> for free! You can design the system so that you *NEVER* compiler
> "against the wrong object". 

How do you do for accomplish linking out-of-date objects ?
You seem really hung up on this, so I interpret it as it happens often.
Does it?

>You can make it so that you *NEVER* pull an
> 'oopsie' with a simple textual search-and-replace rename.

So why would a db-based ide be better on this thatn a file based?

> Moreover, if stored in a database things like version-control can be
> made more useful by storing only the semantically meaningful changes.
> Things like "formatting style" become absolutely meaningless because,
> guess what, the textual-representation gets reconstructed and
> redisplayed as-needed... and that can be fully customizable to the
> particular user w/o impacting anyone else.

And that would make you be the most impopular man,
if our company set the standard for that.
People get _really_ upset if you tamper with a 15-year old comment.
Or changeing case on variables.
Automatic re-writes is a nono. (a bit conservative. I know)


> Seriously, that "the industry" remains fixated on _text_ as the de facto
> medium for storing/maintaining/manipulating programs is disgusting! --

Very much seems disgusting to you...

> It's like a firearm manufacturer that refuses to use firearms in favor
> of bows because "it's simpler".

It would be simpler to deny weapons at all ...

> 
> Hell, if *"because it's simpler"* is a valid reason to embrace
> something, might I suggest you look into PHP, after all its
> implementation (and usage) is "much simpler" than Ada or most any
> compiled language.

No. I like thing s to be simple AND safe. PHP does not match safe.
I also like the KISS principle. Less errors because of
overly complex configuration. I like it simple so I do not need to
explain stuff for my colleagues. I compile stuff with -O0 and -g
to get good stack-traces when needed. To catch errors, and understand
them as soon as possible, so a fix can be provided.

Yes, i like simple stuff, because they break more seldom.
But don't confuse simple with bad.


And I also like to auto-generate objects from xml-files that wraps
access to database-tables. Output is Ada-files.
Print to standard_output and redirect to file.
Simple. Works. Not needed to fiddle with API to access your IDE-DB
or whatever you can provide. If you provide other input means than your IDE.


>> Lets us kill all text-editors and
>> only use _your_ soon-to-come-any-decade fantastic
>> super duper editor
> 
> Who said anything about killing text editors?
> Of course it'd need a way to display/manipulate the program, and of
> course it'd need to be able to import/export plain-text.

ok - rephrase to 'lets kill all editors that saves to file'

> 
> But the fact still remains: the text-based/file-based model is
> inherently worse because it pushes automatable and verifiable checking
> directly into the user's lap.
> 

Things your coming IDE can catch by saving to DB, it could also catch
when save to file.
Consider the file system your db.


--
Björn

Re: GNAT GPL is not shareware

[Shark8]

On 06-Jan-15 14:15, Björn Lundin wrote:
> Consider the file system your db.

But *this* is the problem -- a DB is more than just a storage unit, it 
can enforce consistency!

>  Things your coming IDE can catch by saving to DB, it could also catch
> when save to file.

And things the file-system *can't* catch could be caught by a db.

Ex:
Example.Parent.Child.adb is in your file-system (along with its 
ancestors), it exists in your project and is used therein.

Now "del Example.Parent.ad?" removes the ancestor "parent", is your 
project still valid?

No, because it still contains [and relies upon] "Example.Parent.Child" 
which has had its own dependencies removed.

> How do you do for accomplish linking out-of-date objects ?
> You seem really hung up on this, so I interpret it as it happens often.
> Does it?

I've only had it happen a couple times.
That it can happen at all, when it is preventable, is the issue.

>> Moreover, if stored in a database things like version-control can be
>> made more useful by storing only the semantically meaningful changes.
>> Things like "formatting style" become absolutely meaningless because,
>> guess what, the textual-representation gets reconstructed and
>> redisplayed as-needed... and that can be fully customizable to the
>> particular user w/o impacting anyone else.
>
> And that would make you be the most impopular man,
> if our company set the standard for that.
> People get _really_ upset if you tamper with a 15-year old comment.
> Or changeing case on variables.
> Automatic re-writes is a nono. (a bit conservative. I know)

*sigh* -- You completely miss the point. You're storing it [the program] 
not as text, but as a meaningful structure (think AST w/ extra info 
[like, say, static-analysis]). When you re-constitute the "program text" 
for editing the display-unit/editor can [easily] put it together in the 
"company set standard" (or the user's preferred standard)... IOW, the 
textual formatting simply doesn't matter anymore.

To illustrate, consider the following:
  Type X is (
   Apple,
   Orange,
   Grape
   );
  For X'Size use 8;
Is this semantically different from the following:
  Type X is (Apple,Orange,Grape) with Size => 8;

If there is no semantic difference, then does it matter which text is 
displayed, other than personal preference?

I don't see why it should; why do you?

Re: GNAT GPL is not shareware

[Hubert]

I should maybe say that I am one of these people who are looking into 
Ada. The reason is that I realize that the language has much more to 
offer than C++ and it seems programs are more stable due to the lack of 
pointer juggling.
However, I am reluctant to commit more than some spare time to it and 
writing more than some stand alone tools because from my point it has an 
uncertain future.
Should Adacore ever break down then there would be no more development 
that's worth mentioning. Of course there is still a big userbase in 
Aviation and Space industry but I read that there are movements away 
from Ada so that is not encouraging either.

And I guess many people in my situation feel the same. They look at Ada 
and say, well it looks good in theory but what are the long term chances 
for it. Realistically, as a programmer, you have to focus on one 
language. It is hard enough for me to stay ontop of C++ and I can't say 
that I know more than 75% of the language, even though I make a living 
working with it.
Today's languages are horribly complex. Which is a reason that I decided 
for my Ada experiment that I would stay away from OOP because when I 
read questions about Ada that just make my head smoke and think: how can 
any human being understand that problem really, then it is always about 
OOP. OOP is an abomination in my mind, but that's an entirely different 
subject.

I am afraid, unless there is an Ada solution that would make small 
companies feel secure when they commit a significant amount of time and 
money, they will never do that. Simply because it's an either or 
situation with Adacore.

And yes, you can use the FSF version, but like I said earlier, if 
everybody did that, how would Adacore make money and continue to support 
the compiler? If I use a compiler, I want to make sure the company I buy 
it from will be there in 10 years and in my mind I do that by paying 
them money.

Unless more people try out Ada, there will be no growth in the userbase. 
But it's an emotional thing as well, like I said. I want to feel secure 
about the company who's tools I use.

I really wish Adacore would offer a license for small businesses that 
was more affordable. I think that would lure more people in than a 
completely free version.





---
This email has been checked for viruses by Avast antivirus software.
http://www.avast.com

Re: GNAT GPL is not shareware

[Georg Bauhaus]

On 06.01.15 22:15, Björn Lundin wrote:
>> (A) How many different "small tools" have their own configuration which
>> >directly impacts another tool and that other tool doesn't know about the
>> >first?
> I do not know
> And I do not see the relevance here either.
>

Assume there is a standard way of describing the graph
of dependence of a software product to be.

Then, no matter which compiler you choose, no matter which
operating system you use for development, the standards based
development environment is going to do the right
thing when selecting units and dependencies.

Because the compiler performs the selections in terms of the
standard description.

There is no standard description of the net of dependence
for Ada programs. Whether that standard would rely on text or
on a database or whatever for its implementation is a secondary
concern, I think.

I'd expect vendors to tell tales about APSE failure, about flexibility,
about operating systems, about licensing, about the HALTing problem etc.
So each finds a reason to provide their own configuration language…

What's the situation with other languages?

Eiffel has a configuration language as part of the
language definition.  Other languages have developed highly
specialized solutions. They are complex to configure, although fairly
easy to "run" after some initial training. In fact, in the labor market,
job descriptions will typically mention these tools as a qualification.

The qualifications such as knowing Maven, knowing bower,
knowing VS 9, knowing DevOps topics, knowing Eclipse (not Netbeans),
known the umpteenth framework, typically is of no lasting
value for most programmers, because "The Market" makes
most of these specializations in software configuration worthless.
They are replaced every now and then with something different.
Maintenance jobs are fewer.

Learning programming languages is relatively easy in comparison to
memorizing yet another configuration language … a "necessary" evil,
like also memorizing yet another markup language is … another "necessary"
evil.

Industry does not value standards for configuration and frameworks,
since vendors, consultants, and publishers have successfully done a lot
to lure industry into standards avoidance there.

Re: GNAT GPL is not shareware

[Pascal Obry]

Le mardi 06 janvier 2015 à 17:59 -0800, Hubert a écrit : 
> I should maybe say that I am one of these people who are looking into 
> Ada. The reason is that I realize that the language has much more to 
> offer than C++ and it seems programs are more stable due to the lack of 
> pointer juggling.
> However, I am reluctant to commit more than some spare time to it and 
> writing more than some stand alone tools because from my point it has an 
> uncertain future.

This is just plain wrong. How can Ada have an uncertain future where all
the most challenged projects in the world are using it more and more and
there is two Open Source compilers, one GPL from AdaCore and non GPL
from FSF integrated into the GCC project.

-- 
  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: GNAT GPL is not shareware

[Mark Carroll]

Pascal Obry <pascal@obry.net> writes:

> Le mardi 06 janvier 2015 à 17:59 -0800, Hubert a écrit : 
>> I should maybe say that I am one of these people who are looking into 
>> Ada. The reason is that I realize that the language has much more to 
>> offer than C++ and it seems programs are more stable due to the lack of 
>> pointer juggling.
>> However, I am reluctant to commit more than some spare time to it and 
>> writing more than some stand alone tools because from my point it has an 
>> uncertain future.
>
> This is just plain wrong. How can Ada have an uncertain future where all
> the most challenged projects in the world are using it more and more and
> there is two Open Source compilers, one GPL from AdaCore and non GPL
> from FSF integrated into the GCC project.

I suppose it depends to what extent AdaCore is a single point of
failure. Does the FSF version get much active development that isn't
hand-me-downs of AdaCore's paid work? I don't mind relying on a free
compiler if there's an associated development community already working
on it directly, as with other languages like Haskell where commercial
companies still have the option of privately contracting with
consultants who otherwise work on the free compiler anyway.

-- Mark

Re: GNAT GPL is not shareware

[Pascal Obry]

Le mercredi 07 janvier 2015 à 10:17 +0000, Mark Carroll a écrit : 
> I suppose it depends to what extent AdaCore is a single point of
> failure. Does the FSF version get much active development that isn't
> hand-me-downs of AdaCore's paid work? I don't mind relying on a free
> compiler 

It's not free it is Open Source. This is for me far better than just
free as in freeware for example where from a day to another the product
can disappear because the company as decided so.

Of course nothing is there forever. But to me an Open Source piece of
software has far more chance to live longer.

> if there's an associated development community already working
> on it directly, 

I bet that if a strong needs if felt the community will be there to work
on this. 

-- 
  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: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-06 22:46, Shark8 wrote:
> On 06-Jan-15 14:15, Björn Lundin wrote:
>> Consider the file system your db.
> 
> But *this* is the problem -- a DB is more than just a storage unit, it
> can enforce consistency!
> 
>>  Things your coming IDE can catch by saving to DB, it could also catch
>> when save to file.
> 
> And things the file-system *can't* catch could be caught by a db.
> 
> Ex:
> Example.Parent.Child.adb is in your file-system (along with its
> ancestors), it exists in your project and is used therein.
> 
> Now "del Example.Parent.ad?" removes the ancestor "parent", is your
> project still valid?
> 
> No, because it still contains [and relies upon] "Example.Parent.Child"
> which has had its own dependencies removed.

So ? How would a db solution stop that?

"delete from sources where name like 'Example.Parent%'"
would have the same effect.

however, in a filesystem (with say svn) I could

svn stat - to see that  Example.Parent.ad? is missing
svn revert  Example.Parent.ad?

and I would have restored it.

> 
>> How do you do for accomplish linking out-of-date objects ?
>> You seem really hung up on this, so I interpret it as it happens often.
>> Does it?
> 
> I've only had it happen a couple times.
> That it can happen at all, when it is preventable, is the issue.

and exactly _how_ is this more preventable with a db solution?


> 
> *sigh* -- You completely miss the point. You're storing it [the program]
> not as text, but as a meaningful structure (think AST w/ extra info
> [like, say, static-analysis]). 

I do get your point, but I do not find it so fantastic a you do.


> IOW, the
> textual formatting simply doesn't matter anymore.

For the source code - yes. for the user - no.
Modification date of a file tells me stuff.
like when was it last fiddled with. In an EASY way.


> 
> To illustrate, consider the following:
>  Type X is (
>   Apple,
>   Orange,
>   Grape
>   );
>  For X'Size use 8;
> Is this semantically different from the following:
>  Type X is (Apple,Orange,Grape) with Size => 8;
> 
> If there is no semantic difference, then does it matter which text is
> displayed, other than personal preference?

no, but YOU don't get the point.
Files are more that holder of text. They carry some
meta-info. Sure the kind and amount could be better.


And I still do not see why changing PATH to point to different
compiler installations are considered DISGUSTING


-- 
--
Björn

Re: GNAT GPL is not shareware

[sbelmont700]

On Wednesday, January 7, 2015 6:00:48 AM UTC-5, björn lundin wrote:
> 
> And I still do not see why changing PATH to point to different
> compiler installations are considered DISGUSTING

Because you can't version control an environment variable.  A major part of change management is to ensure that the same product is built the same way, with the same compiler, each and every time, e.g. if your development plan says you are going to use GNAT-FSF, then you should be unable (or at least have it be extraordinary hard) to compile it with GNAT-GPL (or any other compiler).  With the PATH option, Joe might get a different executable than Bob.  Or even more dire, if Steve the admin installs a new compiler version or changes the directory structure, suddenly Joe and Bob silently start using a different compiler and nobody notices until it's too late.  Now add in that Joe and Bob might each be working on multiple projects that require different versions of different compilers, and you'll never contain the mess.  Solutions like gprbuild (i.e. the .cgpr file, that you can check into the tree) offer much more consistency.

-sb

Re: GNAT GPL is not shareware

[David Botton]

> Of course nothing is there forever. But to me an Open Source piece of
> software has far more chance to live longer.

I agree 100% end of the day a 1 company approach is irrelevant when the product is available as open source. Many companies "invest" in AdaCore for new development work to the compiler or have maintenance contracts because is is open source and their support and maintenance dollars are protected long term by it being libre software.
 
> I bet that if a strong needs if felt the community will be there to work
> on this. 

I also agree, the quality of AdaCore's work and frequency of it has generally not made it a "need". However there is already much work in the community on the compiler, but most has just been on creating FSF gcc/ada executables since that has been where any "need" has lied.

David Botton

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-07 13:23, sbelmont700@gmail.com wrote:
> On Wednesday, January 7, 2015 6:00:48 AM UTC-5, björn lundin wrote:
>>
>> And I still do not see why changing PATH to point to different
>> compiler installations are considered DISGUSTING
> 
> Because you can't version control an environment variable.  

You must be joking ?
I maintain a somewhat largish system.
The Standard R&D version is checked out as a working copy.
So is 12 other projects tailor made for different customers based on
different version of the standard mentioned above.
Within each system, a file exists that sets different environ variables
PATH included. Each system points to the compiler the customers
has at site.

to start work, pick your project from a menu (generated from this file)
and all vital environ variables including PATH are set.

And that file, as the rest of the system is version controlled.

Don't project your ignorance on everybody else.


>A major part of change management

Do you really think that Change Management was something
the OP had in mind?
He tried to get another gnat to works with gps. That is it.

>is to ensure that the same product is built the same way, 
>with the same compiler, each and every time, e.g. if your development plan 
>says you are going to use GNAT-FSF, then you should be unable 
>(or at least have it be extraordinary hard) to compile it with GNAT-GPL 
>(or any other compiler).  With the PATH option, Joe might get a
different executable than Bob.
>Or even more dire, if Steve the admin installs a new compiler version or
>changes the directory structure, suddenly Joe and Bob silently 

Not very silently. each compiler will recompile the stuff it did not
compile itself. It will also state its version with EACH re-compiled
file. If you do not notice that, well then it is strange.

>start using a 
>different compiler and nobody notices until it's too late.  

get real.

>Now add in that Joe and Bob might each be working on multiple projects 
>that require different versions of different compilers, 
>and you'll never contain the mess. 

Yes you will. See above

And we are not just Sandy, Bob and Joe.

We are 50+ people in four different countries using this.
Commercially. Successfully.

> Solutions like gprbuild (i.e. the .cgpr file, that you can check into the tree) offer much more consistency.
Yeah, I forget .cgpr is the ONLY file type that can be version handled...

--
Björn

Re: GNAT GPL is not shareware

[Thomas Løcke]

On 01/07/2015 01:23 PM, sbelmont700@gmail.com wrote:
> Because you can't version control an environment variable.

You can easily version control environment variables, if you just keep
them local to your makefile / commands.

You don't have to change your PATH systemwide to do a simple build.

PATH=/path/to/special/gnat gnatmake stuff

Put that in your makefile, and you now have a version controlled PATH.

If you're worried about compiler versions, simply check for that in the
makefile and break out if there's a version mismatch. This is exactly
what proper build scripts are for. If Bob screws up then he will be
notified and it's then up to him to fix his own system. Create a
makefile.conf and have something like GNATMAKE_VERSION=4.8.2 and check
for that.

And just to be clear: I'm not advocating against gprbuild or gpr files,
I'm merely pointing out that a well-written makefile would solve Joe
and Bob's PATH/compiler woes. :o)

-- 
Thomas Løcke

Re: GNAT GPL is not shareware

[sbelmont700]

All that's true, but in those cases you are no longer just "relying on the PATH variable" anymore; you are relying on a big, consistent, safe and verified build system that performs all the requisite checks to ensure the PATH variable is correct.  At that point, you've essentially just engineered yourself a home-brew gprbuild tool, which is as effective as any other.  The problem is when people merely expect to type "gnatmake -P project.gpr" and expect consistent results based on whatever happens to be in the PATH at the time.

-sb

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-07 14:46, sbelmont700@gmail.com wrote:
> 
> All that's true, but in those cases you are no longer just "relying on the PATH variable" anymore;
> you are relying on a big, consistent, safe and verified build system that 
>performs all the requisite checks to ensure the PATH variable is correct.  
>At that point, you've essentially just engineered yourself a home-brew gprbuild tool, 

Yes, this has a 10 year+ history - before gprbuild.


>which is as effective as any other.  The problem is when people merely expect to type 
>"gnatmake -P project.gpr" and expect consistent results based on whatever
> happens to be in the PATH at the time.
> 

Still, I do not see why the change of PATH is DISGUSTING.
Especially not for the case of the OP.

And as Thomas Löcke pointed out, it does not
have to be a 'big, consistent, safe and verified build system'
It is enough that set the path locally in a make file.

I do not see that as DISGUSTING either.


Enough time wasted for me here.

--
Björn

Re: GNAT GPL is not shareware

[Dirk Heinrichs]

Pascal Obry wrote:

> It's not free it is Open Source.

That depends on the definition of "free". For the FSF, free always means 
free as in "freedom" or in "free speech", NOT as in "free beer" (free of 
charge).

For software to be free software, in the FSF sense, it MUST also be Open 
Source, while the opposite might not always be true.

See also: http://www.gnu.org/philosophy/free-sw.en.html

> This is for me far better than just
> free as in freeware for example where from a day to another the product
> can disappear because the company as decided so.

ACK. Seen to much good pieces of software disappear just because some 
company was un(able|willing) to continue its development.

> Of course nothing is there forever. But to me an Open Source piece of
> software has far more chance to live longer.

ACK (with s/Open Source/Free Software/).

Bye...

	Dirk
-- 
Dirk Heinrichs <dirk.heinrichs@altum.de>
Tel: +49 (0)2471 209385 | Mobil: +49 (0)176 34473913
GPG Public Key CB614542 | Jabber: dirk.heinrichs@altum.de
Tox: heini@toxme.se
Sichere Internetkommunikation: http://www.retroshare.org
Privacy Handbuch: https://www.privacy-handbuch.de

Re: GNAT GPL is not shareware

[Shark8]

On 07-Jan-15 04:00, Björn Lundin wrote:
> On 2015-01-06 22:46, Shark8 wrote:
>>
>> No, because it still contains [and relies upon] "Example.Parent.Child"
>> which has had its own dependencies removed.
>
> So ? How would a db solution stop that?
>
> "delete from sources where name like 'Example.Parent%'"
> would have the same effect.

Why would you have the fully-qualified name stored as text?
It makes far more sense to break the name into an actual structure 
itself, in order to show its "lineage"; and once you do that your 
example simply doesn't work.

Again, you're showing that you're thinking of everything in terms of 
text, not in terms of meaningful structure.

> however, in a filesystem (with say svn) I could
>
> svn stat - to see that  Example.Parent.ad? is missing
> svn revert  Example.Parent.ad?
>
> and I would have restored it.

Showing that you could easily recover from accidentally entering an 
inconsistent state is *not* the same as preventing the state-change to 
inconsistency in the first place. -- Here is an example of early 
development using databases as a form of both version-control and 
project-management: 
https://drive.google.com/file/d/0BwQVNNshW39cTXVOdWxQaVJ5WjA/edit

>>> How do you do for accomplish linking out-of-date objects ?
>>> You seem really hung up on this, so I interpret it as it happens often.
>>> Does it?
>>
>> I've only had it happen a couple times.
>> That it can happen at all, when it is preventable, is the issue.
>
> and exactly _how_ is this more preventable with a db solution?

Because with a DB-system you can guarantee that the "system" is not 
inconsistent or out-of date; and you can associate generated objects 
with exactly the state that generates them.

>> *sigh* -- You completely miss the point. You're storing it [the program]
>> not as text, but as a meaningful structure (think AST w/ extra info
>> [like, say, static-analysis]).
>
> I do get your point, but I do not find it so fantastic a you do.

Your example of treating the name of the compilation unit as if it were 
only text proves a counter-example to your claim of understanding my point.

>> IOW, the
>> textual formatting simply doesn't matter anymore.
>
> For the source code - yes. for the user - no.
> Modification date of a file tells me stuff.
> like when was it last fiddled with. In an EASY way.

*shrug* -- I'm not saying that every conceivable operation could [or 
even should] be as easy in a DB-based system. I see no reason, though, 
why such "last modified on"/"last modified by" meta-data could not be 
stored in a database... and, indeed, several do have a system like this, 
generating an audit-trail automatically.

>> To illustrate, consider the following:
>>   Type X is (
>>    Apple,
>>    Orange,
>>    Grape
>>    );
>>   For X'Size use 8;
>> Is this semantically different from the following:
>>   Type X is (Apple,Orange,Grape) with Size => 8;
>>
>> If there is no semantic difference, then does it matter which text is
>> displayed, other than personal preference?
>
> no, but YOU don't get the point.
> Files are more that holder of text. They carry some
> meta-info. Sure the kind and amount could be better.

And more, better meta-info can be held in a database-system.

> And I still do not see why changing PATH to point to different
> compiler installations are considered DISGUSTING

Because it is changing a fundamental behavior in a completely 
invisible-to-the-build-system manner; as someone pointed out you can use 
make-files to set the path but this is a work-around -- instead of 
"making it a variable of the function" it's "depending on a global 
variable" -- instead of making the build-system analogous to a "pure 
unit", it depends on state.

Re: GNAT GPL is not shareware

[Björn Lundin]

Ok, I need to reply to this rubbish

On 2015-01-07 17:32, Shark8 wrote:
> On 07-Jan-15 04:00, Björn Lundin wrote:
>> On 2015-01-06 22:46, Shark8 wrote:
>>>
>>> No, because it still contains [and relies upon] "Example.Parent.Child"
>>> which has had its own dependencies removed.
>>
>> So ? How would a db solution stop that?
>>
>> "delete from sources where name like 'Example.Parent%'"
>> would have the same effect.
> 
> Why would you have the fully-qualified name stored as text?
> It makes far more sense to break the name into an actual structure
> itself, in order to show its "lineage"; and once you do that your
> example simply doesn't work.

It does not matter HOW you represent it.
A db can be manipulated, get corrupt, just as a file system.


> Again, you're showing that you're thinking of everything in terms of
> text, not in terms of meaningful structure.

No, but since I don't know your model, I
visualized with something simple.



>> however, in a filesystem (with say svn) I could
>>
>> svn stat - to see that  Example.Parent.ad? is missing
>> svn revert  Example.Parent.ad?
>>
>> and I would have restored it.
> 
> Showing that you could easily recover from accidentally entering an
> inconsistent state is *not* the same as preventing the state-change to
> inconsistency in the first place. -- Here is an example of early
> development using databases as a form of both version-control and
> project-management:
> https://drive.google.com/file/d/0BwQVNNshW39cTXVOdWxQaVJ5WjA/edit

I see nothing in there to _prove_ that a code-base cannot be
inconsistent in a db - regardless of the db model. That is your claim.


>>>> How do you do for accomplish linking out-of-date objects ?
>>>> You seem really hung up on this, so I interpret it as it happens often.
>>>> Does it?
>>> I've only had it happen a couple times.
>>> That it can happen at all, when it is preventable, is the issue.

I guess this did not happen with Gnat. See below


>> and exactly _how_ is this more preventable with a db solution?
> Because with a DB-system you can guarantee that the "system" is not
> inconsistent or out-of date; and you can associate generated objects
> with exactly the state that generates them.

Gnat calls that state ali-files...

<http://docs.adacore.com/gnat_ugn-docs/html/gnat_ugn_7.html#SEC84>
That is gnat user guide , chapter 6.5
§4

"The ability of GNAT to compile in any order is critical in allowing an
order of compilation to be chosen that guarantees that gnatmake will
recompute a correct set of new dependencies if necessary. "

Seems to me that ACT already can guarantee this with files.
Yes, they use the word guarantee.

And using gnat since 2002 at work,
I've never even heard of this happening with gnat.

However, I do recall something with ObjectAda 7.2
If changing source files belonging both to a certain
ada-lib AND its parent lib, the source belonging to the parent lib was
not recompiled.
However, this was 10+ years ago, and I only remember i vaguely,
so it might have been something completely different.


>> And I still do not see why changing PATH to point to different
>> compiler installations are considered DISGUSTING
> 
> Because it is changing a fundamental behavior in a completely
> invisible-to-the-build-system manner; 

Yes, fully transparent.
Easy to deploy, easy to reconfigure, easy to understand.
All three reasons are good for maintenance.

> as someone pointed out you can use
> make-files to set the path but this is a work-around -- instead of
> "making it a variable of the function" it's "depending on a global
> variable" -- instead of making the build-system analogous to a "pure
> unit", it depends on state.

So ? The state is controlled.
You are building vapor-ware.

--
Björn

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-07 17:32, Shark8 wrote:
>>
>> and exactly _how_ is this more preventable with a db solution?
> 
> Because with a DB-system you can guarantee that the "system" is not
> inconsistent or out-of date; and you can associate generated objects
> with exactly the state that generates them.
> 

see also gnatbind
<http://docs.adacore.com/gnat_ugn-docs/html/gnat_ugn_5.html#SEC63>


"
 The gnatbind program performs four separate functions:

    Checks that a program is consistent, in accordance with the rules in
Chapter 10 of the Ada Reference Manual. In particular, error messages
are generated if a program uses inconsistent versions of a given unit.

"

--
Björn

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-07 18:33, Björn Lundin wrote:
> On 2015-01-07 17:32, Shark8 wrote:
>>>
>>> and exactly _how_ is this more preventable with a db solution?
>>
>> Because with a DB-system you can guarantee that the "system" is not
>> inconsistent or out-of date; and you can associate generated objects
>> with exactly the state that generates them.
>>
> 
> see also gnatbind
> <http://docs.adacore.com/gnat_ugn-docs/html/gnat_ugn_5.html#SEC63>
> 
> 
> "
>  The gnatbind program performs four separate functions:
> 
>     Checks that a program is consistent, in accordance with the rules in
> Chapter 10 of the Ada Reference Manual. In particular, error messages
> are generated if a program uses inconsistent versions of a given unit.
> 
> "

reading further, we get to the section 4.1
<http://docs.adacore.com/gnat_ugn-docs/html/gnat_ugn_5.html#SEC64>

that states

<quote>
The effect of this consistency checking, which includes source files, is
that the binder ensures that the program is consistent with the latest
version of the source files that can be located at bind time. Editing a
source file without compiling files that depend on the source file cause
error messages to be generated by the binder.

For example, suppose you have a main program `hello.adb' and a package
P, from file `p.ads' and you perform the following steps:

    Enter gcc -c hello.adb to compile the main program.

    Enter gcc -c p.ads to compile package P.

    Edit file `p.ads'.

    Enter gnatbind hello.

At this point, the file `p.ali' contains an out-of-date time stamp
because the file `p.ads' has been edited. The attempt at binding fails,
and the binder generates the following error messages:

 	

error: "hello.adb" must be recompiled ("p.ads" has been modified)
error: "p.ads" has been modified and must be recompiled

Now both files must be recompiled as indicated, and then the bind can
succeed, generating a main program.
</quote>


As I said, never heard of linking the wrong object file with gnat

--
Björn

Re: GNAT GPL is not shareware

[Shark8]

>> Why would you have the fully-qualified name stored as text?
>> It makes far more sense to break the name into an actual structure
>> itself, in order to show its "lineage"; and once you do that your
>> example simply doesn't work.
>
> It does not matter HOW you represent it.
> A db can be manipulated, get corrupt, just as a file system.

I never said that a database couldn't "go bad" -- but how easy is it to 
back up a single [proper] DB? Unless it's got its own FS, it's just as 
easy as SVN on the source directory, or zipping the dir-structure, or 
whatever your backup of text-files is.

>> Again, you're showing that you're thinking of everything in terms of
>> text, not in terms of meaningful structure.
>
> No, but since I don't know your model, I
> visualized with something simple.

If we're talking about storing a structured meaningful program as a 
meaningful structure, what sense would it make to store the 
fully-qualified name (something rife with meaningful structure) without 
regard to that structure?

>> Showing that you could easily recover from accidentally entering an
>> inconsistent state is *not* the same as preventing the state-change to
>> inconsistency in the first place. -- Here is an example of early
>> development using databases as a form of both version-control and
>> project-management:
>> https://drive.google.com/file/d/0BwQVNNshW39cTXVOdWxQaVJ5WjA/edit
>
> I see nothing in there to _prove_ that a code-base cannot be
> inconsistent in a db - regardless of the db model. That is your claim.

I never said it would be independent of the DB model. Proper modeling of 
the structure would obviously be required -- there's almost zero 
advantage of a DB whose schema is (ID, compilation_unit_name, 
compilation_unit_text)... the only advantage there is that by using the 
DB you create the possibility of using less physical-space on-disk than 
you would using the FS. *Especially* if the block-size for files is much 
larger than the modulo-X size of the source.

> I guess this did not happen with Gnat. See below

No, it was with either a GCC or G++ that I had to use at the time. 
(Remember; we're talking about handling programming in-general -- not 
Ada specifically and not GNAT in particular.)

>>> and exactly _how_ is this more preventable with a db solution?
>> Because with a DB-system you can guarantee that the "system" is not
>> inconsistent or out-of date; and you can associate generated objects
>> with exactly the state that generates them.
>
> Gnat calls that state ali-files...
>
> <http://docs.adacore.com/gnat_ugn-docs/html/gnat_ugn_7.html#SEC84>
> That is gnat user guide , chapter 6.5
> §4
>
> "The ability of GNAT to compile in any order is critical in allowing an
> order of compilation to be chosen that guarantees that gnatmake will
> recompute a correct set of new dependencies if necessary. "
>
> Seems to me that ACT already can guarantee this with files.
> Yes, they use the word guarantee.

Because they're essentially augmenting the file-structure with a 
database. -- IOW they're adding more complex work-arounds while 
presenting to you the same "environment" that you've always known 
(text-files)... instead of tailoring the environment to the actual 
problems, they're tailoring their tools to the existing workflow. -- 
This would be like when they were developing the electric train, instead 
of training the engineers on electric-trains making the UI the same as 
the Steam locomotive. (Imperfect analogy/word-picture, but I think it 
conveys the meaning.)

Actually, no... it would be more like retrofitting a steam-engine so 
that the boilers were electric.

Re: GNAT GPL is not shareware

[Shark8]

On 07-Jan-15 10:28, Björn Lundin wrote:
> You are building vapor-ware.

You know... it's actually been done before.

R1000 Wikipeda entry
  -- http://en.wikipedia.org/wiki/R1000
R1000 page of a danish museum
  -- http://datamuseum.dk/wiki/Rational/R1000s400
Evaluation of the Rational Environment
  -- http://www.sei.cmu.edu/library/abstracts/reports/88tr015.cfm
"Reminiscing about an old computer system"
  -- 
http://www.somethinkodd.com/oddthinking/category/geek/software-development/rat1000/

So given that there's actual hardware, software, and that there were 
actual apparently-professional users I think that "vapor-ware" is an 
ill-fitting name.

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-07 20:24, Shark8 wrote:
> On 07-Jan-15 10:28, Björn Lundin wrote:
>> You are building vapor-ware.
> 
> You know... it's actually been done before.

I meant that YOU are building vapor-ware.
Not that it has not been done before.

You set out to build
* an IDE
* an Ada2012 compiler
* a ticket/issue system (like Redmine/Bugzilla)

and what not in Freepascal and Delphi.

This has been discussed before here on CLA
where compiler writers says it _very_ hard to write a compiler.
Top that with a 'state-of-the-art' IDE AND a ticket system.

Others has stated the
the Pascal/Delphi people will be not too interested in writing
an Ada compiler (wonder why), and Ada people here will
be fairly doubtful in using Pascal.

You will be fairly lonely.

You won't finish it. Or if you do, Ada2035 will be out.

THAT is vapor-ware.


--
Björn

Re: GNAT GPL is not shareware

[Randy Brukardt]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1366 bytes --]

"Björn Lundin" <b.f.lundin@gmail.com> wrote in message 
news:m8jar2$ceu$1@dont-email.me...
> On 2015-01-07 13:23, sbelmont700@gmail.com wrote:
...
>>start using a
>>different compiler and nobody notices until it's too late.
>
> get real.

Right. I can't speak for GNAT, but for Janus/Ada, incompatible compiler 
versions simply can't work together. All of the intermediate files have 
version checks, so you get an instant version mismatch error. That happens 
to me all of the time, because I forgot to run the environment setting batch 
before running a compile or (more likely make). Big whoop.

And your solution to this "just barely a problem" is to create a massive 
whiz-bang program that has no chance of being customizable to the extent 
that I can do with just a few batch files or shell scripts. That's not 
likely to fly; after all GNAT's "source model" of compilation was a reaction 
to the much fancier (and complicated) library management techniques that 
almost all Ada 83 compilers used. I don't think people suddenly want to go 
back and revisit all of that. There is almost no evidence that a 
semantics-based editor would be more usable than text, and it's not like 
people have tried. (There were lots of such systems in the 1980s; I've used 
several and quite honestly, text source is better.)

                                         Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1985 bytes --]


"Shark8" <OneWingedShark@gmail.com> wrote in message 
news:qcdrw.1246475$Y4.224981@fx24.iad...
> On 07-Jan-15 04:00, Björn Lundin wrote:
...
 Because with a DB-system you can guarantee that the "system" is not
> inconsistent or out-of date; and you can associate generated objects with 
> exactly the state that generates them.

I have yet to use *anything* that used a DB that could not have been done 
better without the DB. DBs primary claim to fame is the ability to handle 
lots of independent transactions. That's pretty much irrelevant for 
compiler/IDE tasks (the number of transactions is very low: on the order of 
a handful per minute).

For all other purposes, DBs are overkill or worse. They just lock one into a 
very heavyweight tool when something much lighter weight would do. And worse 
still, a single version of that tool.

...
>> And I still do not see why changing PATH to point to different
>> compiler installations are considered DISGUSTING
>
> Because it is changing a fundamental behavior in a completely 
> invisible-to-the-build-system manner; as someone pointed out you can use 
> make-files to set the path but this is a work-around -- instead of "making 
> it a variable of the function" it's "depending on a global variable" --  
> instead of making the build-system analogous to a "pure unit", it depends 
> on state.

So you want to change it to use some whizbang tool dependent on a complex 
DB? Sounds great, you won't have the path problem because there won't be any 
way at all to run more than one version of the build system. (Every system 
I've ever dealt with "upgrades" files when used with newer versions, they're 
no longer compatible with the older version afterwards. And any other choice 
would be a maintenance nightmare, so I wouldn't even consider a system that 
tried to do otherwise.)

So of course it's a non-problem in your ideal world. But in the real world, 
you've just made it worse.

                              Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Shark8" <OneWingedShark@gmail.com> wrote in message 
news:1rfrw.561039$ZT5.125723@fx07.iad...
...
>> I guess this did not happen with Gnat. See below
>
> No, it was with either a GCC or G++ that I had to use at the time. 
> (Remember; we're talking about handling programming in-general -- not Ada 
> specifically and not GNAT in particular.)

But we *are* only talking about Ada (or a very small set of languages). The 
odds of being able to build the thing you describe for all programming 
languages is non-existent, even for an amazingly deep-pocketed company. 
You'd have to build the equivalent of a (simple) compiler for each language 
in order to extract semantic information. That could only happen for the 
most popular languages -- it could never be very general.

Moreover, if you are talking about getting people to use a whiz-bang unified 
tool instead of whatever they do now -- no chance. Remember that Ada already 
does the sorts of version checks that you are worrying about. So one could 
argue that such a whiz-bang system already exists. And we know how well 
getting people to use that has been.

You might say "it's not practical for everyone to program only in Ada". 
Perhaps, but you'll quickly find that the same holds true for *any* system 
that is supposed to do everything. No system can do everything, and the 
problem occurs when you have to go outside of it. So that suggests to me 
that it would be most practical to just get people to do more in Ada -- and 
that already exists.

                           Randy.

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-07 23:47, Randy Brukardt wrote:
> "Shark8" <OneWingedShark@gmail.com> wrote in message 
> news:qcdrw.1246475$Y4.224981@fx24.iad...
>> On 07-Jan-15 04:00, Björn Lundin wrote:

Just for the record. I did NOT write this.
Shark8 did.


> ...
>  Because with a DB-system you can guarantee that the "system" is not
>> inconsistent or out-of date; and you can associate generated objects with 
>> exactly the state that generates them.
> 

--
Björn

Re: GNAT GPL is not shareware

[Randy Brukardt]

"David Botton" <david@botton.com> wrote in message 
news:1337ca4c-a19e-468e-bc07-5412438f662b@googlegroups.com...
>> That's not really fair. Both Atego (with ObjectAda) and RRS (with 
>> Janus/Ada)
>> tried to market low-cost compilers for the mass market, but neither made
>> money.
>
>You missed my point, which was fair. There is _no_ low-cost compiler 
>market. That bottomed
>out already before OA and RRS started to market their products to a 
>non-existing market.
>That market is not going to materialize again ever either.

RRS started low-cost compilers in 1984, long before GNAT existed. But 
whatever.

But if there is no market, then there is no point in making a compiler at 
all, because giving it away will not pay the bills.

Outreach in the form of demos, GPL versions, etc is cool, but not if it 
cannablizes your main revenue stream (whatever that is).

So I'm not quite sure what your point was. Which is probably why I missed 
it. :-)

...
>> Which makes it problematical, as some sort of support is required (at a
>> minimum, packaging and fixing of packaging, which can take an amazing 
>> amount
>> of time).
>
>A long time ago, people realized that open source changed where the dollars 
>are in software.

No, open source eliminated all of the dollars from software. There are 
dollars in support of various sorts, some dollars from people who don't know 
better, and some dollars from mega-corps building dedicated systems, and 
that's about it. And all of those things require people skills that many 
software developers don't have and can't realistically acquire (I suspect 
that many developers are borderline autistic).

But people that have those sorts of skills have many opportunities better 
than software. So it's hard to imagine who will be filling these jobs. And 
the people who traditionally have built software are unemployed or 
underemployed. (Of course, most jobs will be automated in the coming years, 
so that is going to be a growing problem for society to deal with.)

> The vendors that can't see beyond compiler sales haven't survived (per se) 
> and those
> in large support contracts are floating, but not swimming if that is their 
> only real product.

There's little of value beyond software sales (and I don't consider 
"maintenance contracts" a-la AdaCore any different than sales). Most 
remaining jobs are glorified marketing jobs that society would be better off 
without. Even cloud-based stuff is just a vessel for marketers, criminals, 
and governments to invade your privacy and steal your money (I'll let you 
figure out which are doing what ;-).

I'm sure it's possible to make money from software, because it's possible 
for con men to make money from nothing, but whether its possible to make 
money and retain one's ethics is highly dubious.

                                                      Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Hubert" <herrdoktor@fumanchu.com> wrote in message 
news:pq0rw.976861$JH1.101473@fx08.iad...
...
> I really wish Adacore would offer a license for small businesses that was 
> more affordable. I think that would lure more people in than a completely 
> free version.

People have been asking AdaCore that since the beginning of GNAT, and they 
have said that it doesn't make econonmic sense. The experience of 
Aonix/ObjectAda and RRS/Janus/Ada also suggest that. Plus, there was such a 
version of GNAT in the late 1990s (I think) created by a third-party 
company, and it didn't work, either.

I have to agree with David that there is no low-cost compiler market 
anymore. The only market (apparently) is for high-quality support, and that 
by its nature is very expensive (because its manpower-dependent).

Even a small business license would need some sort of support and guarantees 
(else why pay for it?), and it's hard to make that come out. RRS has always 
lost money on its support contracts (they really should cost 5 times as much 
as they do). But are small businesses going to fork over $2000 per year?

                                                      Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 677 bytes --]

"Björn Lundin" <b.f.lundin@gmail.com> wrote in message 
news:m8kdu9$a9k$1@dont-email.me...
> On 2015-01-07 23:47, Randy Brukardt wrote:
>> "Shark8" <OneWingedShark@gmail.com> wrote in message
>> news:qcdrw.1246475$Y4.224981@fx24.iad...
>>> On 07-Jan-15 04:00, Björn Lundin wrote:
>
> Just for the record. I did NOT write this.
> Shark8 did.
>
>
>> ...
>>  Because with a DB-system you can guarantee that the "system" is not
>>> inconsistent or out-of date; and you can associate generated objects 
>>> with
>>> exactly the state that generates them.

Sorry. I lost track of who said what, especially when I got a bit worked up 
about it... :-)

                      Randy.

Re: GNAT GPL is not shareware

[David Botton]

> RRS started low-cost compilers in 1984, long before GNAT existed. But 
> whatever.

And then the entire small compiler market for Ada was tiny, and microscopic compared to markets for Turbo Pascal or Turbo C++, in fact Turbo Prolog (I liked that) was probably larger a 1000 fold.

Many companies did excellent in the low-cost compiler market in those days. None of those companies exists per se now. (Borland for example, whose catalog is still dragged along for old customers even with some enhancements)

> But if there is no market, then there is no point in making a compiler at 
> all, because giving it away will not pay the bills.

Correct. That has been the case now for a long time.

Like most things these days you need alternative models for monetizing your creative ideas since the old ones are used up, that is part of progress.
 
> Outreach in the form of demos, GPL versions, etc is cool, but not if it 
> cannablizes your main revenue stream (whatever that is).

In a world of libre software if giving it away would cannibalizes your business then you have no real business model, fools will do things to slow the bleeding like shareware... smart companies understand the code today is not the product and can not be the product, it is just a means to the end.

Support is one revenue stream but there are many others one can tap in to in any market. In general every market today needs to be creative to generate revenues.

Examples beyond compilers:

Evernote - 30% of its monthly sales was in _physical goods_ in Dec 2013, 3 months after launch. I don't have recent numbers but I suspect far more now.

I make a large part of my medical clinic revenue from alternative revenue streams. 40% of the people that come to me for medical assistance can not afford it or if their insurance not paying for the services there is a mental barrier to out of pocket for care even when needed. So I discount or offer my medical services for free and make up overall with other services and products they are willing to pay for and/or can afford. (Another example of my win win approach to business and proof it always works, and closer to the idea of OpenSource)

I built a school over the last few years, also using creative funding methods (All win win situations, those that can't afford have schooling options, etc. etc.) and a few other projects and business all succeeding using creative funding methods. (Each again with win win scenarios for everyone)

There are many ways anyone can succeed when they have the humility to find them and if they try a win win way of doing it are usually blessed with much success.

If even a pompous guy with a blown up head like me can find avenues to success, any one can :)

> So I'm not quite sure what your point was. Which is probably why I missed 
> it. :-)

<< Most of these vendors have the same small minded thinking of only looking at direct sales instead of expanding the user base through mass marketing efforts through free or cheap compiler options.>>

Point was:

There is only doom to vendors that think their products are the compilers.

That it is counter productive to place any stumbling block in the way of Ada use for any purpose since the compiler is not the source of revenue and the larger the base of Ada users in all markets the larger the pool of those that will influence a potential customer to buy the real products vendors offer or could offer.

Here is a recent example of small minded thinking:

https://www.mail-archive.com/gcc-patches@gcc.gnu.org/msg100382.html

Unless the tools needed to build with gpr file are up streamed to the FSF the barrier to a working toolset out of the box got even larger. [I will gladly eat my words and even apologize openly if gprtools and its dependencies xmlada and gnatcoll are up-streamed to the FSF and become part of the regular build of the toolchain] - ya ya someone will write download from libre.. start a new thread if you want to argue about why I am wrong to say it has to be through the FSF, don't hijack this one.

GPL as a weapon rule #2 - You don't have to deliver source that works easily, just something that could work if you knew how.

Rule #1 we all know - infect the outputs with GPL virus to encumber your victim

GPL is a gun (letters spell gnu... hmm) used correctly it brings security to all - everyone can see what's inside, improve on it, etc, in the wrong hands a gun to cripple innovation through "technically correct" uses of the GPL.

> And all of those things require people skills that many 
> software developers don't have and can't realistically acquire (I suspect 
> that many developers are borderline autistic).

And so the rule that the key to success of a business is the team's diversity of skills. The places I do have partners they are rarely like me in any way, but share my passion for whatever the goal of that organization is or has been. I choose my employees, partners, etc. based on their passion for the goal, _before_ even their skills. (Heck you all get to decode my poor grammar and spelling from banging out a post barely proofing it first, and most just accept me for my passion for Ada and forgive it :)

> But people that have those sorts of skills have many opportunities better 
> than software. So it's hard to imagine who will be filling these jobs

If they have people and software skills they tend to do both or bring together teams of people on both sides. If they don't have software skills but just people skills they bring together software teams for common goals.

My experience is that sometimes we don't evaluate where we fit in to things and do not team with the right diversity but instead pick people just like ourselves that will not rock the boat and be "yup" men.

> And the people who traditionally have built software are unemployed or 
> underemployed.

Those that didn't continue expanding their skill sets usually. There are only so many jobs for people that no the ins and the outs of Wangs :) (But I do know someone making a living there too... I wonder what happens when that job is gone for him)

> (Of course, most jobs will be automated in the coming years, 
> so that is going to be a growing problem for society to deal with.)

And those that expand the skill sets in to the new areas that come with it will succeed.

During the Cultural Revolution in China they stupidly killed off most of their greatest treasures, their culture and past to replace it with the new "western" knowledge. Main land China almost completely destroyed their medical knowledge base in the zeal for it. If it wasn't for post revolution efforts to take the remnants and force them to work together to record their knowledge even more would have been lost than already was. They then took the old knowledge applied western and innovations abound.

The past offers gems for the future, so I write "expand" not replace or even add. The idea behind Gnoga for example is to expand Ada to current tech outside the safety critical niche. With that Ada gets more life and those that know it can expand with it. One hand on the past (Ada just like Chinese medicine of the past is just as much also the present) and one hand on the future.

As is I am using borrowed time for Ada, but I wish I had more time. Such a rich past deserves a rich future. I hope others will find some passion this year for some new way to use Ada or new interface to modern tech, etc.

(BTW, having been many times on the hiring boards for large companies or startups, we always grabbed up people with innovative public projects before anyone else, even with tons of degrees, etc., it showed they have initiative, drive, passion, and skill)


> There's little of value beyond software sales

I can assure you there is or the companies making google plex amounts of money giving software away for free wouldn't be making it ;)

> (and I don't consider 
> "maintenance contracts" a-la AdaCore any different than sales).

They are sales, just not direct software sales, but service sales.

Confusion what the product really is, is why things are stagnant beyond the niche and bleeding around it.

> Most remaining jobs are glorified marketing jobs that society would be better off without.

South Florida is flat, no valleys and no mountains (highest point in my county is a small hill at a botanical garden I like to bring the family to), yet there are many jobs available for the right skill sets.

I am hoping that Gnoga will allow Ada programmers the ability to write and sell products for small businesses, the old software pioneering. (Yes is direct sales, but if they are innovative far more ;) I get calls every week asking if I know someone that can write for their company a program that does X, etc. They don't care how just that it is done quick and reasonably priced. So at least for "our guys" there is a win win to come.

> I'm sure it's possible to make money from software, because it's possible 
> for con men to make money from nothing, but whether its possible to make 
> money and retain one's ethics is highly dubious.

There is a beautiful world out there. Most of it is far away from government related projects though :)

In summary of all that hot air:

Expanded_skill_sets + humility + passion + win_win = Success.

David Botton

Re: GNAT GPL is not shareware

[Hubert]

It's a concern when selling the result. Frankly I can't remember the 
last time I was using a Microsoft compiler I paid for. I guess that was 
some years ago when I was still working for a company, I guess they 
bought their licenses. I don't even know what VisualStudio cost these 
days, but I think it's in the range 500-2000$ depending on the version. 
I havent' looked at it closely but I believe they offer their latest 
version for free even? And it is something you can make an applicaiton 
with and sell it.

Now if I would depend on selling software I make that way, I would pay 
2000$ for a compiler, but just once, meaning if there were multiple 
people working on the project, I would use the free version and then pay 
for one license to compile the final result that goes to the customer.

It also depends on the type of service I guess. For instance I am 
working on a tool that I write in Ada now. I will release it as Open 
Source when I'm done so their pro version doesn't concern me. However, I 
was making a change in the package structure yesterday or today that 
made the compiler crash with an invalid access error. Now I suppose if I 
was working on some major project that would be bad and you could pester 
them for a solution, but I changed the program to make the error go 
away, that worked for me. I didn't bother trying to contact them because 
I know they don't provide support for the free version, however there's 
a bug in the compiler and that bug is probably with their paying 
customers as well, so it would have been in their interest to at least 
provide some sort of bug report facility that someone like me could use 
even if there's no help provided.

But yes, I suppose if that's the way it is today, either expensive 
compilers or nothing, than I guess they know best what makes sense for 
them and perhaps for the little guys it means using the FSF version if 
you want to release a closed source program.

It makes no big difference for me, since I am working on a client server 
game. The client will always be in C++ due to the connectin to a 3rd 
party graphics library, which will be the new Unreal SDK once I get rid 
of the crappy engine I'm using now, and which btw sells for 15$ / month 
plus 5% of your gross income if you sell your product. Now that is an 
offer you can't refuse as small developer and it is a more than 
reasonable offer, which is why tons of people are jumping on the new 
engine. Considering that Epic Games is multimillion dollar company who's 
engine is used in AAA titles by the biggest companies in the world, I 
think they outshine Adacore by several factors. If they think there must 
be money in a business model like this, I am sure there is.

But then, maybe Adacore is just too secure with companies like Boeing, 
Airbus, Raytheon on their customer list.


---
This email has been checked for viruses by Avast antivirus software.
http://www.avast.com

Re: GNAT GPL is not shareware

[Hubert]

> I am hoping that Gnoga will allow Ada programmers the ability to write and sell products for small businesses, the old software pioneering. (Yes is direct sales, but if they are innovative far more ;) I get calls every week asking if I know someone that can write for their company a program that does X, etc. They don't care how just that it is done quick and reasonably priced. So at least for "our guys" there is a win win to come.

Actually, isn't Gnoga providing a platform just like what big companies 
like Microsoft are trying to sell? "Cloudbased computing"? Which is 
really just a euphemism for old fashioned client server development just 
on a massive scale?

If so, this would enable a lot of people to provide their software on a 
server as a service for rent, which is what MS want's to do more and 
more because they recognized that it's better to make 20$/month than 
100$ from a one time sale.




---
This email has been checked for viruses by Avast antivirus software.
http://www.avast.com

Re: GNAT GPL is not shareware

[David Botton]

> Actually, isn't Gnoga providing a platform just like what big companies 
> like Microsoft are trying to sell?

Best way to see the Gnoga framework is as a UI toolkit, that if desired the UI can be run remote like a thin client.

David Botton

Re: GNAT GPL is not shareware

[Dmitry A. Kazakov]

On Wed, 7 Jan 2015 16:47:25 -0600, Randy Brukardt wrote:

> I have yet to use *anything* that used a DB that could not have been done 
> better without the DB.

True.

What about parallels between evolution of languages:

   untyped -> weakly typed -> strongly typed -> OO

and persistent storage:

   files -> DB -> nothing -> nothing

Of course neither has any relation to the problem of versioning and
interoperability Shark8 seem to believe in. Except that each new step makes
things greatly more difficult. E.g. interfacing C vs. interfacing C++.

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

Re: GNAT GPL is not shareware

[Simon Wright]

David Botton <david@botton.com> writes:

> Here is a recent example of small minded thinking:
>
> https://www.mail-archive.com/gcc-patches@gcc.gnu.org/msg100382.html
>
> Unless the tools needed to build with gpr file are up streamed to the
> FSF the barrier to a working toolset out of the box got even larger

The reasoning is that gprbuild is much more capable than gnatmake, and
keeping gnatmake up to speed would be hard.

gprbuild is (C) FSF, gnatcoll & xmlada are (C) Adacore. All are GPLv3
with the runtime library exception excised.

It is of course possible to use the GPL gprbuild to invoke an FSF
compiler via a GPR file (I just did!) but that hardly counts as 'out of
the box'.

I will continue to provide gprbuild (somehow!) with my Mac binaries.

Not sure whether the Debian gnat package includes gprbuild?

Re: GNAT GPL is not shareware

[Simon Wright]

Hubert <herrdoktor@fumanchu.com> writes:

> I didn't bother trying to contact them because I know they don't
> provide support for the free version, however there's a bug in the
> compiler and that bug is probably with their paying customers as well,
> so it would have been in their interest to at least provide some sort
> of bug report facility that someone like me could use even if there's
> no help provided.

Mail report@adacore.com with GNAT: at the beginning of the subject
line. Sometimes you get a response; sometimes, even, help.

Re: GNAT GPL is not shareware

[G.B.]

On 08.01.15 09:14, Dmitry A. Kazakov wrote:
> On Wed, 7 Jan 2015 16:47:25 -0600, Randy Brukardt wrote:
>
>> I have yet to use *anything* that used a DB that could not have been done
>> better without the DB.
>
> True.

False, in general:

As soon as you start talking truly relational, you'll either
use Prolog-ish programs, which are DB programs.

Or, in Ada, you'll use pointers or cursors, or symbols in
anything else, and start reinventing everything that the full
relational model provides for free.

Using the GNAT repertoire in the compiler sources,
this question is typical of thinking "relational":

"List all Ada identifiers that are public in packages
  that are children of P0, provided that they are not of
  a pointer type."

A standard RDBMS solution, while obvious, is perhaps
inadequate for reasons of performance, specialization,
Ada fanatism, etc. But it takes a political argument
to deny that compilers do actually include those data
structures and algorithms that the relational model
has as built-ins.

For a worldly, commercial case,
Google's non-SQL hash table based "database" is a major
failure for programs using more than indexed lists, as is
demonstrated by the hugely successful addition of an RDB
option that Google added to the same App Engine.

And yes, SQL isn't perfect, and the type system of the
relational model is much underused. And no, I do not now
think that "relation" necessarily needs any more
representationin the type system than maybe "if".

Thanks to GNAT not being closed source shareware,
we are able to consider the relational question above ;-)

Re: GNAT GPL is not shareware

[G.B.]

On 08.01.15 05:09, Hubert wrote:
> I havent' looked at it closely but I believe they offer their latest
> version for free even? And it is something you can make an applicaiton
> with and sell it.

This is misleading, as Microsoft's cost-free versions
of their software would not allow selling some Microsoft
style applications made using them. "Non-enterprise" and
"individual developer" are terms Microsoft uses in their
licensing white paper.

The existence of a white paper about licensing should
be a hint in itself.

Re: gnatmake to lose support for project files, gprbuild instead

[Ludovic Brenta]

Simon Wright writes:
> Not sure whether the Debian gnat package includes gprbuild?

No; gprbuild is packaged separately from gnat in Debian but both are
available.  gnatcoll and xmlada are also packaged separately.

Still I'm sad at the prospect of being forced to use gprbuild where
gnatmake now works.  As some people noted, this move makes it that much
more difficult to provide, install, maintain etc. a complete toolchain.

Note that even though gprbuild is pure GPL, it can produce proprietary
software.  The only thing that might possibly affect the licensing of
the software you compile with any toolchain is the license of the
*libraries* that you link or copy (via generic instantiation) into your
executable, and gprbuild is not a library.

--
Ludovic Brenta.

Re: GNAT GPL is not shareware

[Dmitry A. Kazakov]

On Thu, 08 Jan 2015 11:55:09 +0100, G.B. wrote:

> On 08.01.15 09:14, Dmitry A. Kazakov wrote:
>> On Wed, 7 Jan 2015 16:47:25 -0600, Randy Brukardt wrote:
>>
>>> I have yet to use *anything* that used a DB that could not have been done
>>> better without the DB.
>>
>> True.
> 
> False, in general:
> 
> As soon as you start talking truly relational, you'll either
> use Prolog-ish programs, which are DB programs.

Prolog has nothing to do with DB, except that, Randy's statement fully
apply to Prolog: anything done in Prolog that could have been done better
without Prolog.

> Or, in Ada, you'll use pointers or cursors, or symbols in
> anything else, and start reinventing everything that the full
> relational model provides for free.

Relational algebra (RA) can be implemented in Ada. No problem, except
issues with generics.

You cannot easily do:

   generic
       type Tuple_Element_Array is (Positive range <>) of private;
   package Relational is

with

   Tuple_Element_Array'Element_Type (N)

to denote N'th type.

> Using the GNAT repertoire in the compiler sources,
> this question is typical of thinking "relational":
> 
> "List all Ada identifiers that are public in packages
>   that are children of P0, provided that they are not of
>   a pointer type."

This is not relational. Relational algebra does not deploy universally
qualified expression. You need a set (table) to search though.

Once you have it, it is a big question whether relational operations would
be useful or could be implemented at all. There are quite few things which
are good mapped onto relations and the corresponding data structures
backing them, e.g. B-trees.

A simple counterexample is spatial neighbour search (kD-tree).
 
> A standard RDBMS solution, while obvious, is perhaps
> inadequate for reasons of performance, specialization,
> Ada fanatism, etc. But it takes a political argument
> to deny that compilers do actually include those data
> structures and algorithms that the relational model
> has as built-ins.

There are many bad-to-destructive technologies used everywhere. E.g.
AdaCore's GNAT uses XML, Python. At least RA could have some application
areas. XML and Python have none.

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

Re: GNAT GPL is not shareware

[G.B.]

On 08.01.15 13:30, Dmitry A. Kazakov wrote:
> On Thu, 08 Jan 2015 11:55:09 +0100, G.B. wrote:
>
>> On 08.01.15 09:14, Dmitry A. Kazakov wrote:
>>> On Wed, 7 Jan 2015 16:47:25 -0600, Randy Brukardt wrote:
>>>
>>>> I have yet to use *anything* that used a DB that could not have been done
>>>> better without the DB.
>>>
>>> True.
>>
>> False, in general:
>>
>> As soon as you start talking truly relational, you'll either
>> use Prolog-ish programs, which are DB programs.
>
> Prolog has nothing to do with DB,

Really? Prolog always has been about databases as long as it
has existed, TTBOMK. It is even using that word meaningfully
at its very basis.
Or are you referring to a different meaning of "DB"?
Prolog:

% the database (base universe):
apple(green, 59).
apple(red_and_green, 49).

orange(sweet, 27).
orange(sour, 20).

% cross product
apples_x_oranges(A1, A2, O1, O2) :-
     apple(A1, A2),
     orange(O1, O2).

% selection from cross product
fruit_salad(A, PA, O, PO) :-          % pricey
      apples_x_oranges(A, PA, O, PO), PA > 50, PO > 20.

?- fruit_salad(X, Y, Z, W).
X = green,
Y = 59,
Z = sour,
W = 27 ;
false.

The same setup could be used for a database of Ada identifiers
and possible relations among them, since each of the identifiers,
as the word "identifier" says, denotes identically one element of
the universe of named things that an Ada source establishes.


> Relational algebra (RA) can be implemented in Ada. No problem,

You *are* naming the problem:

It is: "reinventing wheels", as I said. The point is that relational
problems can be solved easily whenever a language defines the means
of directly expressing relational items. Such a language does *not*
require that modes of expression be implemented first. OTOH, if that's
difficult to do in Ada, then a reusable implementation seems preferable
to compilers' idiosyncrasies except for the reasons listed.


>> Using the GNAT repertoire in the compiler sources,
>> this question is typical of thinking "relational":
>>
>> "List all Ada identifiers that are public in packages
>>    that are children of P0, provided that they are not of
>>    a pointer type."
>
> This is not relational.

Aha...

> Relational algebra does not deploy universally
> qualified expression.

Every selection is from the next universe, all of it. What definition
of the RA equivalent of FROM are you denying? I don't understand.


> A simple counterexample is spatial neighbour search (kD-tree).

A counterexample is usually a technique for invalidating
a general statement, but there is no general statement
about Relational being Whatever in *every* situation.
Relations are just being used in compilers, and in ASIS tools.

Re: GNAT GPL is not shareware

[Dmitry A. Kazakov]

On Thu, 08 Jan 2015 15:17:15 +0100, G.B. wrote:

> The same setup could be used for a database of Ada identifiers
> and possible relations among them, since each of the identifiers,
> as the word "identifier" says, denotes identically one element of
> the universe of named things that an Ada source establishes.

This is obviously wrong, since units can be instantiated, recursively used,
objects have scopes and life time.

Which "Universe" you mean for an identifier X declared in a body of a task
type?

>> Relational algebra (RA) can be implemented in Ada. No problem,
> 
> You *are* naming the problem:
> 
> It is: "reinventing wheels", as I said.

No more than other container types are. Relational table is a container.
There is nothing special about it. There exist both more complex and more
useful container types.

RA, to build a programming paradigm upon, is known to be unusable. Which is
the rationale behind Randy's empirical conclusion about databases.

> The point is that relational
> problems can be solved easily whenever a language defines the means
> of directly expressing relational items.

Another point is that relational problems are not domain space problems. RA
requires bending original problems into a very narrow framework of
techniques, inefficient and counterintuitive.

> OTOH, if that's
> difficult to do in Ada, then a reusable implementation seems preferable
> to compilers' idiosyncrasies except for the reasons listed.

DB models have practically zero reuse and are extremely unmaintainable as
compared to other software.

That is because DB design focus on raw data, rather than on higher level
entities.

>> Relational algebra does not deploy universally qualified expression.
> 
> Every selection is from the next universe, all of it. What definition
> of the RA equivalent of FROM are you denying? I don't understand.

What is FROM for Ada identifiers?

>> A simple counterexample is spatial neighbour search (kD-tree).
> 
> A counterexample is usually a technique for invalidating
> a general statement, but there is no general statement
> about Relational being Whatever in *every* situation.
> Relations are just being used in compilers, and in ASIS tools.

Relations are used everywhere because they are in the foundations of
mathematics.

RA as a computational model is a totally different issue. Its
implementation in RDBMS is yet another.

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

Re: GNAT GPL is not shareware

[Shark8]

On 08-Jan-15 03:55, G.B. wrote:
> And yes, SQL isn't perfect, and the type system of the
> relational model is much underused.

The biggest problem with SQL is that the standard makes *so much* 
optional that there's essentially zero portability between 
implementations. (Just try writing a few non-trivial CREATE TABLE 
statements and inputting them across MySQL, Postgres, FireBird, MSSQL, etc.)

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-08 19:46, Shark8 wrote:
> On 08-Jan-15 03:55, G.B. wrote:
>> And yes, SQL isn't perfect, and the type system of the
>> relational model is much underused.
> 
> The biggest problem with SQL is that the standard makes *so much*
> optional that there's essentially zero portability between
> implementations. (Just try writing a few non-trivial CREATE TABLE
> statements and inputting them across MySQL, Postgres, FireBird, MSSQL,
> etc.)

Yes, for DDL statments,
but DML statements are often quite similar, if
the vendor confesses to one of the standards.

We have about 700 hand-written statements in our WMS system,
+ a wealth (~3000) of table centric ones - auto generated -
and there is only 1 case where we differ the statements between the
vendors (Oracle, MS-sql-server and postgresql) and that
statement contains 'Substring', which in Oracle sql is 'substr'.

All other insert,select,delete,update are the same.
while some of them are trivial, other are more complicated like

SQL.PREPARE(SELECT_IPLOADS_TO_BLOCK,
  "select IPLOAD.*, IPAEXPI " &
  "from IPLOAD, IPART "       &
  "where IPLSTA < :RESERVED " &
  "and IPLRES = 0 " &
  "and IPLQUA > 0 " &
  "and IPLSDAT < :SYSTEM_DATE " &
  "and IPART.IPARTID = IPLOAD.IPARTID " &
  "and IPAEXPI > 0 " &
  "and not exists (select 'X' from IPLBLOC " &
                  "where IPLBLOC.IPLOAID = IPLOAD.IPLOAID " &
                    "and IPLBLOC.IBLOCAUS = :EXPIRED) " &
  "and not exists (select 'X' from IBOMLOA " &
                  "where IBOMLOA.ILDID = IPLOAD.ILDID)");


--
Björn

Re: GNAT GPL is not shareware

[Randy Brukardt]

"David Botton" <david@botton.com> wrote in message 
news:17ad25fe-e04f-4d79-a622-0b2455c150a0@googlegroups.com...
>> RRS started low-cost compilers in 1984, long before GNAT existed. But
>> whatever.

>And then the entire small compiler market for Ada was tiny, and microscopic 
>compared
>to markets for Turbo Pascal or Turbo C++, in fact Turbo Prolog (I liked 
>that) was
>probably larger a 1000 fold.

You grossly underestimate the power of Ada back in its glory days. For your 
statement to be true, Turbo Prolog would have had to sell well beyond 
5,000,000 copies. That seems unlikely. I might believe it for Turbo Pascal, 
but that's it.

>Many companies did excellent in the low-cost compiler market in those days. 
>None
>of those companies exists per se now. (Borland for example, whose catalog 
>is still
>dragged along for old customers even with some enhancements)

True enough. But I don't know why we're talking about this, because almost 
everyone here realizes that there is no profit in a low-cost compiler (for 
any language). If Microsoft feels it necessary to give awy their compilers 
(and they do), that's probably true for everyone else too.

The problem, of course, is that software development systems (which are far 
more than a compiler, of course) can't be built by volunteers. Stuff like 
program correctness is just too hard to be built by few people in their 
spare time.

But if there is no market for them, we'll continue to get more of the same. 
Indeed, it's pretty clear that the trend; a major "feature" of the cloud is 
that software can be replaced quickly, so there is much less incentive to 
get it right in the first place. Which means of course that it never will be 
right (and that contributes a lot to the ease of criminals breaking into 
systems).

>> But if there is no market, then there is no point in making a compiler at
>> all, because giving it away will not pay the bills.
>
>Correct. That has been the case now for a long time.
>
>Like most things these days you need alternative models for monetizing your 
>creative
>ideas since the old ones are used up, that is part of progress.

Since the ideas are ways to make software development better, there is 
nothing else to monitize. I'm not remotely interested in developing software 
for people that aren't already computer experts -- it's hard enough to 
please people that understand you and with which you have something in 
common.

>> Outreach in the form of demos, GPL versions, etc is cool, but not if it
>> cannablizes your main revenue stream (whatever that is).
>
>In a world of libre software if giving it away would cannibalizes your 
>business
>then you have no real business model,

You're probably right. As far as I can tell, there is no remaining business 
model for anything that I am competent at or care about.

Anything that one could do will be copied or even stolen before it could be 
brought to market.

Indeed, I don't understand why you think Gnoga will be good for Ada beyond 
an improvement for the existing believers. After all, if the model is so 
good, someone will copy it for C++ or Java, and they'll get the trade press 
for it, and [almost] everyone will think that the people who copied it 
invented it. (Consider the STL, for example, which started in Ada.) There 
isn't much that can be done in Ada that can't be done in those other 
languages (not quite as well, of course, but no one will care about that). 
Of course, if the model doesn't pan out, then it'll be just another failed 
technology.

I haven't wanted to discourage you in any way from developing Gnoga, which 
is mainly why I haven't brought this up sooner. But from the moment I read 
about it, I thought that it doesn't have much chance to be a game-changer, 
because anything one guy can do in a man-year can be copied by another guy 
in half that time (the tough work is done, after all). Hope I'm wrong.

>> And the people who traditionally have built software are unemployed or
>> underemployed.
>
>Those that didn't continue expanding their skill sets usually. There are 
>only so many
>jobs for people that no the ins and the outs of Wangs :) (But I do know 
>someone
>making a living there too... I wonder what happens when that job is gone 
>for him)

Sadly, that's how I've treated Ada for the last 10+ years. Hope that it 
lasts until I reach retirement.

There is very little in what passes for computing these days that I can 
stand to look at. Most of what would be required to "expand ones skill set" 
would require checking my brain at the door and making unmaintainable 
mash-ups of stuff that will stop working in a week (not the 20 years I want 
to run a program).

I suppose that makes me a dinosaur, because I still care about doing things 
right.

...
>> (Of course, most jobs will be automated in the coming years,
>> so that is going to be a growing problem for society to deal with.)
>
>And those that expand the skill sets in to the new areas that come with it 
>will succeed.

Well, if you mean learning to be a Wal-Mart greeter, perhaps you're right. 
Otherwise, I don't see it, because the vast majority of these machines will 
be self-repairing and eventually even self-constructing. There's little room 
for humans in that equation (and that's discounting the Terminator-style 
outcomes). I'm actually surprised that it hasn't happened already, but as 
with many things, the pace of progress is slower.

...
>There is a beautiful world out there. Most of it is far away from 
>government related projects though :)

Yup. However, it only beautiful when people have left their grubby hands off 
of it. And unfortunately, there is no market for hermits. :-)

>In summary of all that hot air:
>
>Expanded_skill_sets + humility + passion + win_win = Success.

As far as I can tell, I've never possessed any of these things except for 
passion
(I'd put the equation at:
     Ignorance + ego + previous experience with small business + passion + 
luck = Success)
...and the passion and luck were squeezed out years ago by Open Source and 
the takeover of the computer business by massive corps -- essentially 
catching the real innovators in a vice.

Not that I expect anyone to feel sorry for me. There are no real second 
chances, and a lot of people never even get a first chance.

                           Randy. 

Re: GNAT GPL is not shareware

[Randy Brukardt]

"G.B." <bauhaus@futureapps.invalid> wrote in message 
news:m8lnlg$eat$1@dont-email.me...
> On 08.01.15 09:14, Dmitry A. Kazakov wrote:
>> On Wed, 7 Jan 2015 16:47:25 -0600, Randy Brukardt wrote:
>>
>>> I have yet to use *anything* that used a DB that could not have been 
>>> done
>>> better without the DB.
>>
>> True.
>
> False, in general:
>
> As soon as you start talking truly relational, you'll either
> use Prolog-ish programs, which are DB programs.

Anyone who's talking "truly relational" needs their head examined.

> Or, in Ada, you'll use pointers or cursors, or symbols in
> anything else, and start reinventing everything that the full
> relational model provides for free.

But using the "relational model" is nowhere near free. One has to import 
some giant bloatware that changes without warning, most likely has to employ 
an expert in said bloatware in order to get anything done, you have to force 
your software into an almost always inappropriate transactional model, and 
so on. The performance hit is fantastic.

There of course are problems for which DBs are well suited, but there are 
far fewer of them out there than are generally supposed. That's because the 
makers of the bloatware (you know who they are) strongly promoted the 
DB-everywhere model, mainly so they could sell more bloatware. Unless your 
problem is very close to the strengths of a DB, just say no.

> Using the GNAT repertoire in the compiler sources,
> this question is typical of thinking "relational":
>
> "List all Ada identifiers that are public in packages
>  that are children of P0, provided that they are not of
>  a pointer type."

No one asks questions like that, because the answer is in the hundreds for 
many common identifiers. And if not, simple text search gets you the answer. 
Besides, visibility information can't sensibly be represented in a database, 
it depends on both the location of the declaration and the location of use.

> A standard RDBMS solution, while obvious, is perhaps
> inadequate for reasons of performance, specialization,
> Ada fanatism, etc. But it takes a political argument
> to deny that compilers do actually include those data
> structures and algorithms that the relational model
> has as built-ins.

This stuff is so basic that any program would have it (entity lookup, for 
instance). If a DB didn't have it, it would be completely useless. So that 
proves nothing whatsoever.

> For a worldly, commercial case,
> Google's non-SQL hash table based "database" is a major
> failure for programs using more than indexed lists, as is
> demonstrated by the hugely successful addition of an RDB
> option that Google added to the same App Engine.

Which just shows that most so-called developers today could not program 
their way out of a paper bag. They depend on having everything pre-built for 
them, and then they make fragile mashups that depend on things that they 
have no control over at all (meaning that there code will break frequently). 
Microsoft and others got the world so used to that that no one expects more 
anymore.

DB. Bah-humbug. :-)

                                  Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

"G.B." <bauhaus@futureapps.invalid> wrote in message 
news:m8m3ge$sg3$1@dont-email.me...
...
> It is: "reinventing wheels", as I said.

In most cases, I'd rather reinvent a wheel rather than depend on someone 
else's wheel of indeterminate quality which will change at unpredicable 
intervals. The only time reuse (of any kind) makes sense is when it will 
save a lot of effort for very little cost. (I'm not going to invent an HTML 
browser to show help in my next program, the effort would be much higher 
than the benefit, especially as it is not a critical part of the program.)

Using a DB has a high cost (in getting the interface to work, figuring out 
queries and schemas, etc.) and it adds a level of fragility (because of the 
frequent updates, any one of which could break one's system; additionally, 
someone outside of your code can easily access the data files using the DB 
and make them inconsistent). The benefit would have to be very high, and 
given the simplicity of what it provides, that requires a very specific type 
of application (one for a which a transactional model makes sense).

                                            Randy. 

Re: GNAT GPL is not shareware

[Paul Rubin]

"Randy Brukardt" <randy@rrsoftware.com> writes:
> There is very little in what passes for computing these days that I can 
> stand to look at. Most of what would be required to "expand ones skill set" 
> would require checking my brain at the door and making unmaintainable 
> mash-ups of stuff that will stop working in a week (not the 20 years I want 
> to run a program).

Give Haskell a try, http://haskell.org .  It is the most mind-expanding
thing that I've ever done as a programmer.  And its type system makes
Ada's look weak and primitive.

Re: GNAT GPL is not shareware

[David Botton]

> 5,000,000 copies.

How many were non-DoD, they don't count, they had to us it.

> Stuff like 
> program correctness is just too hard to be built by few people in their 
> spare time.

And so the DoD, Apple and others invested/invest and for their own motives require their efforts end in a way to benefit the masses to create trickle up.

> Since the ideas are ways to make software development better, there is 
> nothing else to monitize. I'm not remotely interested in developing software for people that aren't already computer experts -- it's hard enough to  please people that understand you and with which you have something in common.

The "secret" to a great product is to only produce what you yourself want to use and have passion for. The only things I've regretted in my life are the few times I worked for the money and not for the passion of the product itself and those times _hurt_ me.

May you be lucky enough in life to never have to and may we always share with you the things you do for their own sake :) Since the RM is fantastic (I learned Ada from it and use it constantly, I can't say that about any other language and most of my life's coding has not been in Ada) I can only assume you enjoy working on it and the other projects of yours we enjoy.

> You're probably right. As far as I can tell, there is no remaining business 
> model for anything that I am competent at or care about.

No, you just need to partner with someone that can share your passion, but perhaps not your skills, and has the skills to monitize it.

Build your passion first, monitize later.

> Anything that one could do will be copied or even stolen before it could be brought to market.

If what you did was with passion and for its own sake, then it will work anyways. Almost every major startup that has succeeded never hid what it was doing before it was done.

In the current market of libre software, since your code is not the product anyways it really doesn't matter at all if some one copied or "stole" it.

> Indeed, I don't understand why you think Gnoga will be good for Ada beyond 
> an improvement for the existing believers. After all, if the model is so 
> good, someone will copy it for C++ or Java, and they'll get the trade press 
> for it, and [almost] everyone will think that the people who copied it 
> invented it.

If I was thinking about "money" I would have written Gnoga in Python. (I wouldn't respect myself in the morning though...)

I wrote gnoga in Ada because I enjoy coding in Ada.
I wrote Gnoga because I want Gnoga and need it for me.
I publish Gnoga as Open Source because I want others to enjoy the music.
I publish in GMGPL because that will benefit Ada and other developers

If the business models (I've only shared a bit here and there with anyone) work out then my investment pays with cash too and for everyone (win win) and if it doesn't I sang my music even if only I enjoyed it and did what I could to help Ada _and_ the Ada community beyond the niche (win win).

> Of course, if the model doesn't pan out, then it'll be just another failed 
> technology.

What's wrong with failed tech, some parts of the song will be sung again (if OpenSource), perhaps in a remix :)

If Gem (~1985) was OpenSource we would never have had to suffer with Windows now...

> I haven't wanted to discourage you in any way from developing Gnoga, which 
> is mainly why I haven't brought this up sooner.

No worries, it wouldn't discourage me. I only count a friend someone that will tell me I'm wrong (or try to :)

> But from the moment I read 
> about it, I thought that it doesn't have much chance to be a game-changer, 
> because anything one guy can do in a man-year can be copied by another guy 
> in half that time (the tough work is done, after all). Hope I'm wrong.

I'll be happy to meet that guy if he has Botton sized passion :) We'd make a good team or epic adversaries and then eventually probably a team anyways unless he was e.v.i.l.

And if someone just steals my code? You can't steal libre code (you can abuse its license....). The opposite I want it to grow and happy if others add their water or re-plant it. I think better as a team, but if they have enough passion to do it. maybe I'll use their expanded version over my own :)

> Sadly, that's how I've treated Ada for the last 10+ years. Hope that it 
> lasts until I reach retirement.

If I can help it, Ada will :) 

(I don't even care how pompous that sounds, if I can't believe I will make a difference for Ada (and that has happened before...) I wouldn't bother with it.)

> There is very little in what passes for computing these days that I can 
> stand to look at. Most of what would be required to "expand ones skill set" 
> would require checking my brain at the door and making unmaintainable 
> mash-ups of stuff that will stop working in a week (not the 20 years I want 
> to run a program).

You have the talent, do it for you!

> Well, if you mean learning to be a Wal-Mart greeter, perhaps you're right. 
> Otherwise, I don't see it, because the vast majority of these machines will 
> be self-repairing and eventually even self-constructing.

So perhaps you should start writing the code to make that happen as your expansion :)

> Yup. However, it only beautiful when people have left their grubby hands off 
> of it. And unfortunately, there is no market for hermits. :-)

Not true at all. You would be surprised how many of them are doing very well :)

> As far as I can tell, I've never possessed any of these things except for 
> passion
> (I'd put the equation at:
>      Ignorance + ego + previous experience with small business + passion + 
> luck = Success)
> ...and the passion and luck were squeezed out years ago by Open Source and 
> the takeover of the computer business by massive corps -- essentially 
> catching the real innovators in a vice.

When your formula isn't succeeding it is a sign that it has bugs. Try mine it doesn't have aspects and fancy stuff like that, but its been debugged and run enough years to be considered proven stable.

> Not that I expect anyone to feel sorry for me. There are no real second 
> chances, and a lot of people never even get a first chance.

I respect you too much to ever consider feeling sorry for you. I like you enough to maybe even to give you a kick if I see you in person again :)

When I treat a patient, sometimes the next time I see them they say the pain moved from place X to place Y. I'm thrilled. Because as long as there is change, they are already getting better.

On thing leads to another in life, so even if the next Open Source Ada project _you_ do isn't the one that brings the fame and fortune, where it leads you next will and at the least you've enjoyed making (in your case one more) difference for Ada.

David Botton

Re: GNAT GPL is not shareware

[David Botton]

> Give ____ a try, http://_ohnoyoudon't.org_ .  It is the most mind-expanding
> thing that I've ever done as a programmer.  And its type system makes
> Ada's look weak and primitive.

Begone troll! Off with ye head!

Re: GNAT GPL is not shareware

[Paul Rubin]

David Botton <david@botton.com> writes:
>> Give ____ a try, http://_ohnoyoudon't.org_ .
> Begone troll! Off with ye head!

Heh, I'm not trying to troll, Ada is just designed to work in the
intersection of a bunch of different niches (highly correct code,
realtime code, code that runs in constrained environments) and that's
why there's not that many programmers involved in it.  If you're mostly
interested in writing solid, correct code but can look outside the
embedded and realtime niches, there's plenty going on.  

Take a look at http://compcert.inria.fr which is about a formally
verified C compiler (who knows, maybe it might compile Ada sometime too)
written in Coq generating Ocaml.  Ada isn't really the right vehicle for
it since it's not realtime and it runs on big computers, so it can use
garbage collection and simpler verification techniques than Ada uses.
But it's IMHO still of extreme interest to people wanting to write code
with high-end correctness assurance.  The ohnoyoudon't link I gave can
be seen as a stepping-stone to those methods.

Re: GNAT GPL is not shareware

[Jacob Sparre Andersen]

Randy Brukardt wrote:

> I suppose that makes me a dinosaur, because I still care about doing
> things right.

Well.  At least you're not the only dinosaur around here.

Greetings,

Jacob (who is still attempting to figure out how to create a thriving
       business)
-- 
"Being an absolute ruler today was not as simple as people
 thought.  At least, it was not simple if your ambitions
 included being an absolute ruler tomorrow."

Re: GNAT GPL is not shareware

[Arie van Wingerden]

Just curious: AFAIK the free GNU Ada compiler is Ada95. So, when you need 
new Ada2005 or Ada2012 features you're out of luck?
Or am I misinformed?
Arie


>> On Mon, 5 Jan 2015, Hubert wrote:

>> You could develop your software with AdaCore's IDE and compiler, and then
>> compile the final executables with the free FSF compiler. I tried this
>> some time ago (out of curiosity, not for license reasons).

>> The FSF and AdaCore-GPL compilers seem to be compatible, though I tried 
>> to
>> avoid gnat-specifics, anyway. Bug fixes and new features for FSF may be a
>> bit behind. But if you avoid the most recently added feature and don't
>> run into some exotic bug, your program should compile and run the same.

Re: GNAT GPL is not shareware

[Arie van Wingerden]

Found the answer in https://gcc.gnu.org/onlinedocs/gcc-4.9.2/gnat_rm.pdf
It appears that the free compiler DOES support Ada 2005 and 2012.
That is awesome!
Arie

"Arie van Wingerden"  schreef in bericht 
news:nnd$6267e13e$30509c4c@ac332e24ca751e61...

Just curious: AFAIK the free GNU Ada compiler is Ada95. So, when you need
new Ada2005 or Ada2012 features you're out of luck?
Or am I misinformed?
Arie


>> On Mon, 5 Jan 2015, Hubert wrote:

>> You could develop your software with AdaCore's IDE and compiler, and then
>> compile the final executables with the free FSF compiler. I tried this
>> some time ago (out of curiosity, not for license reasons).

>> The FSF and AdaCore-GPL compilers seem to be compatible, though I tried 
>> to
>> avoid gnat-specifics, anyway. Bug fixes and new features for FSF may be a
>> bit behind. But if you avoid the most recently added feature and don't
>> run into some exotic bug, your program should compile and run the same. 

Re: GNAT GPL is not shareware

[G.B.]

On 08.01.15 17:54, Dmitry A. Kazakov wrote:
> On Thu, 08 Jan 2015 15:17:15 +0100, G.B. wrote:
>
>> The same setup could be used for a database of Ada identifiers
>> and possible relations among them, since each of the identifiers,
>> as the word "identifier" says, denotes identically one element of
>> the universe of named things that an Ada source establishes.
>
> This is obviously wrong, since units can be instantiated, recursively used,
> objects have scopes and life time.

"Identifier", which denotes a source entity uniquely. It's
about a database of things in the source text, not about
things at run-time.

> Which "Universe" you mean for an identifier X declared in a body of a task
> type?

package body P is

  task body Foo is
    X : T:  -- here
    procedure Bar is
      X : T;  -- here, too
  begin ...

yields

  P.Foo.X
  P.Foo.Bar.X

Whenever profiles will matter, too, X being a subprogram, say,
they become part of identification, as usual. No identifier
identifies two things of the source text.

GNAT, like other compilers, collects the identifiers
in its vendor specific database, called .ali files…


>>> Relational algebra (RA) can be implemented in Ada. No problem,
>>
>> You *are* naming the problem:
>>
>> It is: "reinventing wheels", as I said.
>
> No more than other container types are.

Other languages have built-in syntax and semantics
for both containers and operators for handling
relations (SETL, APL, Prolog, …). Ada, like C++ and
others, suggests a library based approach; at least
some of the effort is standardized.

> RA, to build a programming paradigm upon, is known to be unusable.

RA is a mathematical abstraction without transitive
closure of relations. That's not the same thing as what
people mean by relational model. These even have recursion,
or, if *used*, that use is typically very well supporting
full languages (be that Ada or stored procedures or whatever).

> Which is
> the rationale behind Randy's empirical conclusion about databases.

His conclusions are not about using relational models,
but about using foreign RDBMSs. Not the same thing.

>> The point is that relational
>> problems can be solved easily whenever a language defines the means
>> of directly expressing relational items.
>
> Another point is that relational problems are not domain space problems.

Another false generalization, IMO: we would have
a political discussion at best, about "domain space".

I had just listed one example, others have given more.

> RA
> requires bending original problems into a very narrow framework of
> techniques, inefficient and counterintuitive.

Certainly, relational techniques do sometimes apply, and are
much more efficient to use than developing home-brewed data
structures and algorithms. All the more when these will fact
fact approximate the relational model.

> DB models have practically zero reuse and are extremely unmaintainable as
> compared to other software.

This interesting claim ignores that databases frequently do
solve problems, such as

(a) storing data for many different, independent uses and
(b) finding (relations between) data items as well as
    computed items, both foreseen and unforeseen.

Both are real needs.

> That is because DB design focus on raw data, rather than on higher level
> entities.

Your assumption is irrelevant, insofar as, briefly, no
program can do anything real without data. (And yes, if theorizing,
you can even involve executable objects in a relational model,
reflecting the phrase "algorithms = data".)

>>> Relational algebra does not deploy universally qualified expression.
>>
>> Every selection is from the next universe, all of it. What definition
>> of the RA equivalent of FROM are you denying? I don't understand.
>
> What is FROM for Ada identifiers?

As outlined above, all identifiers in source of a given
Ada program would be one simple example:
I can use my finger and point at every one of these
identifiers, one by one, thereby enumerating them. This
establishes one possible universe for use with FROM.

Re: GNAT GPL is not shareware

[G.B.]

On 09.01.15 03:20, Randy Brukardt wrote:

> But using the "relational model" is nowhere near free. One has to import
> some giant bloatware

A relational model is not the same thing as using an RDBMS.
When a language has it as a built-in, nothing is imported
at all. (SETL, LINQ, …).

> There of course are problems for which DBs are well suited, but there are
> far fewer of them out there than are generally supposed.

I'd rather say that not enough problems are being addressed
by skillfully using good relational techniques, as they take
learning, and thinking. Ad-hoc solutions seem to be a replacement,
because they are quicker to get our the door, initially.
Maintenance of idiosyncratic programs in the aftermath.

>> Using the GNAT repertoire in the compiler sources,
>> this question is typical of thinking "relational":
>>
>> "List all Ada identifiers that are public in packages
>>   that are children of P0, provided that they are not of
>>   a pointer type."
>
> No one asks questions like that,

Everyone asks questions like that. Proof:
the answer is proudly presented, even graphically (call graphs,
identifiers with locations and full name in error messages,
referring to others presented similarly on the same line,
structure views of source for analysis, overview, inspection,
review, etc.)

> because the answer is in the hundreds for
> many common identifiers. And if not, simple text search gets you the answer.

Simple text search will hardly find identifiers at Ada grade
reliability; rather, this kind of text search is called
semantic analysis, and is typically performed by a full
Ada compiler, or equivalently by an ASIS tool ;-)

> Besides, visibility information can't sensibly be represented in a database,
> it depends on both the location of the declaration and the location of use.

See? A relational form of dependence is right there
in front of the Adaist's eyes!


>> A standard RDBMS solution, while obvious, is perhaps
>> inadequate for reasons of performance, specialization,
>> Ada fanatism, etc. But it takes a political argument
>> to deny that compilers do actually include those data
>> structures and algorithms that the relational model
>> has as built-ins.
>
> This stuff is so basic that any program would have it (entity lookup, for
> instance). If a DB didn't have it, it would be completely useless. So that
> proves nothing whatsoever.

If true, your observation proves that basic stuff can be
done well using a relational model, without reinventing wheels,
as soon as a viable one is available with, and controlled
by, a programming language.

>> For a worldly, commercial case,
>>
>> […] the hugely successful addition of an RDB
>> option that Google added to the same App Engine.
>
> Which just shows that most so-called developers today could not program
> their way out of a paper bag. They depend on having everything pre-built for
> them, and then they make fragile mashups that depend on things that they
> have no control over at all (meaning that there code will break frequently).

Actually, the technical aspect of Google's App Engine
reveals that programmers would have all control they might
want: It is Google's business driven closing of source,
not the relational model, that makes programmers depend
on Google. Or, similarly, on Microsoft (Azure), etc.

Re: GNAT GPL is not shareware

[Pascal Obry]

Le vendredi 09 janvier 2015 à 11:27 +0100, Arie van Wingerden a écrit : 
> Or am I misinformed?

Exactly, GNU Ada is Ada-2012.

-- 
  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: GNAT GPL is not shareware

[Mark Carroll]

David Botton <david@botton.com> writes:

>> Give ____ a try, http://_ohnoyoudon't.org_ .  It is the most mind-expanding
>> thing that I've ever done as a programmer.  And its type system makes
>> Ada's look weak and primitive.
>
> Begone troll! Off with ye head!

(-: There's a serious point here for what Ada advocacy needs to address:
For anything cross-platform closed-source commercial (which is still a
lot, regardless of if the associated business model is simply selling
it, or something else), it takes work with Ada to determine that the FSF
compiler (distinct from GPL, despite the fact that it's generally the
FSF enforcing the GPL!) is affordable (in that case, free!), has the
right licensing, and may actually work well even on Windows etc.;
perhaps other compilers are too, though there's the question of how
actively maintained if they don't implement Ada 2012. When deciding what
language to try for a small project, the question of the larger
viability of cost/support/features for the compilers takes some research
and, in Ada's case, first impressions aren't great. That's very much one
of the things you're now trying to improve, and it's indeed a need.

Whereas for a lot of languages it's easy to determine that there are
multiple, free, cross-platform compilers, and that some of them -- e.g.,
Haskell's GHC -- are both actively maintained and industrial-strength,
with advanced code optimization, the latest experimental features and,
importantly, the latest bug-fixes available in the free version that can
compile closed-source code. That's been a help to us in the past when we
found and reported a compiler bug, and it got fixed well before our
project's release deadline.

In the modern landscape of programming languages, there are enough
interesting new ones like D (which also has textbooks in print) that the
"why Ada?" answer may not be as obvious for anyone more interested in
general-purpose programming than near-real-time embedded systems (and
even then languages like Erlang compete). Haskell /is/ mind-expanding --
it's one of the few languages in much use these days that an
otherwise-competent programmer who already knows, say, Python and OCaml,
can't become good in in a fortnight -- and has a lot to say about
reliability, as it's one of the languages whose type system (if I make
proper use of phantom types, etc.) means that when my Haskell programs
actually compile, that's now most of the bugs fixed. When in my day job
I have to use languages like Java I find myself frustrated by not being
able to express extra constraints to the compiler (e.g., functional
dependencies) that Haskell would permit. (And, yes, languages like OCaml
and Haskell are used in industry: there are some well-paid developer
jobs out there.)

My point isn't use Haskell, not Ada. (-: It's more that, in the modern
landscape, Ada's value proposition may not look so strong relatively for
anyone not already working on products for which Ada is already
entrenched, and when googling finds the curious a confusing and alarming
licensing story -- for instance, if it looks at a glance like for
compiling closed-source products, the only affordable compiler that
implements the latest language spec appears to be a year behind in
bug-fixes to help get the very expensive one sold -- then I can imagine
that many small businesses might shrug and move on.

So, if Ada advocacy does want to expand the number of companies and
developers using it, it needs to make sure that one of the first Ada
websites that people stumble on is one that tells a more reassuring
story about the state of compilers: that there /are/ affordable
cross-platform compilers for closed-source code that get prompt bug
fixes and, if they don't implement the latest specification, why that
doesn't much matter.

-- Mark

Re: GNAT GPL is not shareware

[David Botton]

> So, if Ada advocacy does want to expand the number of companies and
> developers using it, it needs to make sure that one of the first Ada
> websites that people stumble on is one that tells a more reassuring
> story about the state of compilers

and so GetAdaNow.com was born :)

For those that share my vision they will link to it and promote it (and if no one does, well at least I did :). When other libre distributions (with out licence viruses) exist I'll add them there as well.

I know that God willing when ready before end of year with the Gnoga IDE and GUI builder, I'll make available easy cross platform installs to promote Ada further. (Shame couldn't just build on GPS as part of all this, but I wouldn't feel right forking it, that would clearly be against their current "relationship" with the community, but should be possible to still use the GUI builder with it if desired when ready).

It would be really great if some others with the right skill sets decided time to  get involved with the Draco project retargeting gnat for llvm  or start another community supported compiler effort.

http://www.dragonlace.net/questions/quest_004/

David Botton

Re: GNAT GPL is not shareware

[Randy Brukardt]

"G.B." <bauhaus@futureapps.invalid> wrote in message 
news:m8onh1$8cv$1@dont-email.me...
...
>>> Using the GNAT repertoire in the compiler sources,
>>> this question is typical of thinking "relational":
>>>
>>> "List all Ada identifiers that are public in packages
>>>   that are children of P0, provided that they are not of
>>>   a pointer type."
>>
>> No one asks questions like that,
>
> Everyone asks questions like that.

No they don't. I believe the "public in packages" part, but not the "not a 
pointer type" part. This question is far more complex than the real 
questions that get asked. Besides...

>> Proof:
>> the answer is proudly presented, even graphically (call graphs,
>> identifiers with locations and full name in error messages,
>> referring to others presented similarly on the same line,
>> structure views of source for analysis, overview, inspection,
>> review, etc.)

Maybe, but that only illustrates the disconnect I have with modern, can't do 
anything themselves programmers. I have never used a tool that does any of 
the above (with the possible exception of the Rational Apex IDE, and I never 
figured out how to get it to do anything much beyond compiling) and the need 
is quite rare - surely not worth the effort to construct. A few things fall 
out for free (the location of declaration is stored with each declaration, 
of course, so once the compiler knows the item, it could put that into the 
error messages. But Janus/Ada does that only a very few cases, in large part 
because the size of the compiler was a critical constraint when it was 
designed. That made error handling quite rigid, with a single template for 
all messages.)

...
>> Besides, visibility information can't sensibly be represented in a 
>> database,
>> it depends on both the location of the declaration and the location of 
>> use.
>
> See? A relational form of dependence is right there
> in front of the Adaist's eyes!

I haven't any clue as to what you are talking about. Visiblity information 
is tree-structured, and it is not possible to map trees sensibly into the 
flat tables required by relational technology. Doing so distorts the problem 
(as Dmitry notes).

>>> A standard RDBMS solution, while obvious, is perhaps
>>> inadequate for reasons of performance, specialization,
>>> Ada fanatism, etc. But it takes a political argument
>>> to deny that compilers do actually include those data
>>> structures and algorithms that the relational model
>>> has as built-ins.
>>
>> This stuff is so basic that any program would have it (entity lookup, for
>> instance). If a DB didn't have it, it would be completely useless. So 
>> that
>> proves nothing whatsoever.
>
> If true, your observation proves that basic stuff can be
> done well using a relational model, without reinventing wheels,
> as soon as a viable one is available with, and controlled
> by, a programming language.

Last I saw this was an Ada forum, and the entire point of languages at the 
level of Ada is to build wheels (and engines and brakes and...). Perhaps 
you're right (although I happen to think the wheels you're worrying about 
are discredited as a solution for much), but even so, it has nothing to do 
with Ada.

>>> For a worldly, commercial case,
>>>
>>> [.] the hugely successful addition of an RDB
>>> option that Google added to the same App Engine.
>>
>> Which just shows that most so-called developers today could not program
>> their way out of a paper bag. They depend on having everything pre-built 
>> for
>> them, and then they make fragile mashups that depend on things that they
>> have no control over at all (meaning that there code will break 
>> frequently).
>
> Actually, the technical aspect of Google's App Engine
> reveals that programmers would have all control they might
> want: It is Google's business driven closing of source,
> not the relational model, that makes programmers depend
> on Google. Or, similarly, on Microsoft (Azure), etc.

The only thing dumber than depending a giant DB like Oracle is depending on 
some cloud software like Google App Engine. Their approach is that anything 
can be changed at any time, they don't have any notion of a contract 
(certainly not in the Ada sense), so your software can be broken at any 
time. Getting software right isn't even possible in such an environment, at 
best you can get it to work at some moment in time.

Cloud people have completely lost the value of versioning and change 
control. You buy a new car all at once, and then get used to using it as 
everything non-critical will be different. You don't get a new seat one week 
and a new brakes the next and then new engine etc. Because there's a big 
chance that the new brakes won't work right with the old wheels.

                              Randy.

Re: GNAT GPL is not shareware

[Shark8]

On 09-Jan-15 14:33, Randy Brukardt wrote:
> I haven't any clue as to what you are talking about. Visiblity information
> is tree-structured, and it is not possible to map trees sensibly into the
> flat tables required by relational technology. Doing so distorts the problem
> (as Dmitry notes).

It actually is possible to store a tree structure in a "flat table" -- 
see recursive queries. -- 
http://en.wikipedia.org/wiki/Hierarchical_and_recursive_queries_in_SQL

Re: GNAT GPL is not shareware

[Randy Brukardt]

"G.B." <bauhaus@futureapps.invalid> wrote in message 
news:m8om3v$2ga$1@dont-email.me...
> On 08.01.15 17:54, Dmitry A. Kazakov wrote:
>> On Thu, 08 Jan 2015 15:17:15 +0100, G.B. wrote:
>>
>>> The same setup could be used for a database of Ada identifiers
>>> and possible relations among them, since each of the identifiers,
>>> as the word "identifier" says, denotes identically one element of
>>> the universe of named things that an Ada source establishes.
>>
>> This is obviously wrong, since units can be instantiated, recursively 
>> used,
>> objects have scopes and life time.
>
> "Identifier", which denotes a source entity uniquely. It's
> about a database of things in the source text, not about
> things at run-time.

So in other words, it's unusuable for a debugger, which is an important part 
of an IDE. (That's a problem with ASIS, as well; one of the reasons that it 
is a better idea than useful thing.) And it probably would have problems 
with macro-expanded generics vs. code-shared generics (again, which ASIS has 
in spades) - either you duplicate the definitions, so you no longer have a 
1-to-1 relation of identifiers to source, or you don't, and you have 
multiple versions of the same thing. Rather a lose-lose situation.

                              Randy.


                                  Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Shark8" <OneWingedShark@gmail.com> wrote in message 
news:U%Xrw.246026$pr4.26650@fx26.iad...
> On 09-Jan-15 14:33, Randy Brukardt wrote:
>> I haven't any clue as to what you are talking about. Visiblity 
>> information
>> is tree-structured, and it is not possible to map trees sensibly into the
>> flat tables required by relational technology. Doing so distorts the 
>> problem
>> (as Dmitry notes).
>
> It actually is possible to store a tree structure in a "flat table" -- 
> see recursive queries. -- 
> http://en.wikipedia.org/wiki/Hierarchical_and_recursive_queries_in_SQL

Of course it's possible -- it's just unnatural. The reason Ada now has a 
tree container is directly because of that -- while you can map a tree into 
a flat structure, you have to do some sort of encoding to do so. It's better 
to directly have the structure.

(Now, if someone wanted to promulagate an "everything is a tree" strategy 
and algebra, I'd be interested, because there are very few problems that 
aren't a tree of some sort.)

                                    Randy.

Re: GNAT GPL is not shareware

[Shark8]

On 09-Jan-15 15:07, Randy Brukardt wrote:
> Of course it's possible -- it's just unnatural. The reason Ada now has a
> tree container is directly because of that -- while you can map a tree into
> a flat structure, you have to do some sort of encoding to do so. It's better
> to directly have the structure.

I agree.
But there's no reason to snub what's essentially the 
seralization/deserialization for storage. (That is, at some point it's 
going to be stored [and retrieved] sequentially, in some manner.)

> (Now, if someone wanted to promulagate an "everything is a tree" strategy
> and algebra, I'd be interested, because there are very few problems that
> aren't a tree of some sort.)

That actually sounds somewhat like my understanding of mneson.
http://web.archive.org/web/20041018184104/http://www.liacc.up.pt/~maa/mneson/

^- It was apparently a database, written 100% in Ada, and based off of 
graph-theory.

Re: GNAT GPL is not shareware

[Shark8]

On 09-Jan-15 15:03, Randy Brukardt wrote:
> And it probably would have problems
> with macro-expanded generics vs. code-shared generics (again, which ASIS has
> in spades) - either you duplicate the definitions, so you no longer have a
> 1-to-1 relation of identifiers to source, or you don't, and you have
> multiple versions of the same thing.

I haven't read anything about the DIANA based systems having trouble 
with generics/instantiations in my research. -- Do you have some 
experience or stories about them? Could you elaborate on the problems of 
ASIS w/ generics?

Re: GNAT GPL is not shareware

[Simon Clubley]

On 2015-01-09, Mark Carroll <mtbc@bcs.org> wrote:
>
> My point isn't use Haskell, not Ada. (-: It's more that, in the modern
> landscape, Ada's value proposition may not look so strong relatively for
> anyone not already working on products for which Ada is already
> entrenched, and when googling finds the curious a confusing and alarming
> licensing story -- for instance, if it looks at a glance like for
> compiling closed-source products, the only affordable compiler that
> implements the latest language spec appears to be a year behind in
> bug-fixes to help get the very expensive one sold -- then I can imagine
> that many small businesses might shrug and move on.
>

As someone who really likes Ada but isn't as deeply emotionally involved
with it as many others here, I've been saying the above for years here
in comp.lang.ada so I strongly agree with you. Sometimes, there's been a
tendency for people deeply involved with Ada to stick their head in the
sand when it comes to trying to make them understand how Ada is perceived
by the outside world.

The other barrier (for some) is that you can't build the FSF compiler,
out of the box, as a cross compiler for a number of targets in the same
easy way as you can with C. As one of Ada's strengths is in the embedded
world (and hence should be a good way to attract newcomers, including
hobbyists, to Ada), that is a major annoyance.

Yes, I am very aware that some of the common hobbyist MCUs (such as the
AVR and MSP430) do have Ada compilers for them (as third party efforts)
but I am talking about the general case.

C is not a good language by today's standards, but it runs _everywhere_
which is one of the reasons why people continue to use it.

Simon.

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

Re: GNAT GPL is not shareware

[Dmitry A. Kazakov]

On Fri, 09 Jan 2015 14:47:08 +0100, G.B. wrote:

> On 08.01.15 17:54, Dmitry A. Kazakov wrote:

>> Which is
>> the rationale behind Randy's empirical conclusion about databases.
> 
> His conclusions are not about using relational models,
> but about using foreign RDBMSs. Not the same thing.

Just because RDBMS uses RA for dealing with persistency problems. The point
is that RA is poor for almost everything, persistency included. RA didn't
made it into mainstream programming, though attempts made.
 
>> RA
>> requires bending original problems into a very narrow framework of
>> techniques, inefficient and counterintuitive.
> 
> Certainly, relational techniques do sometimes apply,

Sometimes, yes. As an Ada source library, no.

> and are
> much more efficient to use than developing home-brewed data
> structures and algorithms.

But they don't have structures and algorithms of their own. What prevents
you from implementing B-tree?

>> DB models have practically zero reuse and are extremely unmaintainable as
>> compared to other software.
> 
> This interesting claim ignores that databases frequently do
> solve problems, such as
> 
> (a) storing data for many different, independent uses and
> (b) finding (relations between) data items as well as
>     computed items, both foreseen and unforeseen.
> 
> Both are real needs.

My in-ear headphones are totally unmaintainable and have zero component
reuse, when cable break, I throw them away. But I still have a real need in
headphones. And I never ever will use them as an ultrasonic mixer.

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

Re: GNAT GPL is not shareware

[Brian Drummond]

On Fri, 09 Jan 2015 12:08:28 -0800, David Botton wrote:

>> So, if Ada advocacy does want to expand the number of companies and
>> developers using it, it needs to make sure that one of the first Ada
>> websites that people stumble on is one that tells a more reassuring
>> story about the state of compilers
> 
> and so GetAdaNow.com was born :)

> It would be really great if some others with the right skill sets
> decided time to  get involved with the Draco project retargeting gnat
> for llvm  or start another community supported compiler effort.
> 
> http://www.dragonlace.net/questions/quest_004/
> 
> David Botton

And one of the links there
http://llvm.org/cmds/llvmgcc.html
apparently on the official LLVM website now 404s, which doesn't give one 
a good feel for the state of the project :-(

- Brian

Re: GNAT GPL is not shareware

[Arie van Wingerden]

Is it correct that the free GNU compiler is exactly the same compiler as 
Adacore's one? The difference with Ada Libre would be the IDE and extra 
tools supplied by Adacore??
Tia,
   Arie

"Pascal Obry"  schreef in bericht news:1420821566.25169.31.camel@obry.net...

Le vendredi 09 janvier 2015 à 11:27 +0100, Arie van Wingerden a écrit :
> Or am I misinformed?

Exactly, GNU Ada is Ada-2012.

-- 
  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: GNAT GPL is not shareware

[Pascal Obry]

Le samedi 10 janvier 2015 à 18:33 +0100, Arie van Wingerden a écrit : 
> Is it correct that the free GNU compiler is exactly the same compiler as 
> Adacore's one? The difference with Ada Libre would be the IDE and extra 
> tools supplied by Adacore??

The IDE is part of GNU/Debian. GPS *is* a tool so not part of GCC/FSF 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: GNAT GPL is not shareware

[David Botton]

> Is it correct that the free GNU compiler is exactly the same compiler as 
> Adacore's one?

AdaCore, and one reason they deserve much praise, up streams most of their improvements on gcc/ada back to the FSF. So the FSF compiler is not identical but close to older versions of AdaCore's products.

When compiling gcc there are many options and features not just on the Ada side, so they will never be identical.

Based on your previous questions, in terms of language features they are both Ada 2012 compilers and the same sort of gnat specific extensions, etc. would be in both, etc. So for professional use FSF gcc/ada is a good choice. In particular on platforms with maintainers like GNU Linux/Debian and Mac.

> The difference with Ada Libre would be the IDE and extra 
> tools supplied by Adacore??

GNAT-GPL from the libre site, other than license differences, is optimized by AdaCore with the build choices they make for their customers and using the same sources and tools as their PRO product. It also can lag a bit behind their PRO product but GNAT-GPL is a very solid build of gcc/ada and a good demo of their PRO builds, less the PRO support of course which is AdaCore's real product and is worth every penny.

If I had a project in AdaCore's niche at the moment and it had the funding needed for it, I wouldn't think twice about PRO product, ie. their support. (although maybe I'd use a fake name at this point when negotiating the contract ;)

David Botton

Re: GNAT GPL is not shareware

[Arie van Wingerden]

Hi David,

thanks! That is the answer I was looking for!

Regards,
   Arie

"David Botton"  schreef in bericht 
news:501b4436-6852-461e-abb9-145616803a5f@googlegroups.com...

> Is it correct that the free GNU compiler is exactly the same compiler as
> Adacore's one?

AdaCore, and one reason they deserve much praise, up streams most of their 
improvements on gcc/ada back to the FSF. So the FSF compiler is not 
identical but close to older versions of AdaCore's products.

When compiling gcc there are many options and features not just on the Ada 
side, so they will never be identical.

Based on your previous questions, in terms of language features they are 
both Ada 2012 compilers and the same sort of gnat specific extensions, etc. 
would be in both, etc. So for professional use FSF gcc/ada is a good choice. 
In particular on platforms with maintainers like GNU Linux/Debian and Mac.

> The difference with Ada Libre would be the IDE and extra
> tools supplied by Adacore??

GNAT-GPL from the libre site, other than license differences, is optimized 
by AdaCore with the build choices they make for their customers and using 
the same sources and tools as their PRO product. It also can lag a bit 
behind their PRO product but GNAT-GPL is a very solid build of gcc/ada and a 
good demo of their PRO builds, less the PRO support of course which is 
AdaCore's real product and is worth every penny.

If I had a project in AdaCore's niche at the moment and it had the funding 
needed for it, I wouldn't think twice about PRO product, ie. their support. 
(although maybe I'd use a fake name at this point when negotiating the 
contract ;)

David Botton 

Re: GNAT GPL is not shareware

[Ludovic Brenta]

"Arie van Wingerden" <xapwing@gmail.com> writes:
> Is it correct that the free GNU compiler is exactly the same compiler
> as Adacore's one? The difference with Ada Libre would be the IDE and
> extra tools supplied by Adacore??
> Tia,

https://en.wikibooks.org/wiki/Ada_Programming/Installing#GNAT.2C_the_GNU_Ada_Compiler_from_AdaCore_and_the_Free_Software_Foundation

https://people.debian.org/~lbrenta/debian-ada-policy.html#The-variants-of-GNAT

--
Ludovic Brenta.

Re: GNAT GPL is not shareware

[G.B.]

On 10.01.15 08:18, Dmitry A. Kazakov wrote:
> Just because RDBMS uses RA for dealing with persistency problems.

Persistence typically is just one of the goals when using a DB.

> RA didn't made it into mainstream programming, though attempts made.

Maybe Ada, C++, Cobol, C, Python, VB, and other mainstream
programming languages are lacking in support for declarative
style?

Besides, LINQ made it into C#  …

Re: GNAT GPL is not shareware

[Dmitry A. Kazakov]

On Mon, 12 Jan 2015 12:40:50 +0100, G.B. wrote:

> On 10.01.15 08:18, Dmitry A. Kazakov wrote:
>> Just because RDBMS uses RA for dealing with persistency problems.
> 
> Persistence typically is just one of the goals when using a DB.

Other goals, like money extortion, you mean?

>> RA didn't made it into mainstream programming, though attempts made.
> 
> Maybe Ada, C++, Cobol, C, Python, VB, and other mainstream
> programming languages are lacking in support for declarative
> style?

No, they keep it in balance. And it would be a lie to say that SQL were any
declarative.

The reason why has nothing to do with imperative vs. declarative. It does
with the computational framework required to back the corresponding
paradigm. Compared to mainstream languages RA relies on extremely
constraining and extremely inefficient frameworks of RDBMS, even when
watered down with stored procedures. Nobody would seriously consider this
for universal purpose programming, except for pointy-haired academics.

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

Re: GNAT GPL is not shareware

[G.B.]

On 12.01.15 14:21, Dmitry A. Kazakov wrote:
> On Mon, 12 Jan 2015 12:40:50 +0100, G.B. wrote:
>
>> On 10.01.15 08:18, Dmitry A. Kazakov wrote:
>>> Just because RDBMS uses RA for dealing with persistency problems.
>>
>> Persistence typically is just one of the goals when using a DB.
>
> Other goals, like money extortion, you mean?

A DB is good for independent information retrieval,
in particular when it is part of a PL:

Clients then need not buy or order special information
retrieval programs given all these non-standard databases.
A clear advantage, IMO.

Tiny example:
.ali files of GNAT and the ./info files of AdaMagic may
(theoretically) share a schema of Ada library data,
data available on request, leaving hardly any performance hit.

Granted, there was a time when a standard schema like this
would have meant that two vendors of Ada compilers would
be able to use each others' output (other than the object files).
And even third parties could use either GNAT's or AdaMagic-Based's
compiler output, so as to make it serve *their* needs as well
as *their* customers' needs. That's not exactly the freedom of
information that every business person will like, I guess,
depending on whether they are sellers or buyers.


> And it would be a lie to say that SQL were any
> declarative.

SQL is not *any* declarative? Do you mean "not *all* declarative"?

> Nobody would seriously consider this
> for universal purpose programming, except for pointy-haired academics.

So what? No need to have relational models replace everything!
That's a straw man. When RA is just made available as part
of a general purpose PL's definition, that's a good start.

In fact, with either built-in relation support or Ada.Containers,
a typical algorithm like
   "Find all friends of distance <= 2."
might look almost the same no matter whether, say, pairs would
be stored in a container table or in a relational table.

Re: GNAT GPL is not shareware

[Dmitry A. Kazakov]

On Mon, 12 Jan 2015 15:52:35 +0100, G.B. wrote:

> On 12.01.15 14:21, Dmitry A. Kazakov wrote:
>> On Mon, 12 Jan 2015 12:40:50 +0100, G.B. wrote:
>>
>>> On 10.01.15 08:18, Dmitry A. Kazakov wrote:
>>>> Just because RDBMS uses RA for dealing with persistency problems.
>>>
>>> Persistence typically is just one of the goals when using a DB.
>>
>> Other goals, like money extortion, you mean?
> 
> A DB is good for independent information retrieval,
> in particular when it is part of a PL:

All reentrant containers are.

> Clients then need not buy or order special information
> retrieval programs given all these non-standard databases.
> A clear advantage, IMO.

Advantage over what?
 
> Tiny example:
> .ali files of GNAT and the ./info files of AdaMagic may
> (theoretically) share a schema of Ada library data,
> data available on request, leaving hardly any performance hit.

Which has nothing to do with RA.

>> And it would be a lie to say that SQL were any
>> declarative.
> 
> SQL is not *any* declarative? Do you mean "not *all* declarative"?

As declarative as C.

>> Nobody would seriously consider this
>> for universal purpose programming, except for pointy-haired academics.
> 
> So what? No need to have relational models replace everything!

In order to become mainstream you have to.

> That's a straw man. When RA is just made available as part
> of a general purpose PL's definition, that's a good start.

No. A programming language should be capable of designing a decent
container library. There is nothing in RA beyond being a specialized class
of containers.

Built-in containers is a mistake. Modern languages have no built-in
containers except for record and array types.

> In fact, with either built-in relation support or Ada.Containers,
> a typical algorithm like
>    "Find all friends of distance <= 2."
>
> might look almost the same no matter whether, say, pairs would
> be stored in a container table or in a relational table.

Which would be horrific O(n) in RA.

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

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Shark8" <OneWingedShark@gmail.com> wrote in message 
news:hCZrw.1170551$412.561840@fx30.iad...
> On 09-Jan-15 15:07, Randy Brukardt wrote:
>> Of course it's possible -- it's just unnatural. The reason Ada now has a
>> tree container is directly because of that -- while you can map a tree 
>> into
>> a flat structure, you have to do some sort of encoding to do so. It's 
>> better
>> to directly have the structure.
>
> I agree.
> But there's no reason to snub what's essentially the 
> seralization/deserialization for storage. (That is, at some point it's 
> going to be stored [and retrieved] sequentially, in some manner.)

Depends on the usage, of course. If all you need is persistence of the 
(entire) data structure, the stream attributes provided with Multiway_Trees 
is sufficient (and it already exists, so no wheel-reinventing, and a lot 
less complex than a DB). If you need some sort of on-the-fly access to 
individual elements, that's obviously a different problem (and much more in 
the wheelhouse of DBs, as it is necessarily transactional).

                          Randy.

                             Randy. 

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Shark8" <OneWingedShark@gmail.com> wrote in message 
news:eFZrw.1020853$No4.1016889@fx19.iad...
> On 09-Jan-15 15:03, Randy Brukardt wrote:
>> And it probably would have problems
>> with macro-expanded generics vs. code-shared generics (again, which ASIS 
>> has
>> in spades) - either you duplicate the definitions, so you no longer have 
>> a
>> 1-to-1 relation of identifiers to source, or you don't, and you have
>> multiple versions of the same thing.
>
> I haven't read anything about the DIANA based systems having trouble with 
> generics/instantiations in my research. -- Do you have some experience or 
> stories about them? Could you elaborate on the problems of ASIS w/ 
> generics?

DIANA certainly wouldn't have any issues, because any individual 
implementation simply does whatever it does, which is fine. The problem with 
ASIS is that is a disaster for portability. ASIS 99 essentially allows the 
implementation to do whatever it does for generics -- so how do you write 
portable code for that? (Ans: you have to write it both ways and use query 
functions. Gag.) The alternative is to require it to emulate a 
macro-expansion. But of course then an ASIS implementation is near 
impossible on a sharing implementation. (After all, if the implementer 
wanted to implement the full nastiness of a macro-expansion implementation, 
they probably would have done that in the first place. And they'll have to 
implement 95% of it in order to properly implement ASIS.)

The other problem with ASIS is that the name "Ada Semantic Interface" is 
nearly a lie; ASIS has very little semantic information in it. It's almost 
exclusively about matching syntactic constructs with their syntactic 
definitions. It does badly with anonymous things for this reason (the worst 
being T'Class, which is 100% implicit), and it makes it very hard to deal 
with visibility and the like. It also means its a bad mapping for any 
implementation that does not keep the syntax around. For instance, in 
Janus/Ada, we eliminate most static matching issues by collapsing subtypes 
whenever possible. So there is never more than one subtype object with each 
static semantics, even if those come from different declarations. (If you 
can't tell the difference from the Ada perspective, why waste space on 
storage?) One can't implement ASIS that way; we'd have to change the 
underlying way subtypes are handled in order to separate the different 
declarations.

A true semantic interface would talk about semantic entities only, the 
associated syntax would not enter into it.

                             Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:delkd2xhimol.q5uw34dwvc8m.dlg@40tude.net...
> On Mon, 12 Jan 2015 12:40:50 +0100, G.B. wrote:
...
> Other goals, like money extortion, you mean?
...
> Nobody would seriously consider this
> for universal purpose programming, except for pointy-haired academics.

You forgot salemen for DB companies. :-)

                 Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

"G.B." <bauhaus@futureapps.invalid> wrote in message 
news:m90n2n$c2p$1@dont-email.me...
...
> Tiny example:
> .ali files of GNAT and the ./info files of AdaMagic may
> (theoretically) share a schema of Ada library data,
> data available on request, leaving hardly any performance hit.

That's not really practical; different compilers store very different 
information in those files. GNAT stores hardly anything in an .ali file, 
preferring to recompile everything as needed. (A true source-based model.) 
OTOH, a compiler like Janus/Ada stores pre-compiled data in it's SYM files, 
it never recompiles anything other than by explicit compile command. The 
commonality is so small that there isn't much to be gained by a standard for 
library data.

What would happen is that you'd have a definition of "library data" that 
matched one particular compiler, and either everyone else would have to 
conform to it (making them less efficient than the one that they had to 
match) or ignore the "standard" (providing no benefit at all). That's the 
problem with ASIS, after all. It essentially matches the way that the circa 
1990 Rational compiler works (which is downright weird, IMHO), and everyone 
else either has to bend their technology to match it somehow, or simply not 
bother and hope the silly thing goes away.

I don't see how either does any good unless you really want a 
single-implementation ecosystem. (Even AdaCore doesn't want that for Ada.)

                                    Randy.

Re: GNAT GPL is not shareware

[J-P. Rosen]

Le 13/01/2015 00:49, Randy Brukardt a écrit :
> A true semantic interface would talk about semantic entities only, the 
> associated syntax would not enter into it.

That would be a semantic ONLY interface, but syntax is also useful for
some tools (especially coding rules checkers ;-) ).

For example, checking that "end" mentions the entity name is 100%
syntactic...

-- 
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: GNAT GPL is not shareware

[Robert A Duff]

"J-P. Rosen" <rosen@adalog.fr> writes:

> Le 13/01/2015 00:49, Randy Brukardt a écrit :
>> A true semantic interface would talk about semantic entities only, the 
>> associated syntax would not enter into it.
>
> That would be a semantic ONLY interface, but syntax is also useful for
> some tools (especially coding rules checkers ;-) ).

Right, you can't very well have a semantic interface without syntax
to hang it off of.

> For example, checking that "end" mentions the entity name is 100%
> syntactic...

True.  But I'd prefer 'gnatpp', which doesn't "check" that, it just
sticks in the missing name for you -- similar idea.  Anyway, gnatpp is
primarily syntactic.  Not entirely -- it knows how to capitalize usage
names to match the declaration, which requires semantic information.

- Bob

Re: GNAT GPL is not shareware

[J-P. Rosen]

Le 13/01/2015 16:51, Robert A Duff a écrit :
> True.  But I'd prefer 'gnatpp', which doesn't "check" that, it just
> sticks in the missing name for you -- similar idea.  Anyway, gnatpp is
> primarily syntactic.  Not entirely -- it knows how to capitalize usage
> names to match the declaration, which requires semantic information.

Right. Checking presentation is as much effort (perhaps more) than
fixing it - which is the reason why I don't have many presentation rules
in AdaControl. OTOH, some users have rules like "the name after end is
not required if the subprogram is less than nn lines". You can't go into
such details with a pretty printer.

(I accept the argument that it's better to have the name everywhere than
start arguing, but that's what some of my clients are using - AdaControl
is not supposed to support my own favorite rules only, but anybody's rules).

-- 
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: GNAT GPL is not shareware

[Randy Brukardt]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 998 bytes --]

"J-P. Rosen" <rosen@adalog.fr> wrote in message 
news:m92mq3$kji$1@dont-email.me...
> Le 13/01/2015 00:49, Randy Brukardt a écrit :
>> A true semantic interface would talk about semantic entities only, the
>> associated syntax would not enter into it.
>
> That would be a semantic ONLY interface, but syntax is also useful for
> some tools (especially coding rules checkers ;-) ).
>
> For example, checking that "end" mentions the entity name is 100%
> syntactic...

True enough. I just don't like the fact that the name of ASIS is misleading. 
And of course, a syntax-only tool would be quite easy to create without 
using any fancy interface. (Our syntax checker/pretty printer tool makes 
similar checks [not sure about that one].) A mostly semantic system with a 
bit of syntax mixed in (we do keep a bit of such information for error 
messages, purely semantic wouldn't work either) seems best to me. ASIS 
doesn't have enough abstraction for my taste.

                               Randy.

Re: GNAT GPL is not shareware

[J-P. Rosen]

Le 13/01/2015 22:19, Randy Brukardt a écrit :
> ASIS 
> doesn't have enough abstraction for my taste.
I wasn't part of the initial design of ASIS, but I think the initial
idea was just to provide basic building blocks, from which everybody
could build higher level queries. From that point of view, it succeeded,
I never met a case* where I wasn't able to build the queries I needed
(see the Thick_Queries package of AdaControl)... although some of them
were quite painful.

* TBH, I should mention a big hole: dispatching calls, where something
is clearly missing.

Of course, everybody has its own opinion about where to put the line
between basic building blocks and do-it-yourself. After all, even Lego
has quite sophisticated (and specialized) pieces nowadays.

(When I was a kid, Lego blocks were just intended to build houses. You
only had rectangular blocks, plaques, and tiles... which didn't prevent
me from building airplanes with these).

-- 
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: GNAT GPL is not shareware

[Robert A Duff]

"J-P. Rosen" <rosen@adalog.fr> writes:

> Le 13/01/2015 22:19, Randy Brukardt a écrit :
>> ASIS 
>> doesn't have enough abstraction for my taste.
> I wasn't part of the initial design of ASIS, but I think the initial
> idea was just to provide basic building blocks, from which everybody
> could build higher level queries. From that point of view, it succeeded,
> I never met a case* where I wasn't able to build the queries I needed
> (see the Thick_Queries package of AdaControl)... although some of them
> were quite painful.

The annoying thing to me is that the compiler has already done that
"quite painful" work, so you're duplicating work.

An example:  ASIS has a query "Has_Limited", which tells you whether a
given piece of syntax (e.g type declaration) has the keyword "limited".
But it doesn't have an "Is_Limited" function that tells you whether
a given subtype is limited.  The ASIS client can implement that
(and I'm guessing you have such a thing and many more in your
Thick_Queries), but it probably takes at least 50 lines of code.
Should an ASIS client really have to implement this (from 7.3.1(5)):

    For example, an array type whose component type is limited private
    becomes nonlimited if the full view of the component type is
    nonlimited and visible at some later place immediately within the
    declarative region in which the array type is declared. ...

when the compiler already did so?

And there are probably hundreds of similar missing "semantic" queries.

> * TBH, I should mention a big hole: dispatching calls, where something
> is clearly missing.

I think I remember something about that, but I've forgotten the
details.  What is missing?

> Of course, everybody has its own opinion about where to put the line
> between basic building blocks and do-it-yourself. After all, even Lego
> has quite sophisticated (and specialized) pieces nowadays.
>
> (When I was a kid, Lego blocks were just intended to build houses. You
> only had rectangular blocks, plaques, and tiles... which didn't prevent
> me from building airplanes with these).

;-)

- Bob

Re: GNAT GPL is not shareware

[J-P. Rosen]

Le 14/01/2015 17:22, Robert A Duff a écrit :

> The annoying thing to me is that the compiler has already done that
> "quite painful" work, so you're duplicating work.
Sure. The "where to put the limit" question.

> An example:  ASIS has a query "Has_Limited", which tells you whether a
> given piece of syntax (e.g type declaration) has the keyword "limited".
> But it doesn't have an "Is_Limited" function that tells you whether
> a given subtype is limited.  The ASIS client can implement that
> (and I'm guessing you have such a thing and many more in your
> Thick_Queries), but it probably takes at least 50 lines of code.
Hmm.... I have that query, it's 168 lines of code.
I remember Tuck being frightened when I told him, he said "and to say we
have a bit for that in the compiler"... Hence the (failed) attempt to
define a higher layer of abstraction.

>> * TBH, I should mention a big hole: dispatching calls, where something
>> is clearly missing.
> 
> I think I remember something about that, but I've forgotten the
> details.  What is missing?
Since you can't statically know what subprogram is being called,
Corresponding_Called_Entity returns Nil_Element in place of the
subprogram declaration. But without a declaration, you cannot know the
formal parameters (so no information about the modes, whether some
parameters are defaulted, etc.)

We need a Corresponding_Called_Root_Entity... I think Serguei added
something like that.
-- 
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: GNAT GPL is not shareware

[Robert A Duff]

"J-P. Rosen" <rosen@adalog.fr> writes:

> Since you can't statically know what subprogram is being called,

Well, you can't know which body will be dispatched to, but formally
speaking, the subprogram being calling is known statically (and might be
abstract).

> Corresponding_Called_Entity returns Nil_Element in place of the
> subprogram declaration.

Hmm.  That seems like just a design mistake in ASIS.  It seems like it
should return the entity denoted by the name in the call (which always
exists statically -- X.all(...) is never a dispatching call).  That is,
Corresponding_Called_Entity should return what you say about
Corresponding_Called_Root_Entity below.

But I think you can work around the problem -- look at the name of the
call and see what it denotes.

>...But without a declaration, you cannot know the
> formal parameters (so no information about the modes, whether some
> parameters are defaulted, etc.)

Right.  That sort of thing is an annoying nuisance.

> We need a Corresponding_Called_Root_Entity... I think Serguei added
> something like that.

I searched for "function Corresponding_Called", and didn't see anything
like that.  So if we have such a thing, it has a different name.
Are you sure you didn't end up working around the problem in the way
I suggested above?

- Bob

Re: GNAT GPL is not shareware

[J-P. Rosen]

Le 15/01/2015 00:43, Robert A Duff a écrit :
> "J-P. Rosen" <rosen@adalog.fr> writes:
> 
>> Since you can't statically know what subprogram is being called,
> 
> Well, you can't know which body will be dispatched to, but formally 
> speaking, the subprogram being calling is known statically (and might
> be abstract).
No, all you could know is a primitive subprogram of an ancestor of the
one being called. The called subprogram may have a different (although
matching) specifications too.

>> Corresponding_Called_Entity returns Nil_Element in place of the 
>> subprogram declaration.
> 
> Hmm.  That seems like just a design mistake in ASIS.  It seems like
> it should return the entity denoted by the name in the call (which
> always exists statically -- X.all(...) is never a dispatching call).
> That is, Corresponding_Called_Entity should return what you say
> about Corresponding_Called_Root_Entity below.
But since it would be incompatible, we need a different query.

> But I think you can work around the problem -- look at the name of 
> the call and see what it denotes.
Corresponding_Name_Definition of the called subprogram returns
Nil_Element in this case (similarly, because the real subprogram cannot
be determined).

>> ...But without a declaration, you cannot know the formal parameters
>> (so no information about the modes, whether some parameters are
>> defaulted, etc.)
> 
> Right.  That sort of thing is an annoying nuisance.
> 
>> We need a Corresponding_Called_Root_Entity... I think Serguei
>> added something like that.
> 
> I searched for "function Corresponding_Called", and didn't see
> anything like that.  So if we have such a thing, it has a different
> name.
Apparently, not done yet. There is a discussion about it in the comments
after Corresponding_Called_Entity specification

> Are you sure you didn't end up working around the problem in
> the way I suggested above?
Oh yes. Look at Adacontrol's user guide, and count the phrases "due to a
shortcoming of ASIS, dispatching calls..."

-- 
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: GNAT GPL is not shareware

[G.B.]

On 13.01.15 22:19, Randy Brukardt wrote:
> ASIS
> doesn't have enough abstraction for my taste.

Meanwhile, in the world of single-vendor languages, Microsoft
is releasing program analysis tools based on its compiler
infrastructure, using Apache 2.0 licensing:

https://github.com/dotnet/roslyn

Re: GNAT GPL is not shareware

[David Botton]

> Meanwhile, in the world of single-vendor languages, Microsoft
> is releasing program analysis tools based on its compiler
> infrastructure, using Apache 2.0 licensing:
> 
> https://github.com/dotnet/roslyn


Amazing how traditional closed source vendors are becoming the heros of open source while the open source vendors are busy trying to use old world failed closed source lock in techniques like shareware...

I'm busy writing gnoga_doc (and the background library for the coming Gnoga IDE it is using) reinventing the wheel (again) because of open source license abuses... It would have been better for me to use ASIS, but since ASIS versions and compiler versions need to match and are not distributed as one package to the FSF everyone loses, again.

The entire goal of open source was to share knowledge, grow from each other and make sure your tools of the trade are not stolen away by some corporate interests, etc. I can't say that the idea has failed but I can't say there is complete success either.

David Botton

Re: GNAT GPL is not shareware

[Simon Wright]

David Botton <david@botton.com> writes:

> It would have been better for me to use ASIS, but since ASIS versions
> and compiler versions need to match and are not distributed as one
> package to the FSF everyone loses, again.

Not quite sure what the problem was .. Debian puts the compiler
dependencies for ASIS (and GNATColl - if Debian has libgnatcoll) in
libgnatvsn.

The latest GNAT GPL includes libgnat_util which does the same.

I made a version of libgnat_util[1] which does the same and includes
tools to build it (rather than just being the finished product, as
AdaCore's is).

GCC 5's build process creates gcc/ada/tools/ which looks as though it
might bear some relationship, I haven't investigated this yet but it
_might_ be the answer to your prayers.

[1] https://sourceforge.net/projects/gnatutil/

Re: GNAT GPL is not shareware

[David Botton]

> Not quite sure what the problem was .. 

In a word:

Windows......

David Botton

Re: GNAT GPL is not shareware

[David Botton]

> In a word:
> 
> Windows......

The reason is simple Ada can not be in a position ever to say "you can't do that" but rather, yes, you can do that too and even better. (..Fill in rant  here..)

I'd be happy to go back to investigating and considering ASIS for sure, I do have most of what I need for documentation parsing done, but there will be much work needed for context sensitive completion in a month or two and I'd rather be reusing and building on what is and GPL licensing for tools is very appropriate, so ASIS's license works.

David Botton

Re: What is the best license to use for open source software?

[jeditekunum]

Interesting conversation about licenses and advocacy.  But I have to say that I think the barriers are far deeper.

I've been interested in Ada for over 20 years.  Every time I decide to put more effort into learning it I quickly become frustrated due to the availability of toolchains for the platforms of interest to me.  It seems to me that is the biggest problem Ada has - without solving that there is no hope for increased popularity.

My most recent increase in interest started only a few months ago.  My platforms are:

1. OSX desktop
2. Solaris x86 server
3. AVR and ARM Cortex-M3/M4 embedded

First question is where to get recent toolchains.  On OSX neither macports or homebrew enable Ada in their gcc builds.  Same for Solaris package repository.

GNAT GPL has OSX but not Solaris.  Doesn't have AVR or ARM hosted on OSX.

gnuada has OSX; has Solaris but not recent; has OSX-hosted ARM Cortex-M4 for two boards.  AVR-Ada requires building from source.

Certainly all these contributions are appreciated however the sum total falls short of giving the comforting feeling that investing in learning and using Ada is wise.

Foolishly I expected that the state of GCC had improved since the last time I messed with building my own.  I thought things would have advanced to the point where I could drop recent non-".0" source onto OSX and Solaris and have it built relatively painlessly.  Once again very disappointed.  Granted most the problems are not specific to Ada.  And by problems I don't mean just finding the right incantation of configure options (of which there are many).  After many hours of struggling I got it built with Ada on both OSX and Solaris.

Next I tackled ARM.  gnu-arm-embedded over on launchpad.net has a source package with build script to create a gcc that can target a variety of ARM processors (maintained by ARM themselves I believe).  Minor tweaking got it to build on OSX with Ada but of course needs a rts from elsewhere.

At this point I'm exhausted.  If I get ARM working and if I get AVR working I will have spent an enormous amount of time just getting working toolchains for my platforms.  Which I will have to repeat all over again at some point in the future due to nothing other than platform progression.  I don't want to become a compiler developer.

This is the same kind of cycle I go through every time I think about getting serious about Ada.  I suspect the vast majority of people aren't going to bother getting this far.

Then I look at Ada here: http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

Despite having worked with C++ a moderate amount I still spend most of my time using C.  Because its stable and ubiquitous.  Those key elements seem to drive most things in computing, not just programming languages.  Sadly the end result seems to be that software remains mediocre, fails to evolve, and has become severely devalued.

Re: What is the best license to use for open source software?

[Jedi Tek'Unum]

On Friday, January 23, 2015 at 5:50:00 AM UTC-6, Jedi Tek'Unum wrote:
> Interesting conversation about licenses and advocacy.  But I have to say that I think the barriers are far deeper.

So this was a bit of a rant - but nonetheless indicative of the situation.  The response - lack of - is always the same.

If the Ada community is not interested in broadly attacking the problem then nothing is going to change.

Re: What is the best license to use for open source software?

[David Botton]

> So this was a bit of a rant - but nonetheless indicative of the situation.  The response - lack of - is always the same.

You make a couple of statements at the end of a thread 150+ messages stating gripes about things you tried but haven't asked for help where you got stuck and somehow that is "indicative of the situation", i.e. that no one picks up on a troll?

> If the Ada community is not interested in broadly attacking the problem then nothing is going to change.

Perhaps:

1. Start a new thread with a specific issue you need help on
2. Start a new thread with one specific issue you want to know how or if is being addressed by others
3. Start a new thread about what _you_ plan on contributing or how you would like to contribute

The Ada community doesn't need people to tell them what is wrong, they need people to do something about it.

When I rant it is part of a clear agenda of a strategic set of actual actions, code, and deliverables, i.e. part of the solution.

It seems that you have skills you can put to use for coding or helping to build reusable non-license viral compiler packages, etc. Looking forward to see your solutions.

David Botton

Re: What is the best license to use for open source software?

[Jedi Tek'Unum]

On Monday, January 26, 2015 at 9:37:34 AM UTC-6, David Botton wrote:
> > So this was a bit of a rant - but nonetheless indicative of the situation.  The response - lack of - is always the same.
> 
> You make a couple of statements at the end of a thread 150+ messages stating gripes about things you tried but haven't asked for help where you got stuck and somehow that is "indicative of the situation", i.e. that no one picks up on a troll?

The thread already had plenty of tangents and it was a few of those that got me here.

> > If the Ada community is not interested in broadly attacking the problem then nothing is going to change.
> 
> Perhaps:
> 
> 1. Start a new thread with a specific issue you need help on
> 2. Start a new thread with one specific issue you want to know how or if is being addressed by others
> 3. Start a new thread about what _you_ plan on contributing or how you would like to contribute
> 
> The Ada community doesn't need people to tell them what is wrong, they need people to do something about it.
> 
> When I rant it is part of a clear agenda of a strategic set of actual actions, code, and deliverables, i.e. part of the solution.
> 
> It seems that you have skills you can put to use for coding or helping to build reusable non-license viral compiler packages, etc. Looking forward to see your solutions.

So the community here would rather shoot the messenger than accept the message?  Like I said, nothing changes.  All the good intentions in the world won't solve it.  Despite individuals making valuable contributions to moving the bar, the bar is still crushingly low.

I don't need help with a specific issue.  I'm very experienced in lots of things but not Ada.  Given the general issue, I am not inclined to become experienced in Ada.  Since I'm retired I have plenty of time on my hands yet this seems too risky even for me.  I should fit the definition of low hanging fruit.

I am not trolling and do not have any agenda to see Ada fail.  On the contrary, on paper Ada looks like something everybody should be using for everything and I'd like to learn it and use it to develop things.

The frustrating thing is that this situation has existed for 20+ years.  It seems the community lacks the critical mass required to converge on effective solutions.

Re: What is the best license to use for open source software?

[G.B.]

"Jedi Tek'Unum" <jeditekunum@gmail.com> wrote:
> On Monday, January 26, 2015 at 9:37:34 AM UTC-6, David Botton wrote:
>>> So this was a bit of a rant - but nonetheless indicative of the
>>> situation.  The response - lack of - is always the same.
>> 
>> You make a couple of statements at the end of a thread 150+ messages
>> stating gripes about things you tried but haven't asked for help where
>> you got stuck and somehow that is "indicative of the situation", i.e.
>> that no one picks up on a troll?
> 
> The thread already had plenty of tangents and it was a few of those that got me here.
> 
>>> If the Ada community is not interested in broadly attacking the problem
>>> then nothing is going to change.

So, when something will have changed, it will be because the Ada community
will have been interested in broadly attacking the problem?

That would exclude numerous reasons for whatever future Ada could have,
wouldn't it?
By comparison, what community would have made Go useful for anything if
Google had not?

> The frustrating thing is that this situation has existed for 20+ years. 
> It seems the community lacks the critical mass required to converge on effective solutions.

Critical mass is seen near fads and big money, adoption of things that
change and transform, come and go.
PLs seem to develop differently: What is needed in order to sustain them is
simply business.
One more reason to appreciate independent Gnoga, e.g. as a way to provide
embedded systems with web views.
These views' supporting technology, i.e. web browsers, is ubiquitous
already.

I wish I had the time to write/vary a template compiler possibly different
from AWS's
that would allow integration of graphics design with Gnoga's way of
creating web views,
by identifying parts to the program via unique id attributes on elements.

Re: What is the best license to use for open source software?

[David Botton]

> I wish I had the time to write/vary a template compiler possibly different
> from AWS's
> that would allow integration of graphics design with Gnoga's way of
> creating web views,
> by identifying parts to the program via unique id attributes on elements.

Actually you don't need anything special, you just can load any HTML as a boot file or place in to view after the fact, then use Gnoga.Client.Bind_Page or just use Attach_With_Parent for each ID.

If you want send me more details on a new thread or the Gnoga list about how you imagine the template compiler would work if more than that. I'm working out the details of the GUI builder and any ideas additional ideas are helpful.

(BTW Gnoga also includes a simple token replace parser and a full parser using embedded Python already).

David Botton

Re: What is the best license to use for open source software?

[Shark8]

On 26-Jan-15 15:46, Jedi Tek'Unum wrote:
>>> If the Ada community is not interested in broadly attacking the problem
>>> then nothing is going to change.
>> >
>> >Perhaps:
>> >
>> >1. Start a new thread with a specific issue you need help on
>> >2. Start a new thread with one specific issue you want to know
>> >   how or if is being addressed by others
>> >3. Start a new thread about what _you_ plan on contributing or
>> >   how you would like to contribute
>> >
>> >The Ada community doesn't need people to tell them what is wrong, they
>> >need people to do something about it.
>> >
>> >When I rant it is part of a clear agenda of a strategic set of actual
>> >actions, code, and deliverables, i.e. part of the solution.
>> >
>> >It seems that you have skills you can put to use for coding or helping to
>> >build reusable non-license viral compiler packages, etc. Looking forward
>> > to see your solutions.
>
> So the community here would rather shoot the messenger than accept the message?
> Like I said, nothing changes.

I don't think that's the point DBotton was making at all; merely that 
extending tangents off of tangents on a thread whose title has little to 
nothing to do with your topic *isn't* the way to get your concerns heard 
-- especially by those who *aren't* interested in licenses.

Re: What is the best license to use for open source software?

[Dmitry A. Kazakov]

On Tue, 27 Jan 2015 00:39:21 +0000 (UTC), G.B. wrote:

> I wish I had the time to write/vary a template compiler possibly different
> from AWS's
> that would allow integration of graphics design with Gnoga's way of
> creating web views,
> by identifying parts to the program via unique id attributes on elements.

There were other template projects initiated, but they didn't go further.

Maybe you could summarize requirements and features, at least. And put them
somewhere as a wiki? So that others would know what is expected.

E.g. one of my requirements when I designed HTTP server implementation was
having it working on a diskless embedded machine. Thus if a template
framework based on files were non-starter to me.

One basic issue more, should the template paradigm be:

A. Substitution-based (some escape sequences in the text);
B. Language-based;
C. Programmable (some API to manipulate the template, plus intermediate
embeddable code, plus GUI editor).

The rough correspondence to the word-processing world:

A were like groff, troff, HTTP, XML
B were like TeX / LaTeX
C were like MS-Word

I would prefer C, AWS solution looks like A.

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

Re: What is the best license to use for open source software?

[Brian Drummond]

On Mon, 26 Jan 2015 14:46:50 -0800, Jedi Tek'Unum wrote:

> On Monday, January 26, 2015 at 9:37:34 AM UTC-6, David Botton wrote:
>> > If the Ada community is not interested in broadly attacking the
>> > problem then nothing is going to change.
>> 
>> Perhaps:
>> 
>> 1. Start a new thread with a specific issue you need help on 
[... other good suggestions snipped]
>
> So the community here would rather shoot the messenger than accept the
> message?  Like I said, nothing changes.  All the good intentions in the
> world won't solve it.  Despite individuals making valuable contributions
> to moving the bar, the bar is still crushingly low.

Suggesting you contribute is not shooting you.

News flash : posting here, you are *part* of the Ada community, not 
something separate from it, outside it looking in. 

Your problems are our problems too. I post here fairly regularly but I'm 
not remotely a major Ada expert, just another small time member of the Ada 
community.

So, you have problems (for example) installing AVR-Ada on OS/X. Probably 
you're the first person to try with your specific combination of packages 
and what worked smoothly for the last guy on the previous release no 
longer works. 

Report the specific problem - if not here, then on the AVR-Ada Sourceforge 
page and work with the nice folks there to resolve it. That's what I did 
(sorry, not for OS/X) and make life *slightly* better for the next guy. I 
mention the AVR because there are a few good people here working on the 
ARM already : watch for announcements.

Cumulatively, that's what it'll take to get us out of the mess you so 
correctly say we're in.

- Brian

Re: What is the best license to use for open source software?

[Jedi Tek'Unum]

On Monday, January 26, 2015 at 6:39:56 PM UTC-6, G. B. wrote:
> "Jedi Tek'Unum" wrote:
> > The frustrating thing is that this situation has existed for 20+ years. 
> > It seems the community lacks the critical mass required to converge on effective solutions.
> 
> Critical mass is seen near fads and big money, adoption of things that
> change and transform, come and go.
> PLs seem to develop differently: What is needed in order to sustain them is
> simply business.

Yet nobody (I suppose there are still niche compiler vendors) really makes any money on C/C++ compilers.  Vendors only invest in them because they have to in order to sustain their ecosystem (Apple, Oracle, etc).  Its other aspects of the ecosystem that generates revenue, not the tools.

With Ada it is an entirely different story.  Vendors (mostly AdaCore) need revenue on the tools themselves because that is all they have for assets.  Their market is very small and not going to grow - they already have the customers who need it.

Its disappointing that Ada is locked into this niche and shows little potential to break out.

I guess the problem is really that "general computing" seems to be decaying in quality, not that it was ever very good.  Most believe "good enough" is just that and refuse to spend anything on something better.  They believe there is no solution to the ongoing maintenance costs and quality problems.  Even when there is.  Inertia (and ignorance) is the killer.

Back to the race to the bottom...

Re: What is the best license to use for open source software?

[David Botton]

> With Ada it is an entirely different story.  Vendors (mostly AdaCore) need revenue on the tools themselves because that is all they have for assets.  Their market is very small and not going to grow - they already have the customers who need it.

Actually, it is not that different at all. AdaCore does near zero R&D unless requested and paid for (at least in large part) directly by a customer. So the only difference is who does the actual development. With C/C++, etc. the customers themselves do the dev work in the case of Ada it is AdaCore generally being outsourced for the work to support some project and the AdaCore supporting the result for them and others interested.

AdaCore doesn't make money on the compiler (even they though are confused about what actual product they are selling sometimes), their product is support contracts, i.e. they are selling resources and talent.

> Its disappointing that Ada is locked into this niche and shows little potential to break out.

It is not "locked" in and I don't believe it has little potential to break out. If that was the case I would not have created Gnoga or continue towards my goals of opening the Ada market beyond that niche, nor would many others bother with their efforts to make Ada available with out a virus.

Since AdaCore doesn't understand how to make money beyond the "grant" model (it is a general issue with academics in business) they've done their best to force customer lock in. This has the unfortunate result of making it very hard for Ada to grow beyond their niche and harms Ada advocacy in general. In time the lack of creativity and R&D will cause an implosion, but most of us here (including myself) are not anti-AdaCore and hopefully what efforts we can make on our own for Ada despite the stumbling blocks they have laid (and yes strangely with their help as well with the FSF upstream, and while it doesn't balance their actions, it at least reduces the sting), our efforts will generate enough interest and market to keep them from imploding sooner but rather much later.


> Most believe "good enough" is just that and refuse to spend anything on something better.

Not 100% true, the issue is that speed to market today is more important than initial quality for most non-safety critical systems.

That however is Ada's greatest value, minimal additional development time for considerable improvements in quality and long term maintainability. 

However no one (yet ;) is marketing that angle since the "niche" market for AdaCore is safety critical and they already understand the need for quality and get what Spark and other Ada related products can add, and can and will pay for AdaCore's only actual product "support".

> Back to the race to the bottom...

I don't feel until you contribute time and product, "damnation" is your right... but being from the US, say what you will and me and the posy working to change things for the better despite the stumbling blocks and not just muck raking will dance on your words when things materialize for the better ;)

I challenge you to make a difference :)

David Botton

Re: What is the best license to use for open source software?

[Jerry Petrey]

On 1/27/2015 4:18 AM, Brian Drummond wrote:

>
> Cumulatively, that's what it'll take to get us out of the mess you so
> correctly say we're in.
>
> - Brian
>


I certainly agree with Brian and David on this issue.  If we believe 
that Ada is truly a great language for embedded applications, we must 
all work to help it succeed in that area. Most users will use what is 
easiest and what others are using to get things done fast and cheap but 
fail to see the true software engineering aspects of software 
development.  Ada is the correct language for software engineering in my 
opinion so I am willing to work with it in spite of the obstacles.

I was happy to see the AdaCore release of the ARM M3/M4 support and 
jumped in to start using it.  I published an article on my early work 
with it in Electronic Design 
(http://electronicdesign.com/dev-tools/armed-and-ready) a few months ago 
and since then I have implemented it on about a dozen different ARM 
M3/M4 boards and created drivers to a number of peripherals (such as 
graphic LCD displays) and implemented support for more of the on-chip 
peripherals that AdaCore did not provide.  I have had to struggle though 
a lot of C code (which I dislike) to redo things in Ada but it is fun 
and educational and to me, worth the effort.
It is like if someone hands you a really nice toolkit - you just want to 
go build something!

Jerry

Re: What is the best license to use for open source software?

[Jedi Tek'Unum]

On Tuesday, January 27, 2015 at 7:16:08 PM UTC-6, David Botton wrote:
> > With Ada it is an entirely different story.  Vendors (mostly AdaCore) need revenue on the tools themselves because that is all they have for assets.  Their market is very small and not going to grow - they already have the customers who need it.
> 
> Actually, it is not that different at all. AdaCore does near zero R&D unless requested and paid for (at least in large part) directly by a customer. So the only difference is who does the actual development. With C/C++, etc. the customers themselves do the dev work in the case of Ada it is AdaCore generally being outsourced for the work to support some project and the AdaCore supporting the result for them and others interested.
> 
> AdaCore doesn't make money on the compiler (even they though are confused about what actual product they are selling sometimes), their product is support contracts, i.e. they are selling resources and talent.

It is still selling resources/talent for a toolset.  I'm not sure who the customers of C/C++ are that are doing the dev work.  Certainly not the end-users like me.  Apple invests in their toolset simply because it needs it to support its other development and 3rd party developers who reinforce their ecosystem.  Same for Oracle and anybody else selling platforms (including RedHat).  The fact that those toolsets are also available to everyone else for free (maybe noncommercial use for some like Oracle) is just another thing they have to do to support the ecosystem.  Its the ecosystem, completely separate from toolsets that they make their money on.

These companies understand that these investments are necessary to make money elsewhere.  Even OSX has become free (granted one is paying for it indirectly in higher hardware cost).

Bottom line is there is no longer a direct link between a programming language and revenue - except for Ada.  And there appears to be no FOSS community capability to evolve Ada on a broad scale.  Which was my original point.  I suppose if AdaCore were to vanish that such a capability may emerge if nothing else from the talent that is available as a result.

> > Its disappointing that Ada is locked into this niche and shows little potential to break out.
> 
> It is not "locked" in and I don't believe it has little potential to break out. If that was the case I would not have created Gnoga or continue towards my goals of opening the Ada market beyond that niche, nor would many others bother with their efforts to make Ada available with out a virus.

It is all a point of perspective - people in this forum are on the inside as it were.  Those not already deep into it have a different view.

I can get past the pain of learning a new language.  I can even get past the pain of custom toolset generation or hunting/gathering the results of contributors here.  What I can't get past at the moment is writing a lot of code (even personal hobby stuff) that may be problematic down the road.

> > Most believe "good enough" is just that and refuse to spend anything on something better.
> 
> Not 100% true, the issue is that speed to market today is more important than initial quality for most non-safety critical systems.
> 
> That however is Ada's greatest value, minimal additional development time for considerable improvements in quality and long term maintainability. 

Having worked at a fortune-500 software company before retiring I can say there is 0 chance of them considering anything other than C/C++ (and some Java).  One could prove a 50% reduction in overall cost and defects and it wouldn't matter.  Its all about being sheep and following the masses.

> > Back to the race to the bottom...
> 
> I don't feel until you contribute time and product, "damnation" is your right... but being from the US, say what you will and me and the posy working to change things for the better despite the stumbling blocks and not just muck raking will dance on your words when things materialize for the better ;)
> 
> I challenge you to make a difference :)

Sorry, I wasn't referring to Ada - I was referring to computing in general.

I hope you are right but I don't think I'm going to stick around to help.  I've spent a career bloodying my head against immovable walls like this.  Life is too short.

Re: What is the best license to use for open source software?

[Vadim Godunko]

On Tuesday, January 27, 2015 at 11:52:28 AM UTC+3, Dmitry A. Kazakov wrote:
> 
> One basic issue more, should the template paradigm be:
> 
> A. Substitution-based (some escape sequences in the text);
> B. Language-based;
> C. Programmable (some API to manipulate the template, plus intermediate
> embeddable code, plus GUI editor).
> 
Matreshka includes templates engine that uses XML format for templates and handles substitutions and conditional processing. Generated output can be XML or optimized HTML (when template uses HTML namespace). See

http://forge.ada-ru.org/matreshka/wiki/XML/Templates

Source template not necessary should be file: it can be any stream of stream elements or sequence of 'markup events' - elements of internal representation of XML document.

Re: What is the best license to use for open source software?

[Dmitry A. Kazakov]

On Wed, 28 Jan 2015 23:03:24 -0800 (PST), Vadim Godunko wrote:

> On Tuesday, January 27, 2015 at 11:52:28 AM UTC+3, Dmitry A. Kazakov wrote:
>> 
>> One basic issue more, should the template paradigm be:
>> 
>> A. Substitution-based (some escape sequences in the text);
>> B. Language-based;
>> C. Programmable (some API to manipulate the template, plus intermediate
>> embeddable code, plus GUI editor).
>> 
> Matreshka includes templates engine that uses XML format for templates and
> handles substitutions and conditional processing. Generated output can be
> XML or optimized HTML (when template uses HTML namespace). See
> 
> http://forge.ada-ru.org/matreshka/wiki/XML/Templates
> 
> Source template not necessary should be file: it can be any stream of
> stream elements or sequence of 'markup events' - elements of internal
> representation of XML document.

That would be A, while I prefer C. E.g. instead of XML:

   <mtl:if expression="boolean_expression">
     ...
   </mtl:if>

Ada's:

   ... & (if Condition then ... else Null_Text end if) & ...

or simply

   ... & Condition * ... & ...

Some set of types HTML_* with operations like "&", "*" etc. Thus no parser,
maybe, parameter binder. Serialize/deserialize for keeping it in a file or
in a database.

I would also try to declare HTML elements as typed constants. The idea is
to ensure the resulted HTML page being correct (e.g. matched elements <b>
</b>) for any set of actual parameters. One flaw of the approaches A and B
is that there is no way to do this.

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

Re: What is the best license to use for open source software?

[Georg Bauhaus]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote:
> On Wed, 28 Jan 2015 23:03:24 -0800 (PST), Vadim Godunko wrote:
> 
>> On Tuesday, January 27, 2015 at 11:52:28 AM UTC+3, Dmitry A. Kazakov wrote:
>>> 
>>> One basic issue more, should the template paradigm be:
>>> 
>>> A. Substitution-based (some escape sequences in the text);
>>> B. Language-based;
>>> C. Programmable (some API to manipulate the template, plus intermediate
>>> embeddable code, plus GUI editor).
>>> 
>> Matreshka includes templates engine that uses XML format for templates and
>> handles substitutions and conditional processing. Generated output can be
>> XML or optimized HTML (when template uses HTML namespace). See
>> 
>> http://forge.ada-ru.org/matreshka/wiki/XML/Templates
>> 
>> Source template not necessary should be file: it can be any stream of
>> stream elements or sequence of 'markup events' - elements of internal
>> representation of XML document.
> 
> That would be A, while I prefer C. E.g. instead of XML:
> 
>    <mtl:if expression="boolean_expression">
>      ...
>    </mtl:if>
> 
> Ada's:
> 
>    ... & (if Condition then ... else Null_Text end if) & ...

No professional designer will accept
Anything like it.


> I would also try to declare HTML elements as typed constants. 

This can be done in programs modelling
HTML documents, but for working with
templates, XML-defined validity and
sometimes even just wellformedness
turns out to be quite enough.

The idea is
> to ensure the resulted HTML page being correct (e.g. matched elements <b>
> </b>) for any set of actual parameters. One flaw of the approaches A and B
> is that there is no way to do this.

XML not matching elements? I must
be misunderstanding something.

Re: What is the best license to use for open source software?

[Georg Bauhaus]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote:
> On Wed, 28 Jan 2015 23:03:24 -0800 (PST), Vadim Godunko wrote:
> 
>> On Tuesday, January 27, 2015 at 11:52:28 AM UTC+3, Dmitry A. Kazakov wrote:
>>> 
>>> One basic issue more, should the template paradigm be:
>>> 
>>> A. Substitution-based (some escape sequences in the text);
>>> B. Language-based;
>>> C. Programmable (some API to manipulate the template, plus intermediate
>>> embeddable code, plus GUI editor).
>>> 
>> Matreshka includes templates engine that uses XML format for templates and
>> handles substitutions and conditional processing. Generated output can be
>> XML or optimized HTML (when template uses HTML namespace). See
>> 
>> http://forge.ada-ru.org/matreshka/wiki/XML/Templates
>> 
>> Source template not necessary should be file: it can be any stream of
>> stream elements or sequence of 'markup events' - elements of internal
>> representation of XML document.
> 
> That would be A, while I prefer C. E.g. instead of XML:
> 
>    <mtl:if expression="boolean_expression">
>      ...
>    </mtl:if>
> 
> Ada's:
> 
>    ... & (if Condition then ... else Null_Text end if) & ...

No professional designer will accept
Anything like it.


> I would also try to declare HTML elements as typed constants. 

This can be done in programs modelling
HTML documents, but for working with
templates, XML-defined validity and
sometimes even just wellformedness
turns out to be quite enough.

The idea is
> to ensure the resulted HTML page being correct (e.g. matched elements <b>
> </b>) for any set of actual parameters. One flaw of the approaches A and B
> is that there is no way to do this.

XML not matching elements? I must
be misunderstanding something.

Re: What is the best license to use for open source software?

[G.B.]

On 29.01.15 09:50, Dmitry A. Kazakov wrote:
> On Wed, 28 Jan 2015 23:03:24 -0800 (PST), Vadim Godunko wrote:
>
>> On Tuesday, January 27, 2015 at 11:52:28 AM UTC+3, Dmitry A. Kazakov wrote:
>>>
>>> One basic issue more, should the template paradigm be:
>>>
>>> A. Substitution-based (some escape sequences in the text);
>>> B. Language-based;
>>> C. Programmable (some API to manipulate the template, plus intermediate
>>> embeddable code, plus GUI editor).
>>>
>> Matreshka includes templates engine that uses XML format for templates and
>> handles substitutions and conditional processing. Generated output can be
>> XML or optimized HTML (when template uses HTML namespace). See
>>
>> http://forge.ada-ru.org/matreshka/wiki/XML/Templates
>>
>> Source template not necessary should be file: it can be any stream of
>> stream elements or sequence of 'markup events' - elements of internal
>> representation of XML document.
>
> That would be A,

Microsoft Word files are A (XML), too. The tool does not
determine the representation.

> while I prefer C. E.g. instead of XML:
>
>     <mtl:if expression="boolean_expression">
>       ...
>     </mtl:if>

The template language need not be XML even when the
template documents are XML.

Also, using XML Processing Instructions (PIs), you could
be specifically using XML and avoid another XML namespace
plus more node names:

  <?gnoga-template-parser  if boolean_expression then ?>
    <div class="visible-instrument">
      ...
    </div>
  <?gnoga-template-parser end if ?>

boolean_expression can very well use Ada syntax, as it
is the job of the XML processor to take care of PIs!

We sometimes use a template language that lets us choose
indicators flexibly, which can mean HTML comments,
and in no way do we need to use namespaces, to get

   <!--[* IF boolean_expression *]-->
     ...
   <!--[* END *]-->

where we chose "<!--[*" and "*]-->" as the indicators.
The templates stay valid XML (XHTML, i.e.) in those
cases. In other cases, we switch indicators so that we can
put things in attribute values.

Design tools might require that JSP syntax or ASP syntax
be understood.

Re: What is the best license to use for open source software?

[Vadim Godunko]

On Thursday, January 29, 2015 at 1:26:24 PM UTC+3, Georg Bauhaus wrote:
> 
> The idea is
> > to ensure the resulted HTML page being correct (e.g. matched elements <b>
> > </b>) for any set of actual parameters. One flaw of the approaches A and B
> > is that there is no way to do this.
> 
> XML not matching elements? I must
> be misunderstanding something.

Wellformed XML (XHTML) template will produce wellformed XML (XHTML) document. Matreshka escapes all "special" characters in substituted data, thus it is impossible to break wellformedness (this is protection from well known attacks in Internet).

In opposite, HTML generator removes some whitespaces and close tags; rewrites attributes, to make resulting document more compact but still valid HTML document.

Re: What is the best license to use for open source software?

[Vadim Godunko]

On 01/29/2015 03:23 PM, G.B. wrote:
>
> Also, using XML Processing Instructions (PIs), you could
> be specifically using XML and avoid another XML namespace
> plus more node names:
>
>   <?gnoga-template-parser  if boolean_expression then ?>
>     <div class="visible-instrument">
>       ...
>     </div>
>   <?gnoga-template-parser end if ?>
>
Use of PI doesn't protect from generation of invalid HTML, just move 
"end if" one line up:

    <?gnoga-template-parser  if boolean_expression then ?>
      <div class="visible-instrument">
        ...
    <?gnoga-template-parser end if ?>
      </div>

close tag for 'div' element will be generated when booloean_expression 
is False for what? :-(

Re: GNAT GPL is not shareware

[Lucretia]

On Monday, 5 January 2015 18:43:57 UTC, Jeffrey Carter  wrote:


> The GNAT Pro/GNAT GPL dichotomy seems unique: two products with essentially
> identical features, differing only in the run-time license. Perhaps we should
> dub GNAT GPL "RTL-ware".

They're not identical feature-wise. Pro has more work put into it than GPL as does GPL over FSF. Therefore, it is crippleware as FSF is buggier than GPL and GPL is buggier than Pro. One feature in Pro may be completely broken in FSF and partially working in GPL. God, it took them years to sort out interfaces.

Re: What is the best license to use for open source software?

[Dmitry A. Kazakov]

On Thu, 29 Jan 2015 10:29:49 +0000 (UTC), Georg Bauhaus wrote:

> No professional designer will accept Anything like it.

No "professional designer" will accept any Ada in first place.

> XML not matching elements? I must
> be misunderstanding something.

You are confusing the input language and the target (object) language.

The idea is to check as much as possible. E.g. HTML tags with parameters
like <img> would be mapped onto Ada subprograms with corresponding typed
parameters (src, alt, height, width).

Using nothing but Ada, of course.

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

Re: What is the best license to use for open source software?

[G.B.]

On 29.01.15 13:47, Vadim Godunko wrote:
> On 01/29/2015 03:23 PM, G.B. wrote:
>>
>> Also, using XML Processing Instructions (PIs), you could
>> be specifically using XML and avoid another XML namespace
>> plus more node names:
>>
>>   <?gnoga-template-parser  if boolean_expression then ?>
>>     <div class="visible-instrument">
>>       ...
>>     </div>
>>   <?gnoga-template-parser end if ?>
>>
> Use of PI doesn't protect from generation of invalid HTML,

It doesn't protect, if used in the way outlined, yes. I'd rather
not use it for bracketing stuff, syntax-wise. Only for simple
substitutions, say.

OTOH, if the instruction can be more "heavy":

     <?gnoga-template-parser
       for Item of Data loop #that-thing;
      ?>
        <tr data-id="that-thing">
          ...
        </tr>

which makes the PI apply to the next element so identified.
It's a bit like providing for writing

    Iterate (Page, Tr'Access);

Re: What is the best license to use for open source software?

[G.B.]

On 29.01.15 14:19, Dmitry A. Kazakov wrote:

>> XML not matching elements? I must
>> be misunderstanding something.
>
> You are confusing the input language and the target (object) language.

No, I wasn't, as I was discussing documents to be used
by both Ada/Gnoga programmers and professional designers,
without any additional level of indirection: HTML 5 elements,
for both I/O of Gnoga programs and I/O of HTML design work.
(HTML 5 Elements seem quite fit for Gnoga programs…)

If you are thinking of a realistic transformation program
between HTML 5 or something above it and Ada source text or
whatever, introducing yet another unnecessary I/O layer,
then that's different.
And what for? HTML 5 editors can be quite MS Word-like.
Also, good luck with even the draft of a practical use case
of automatic transformation that meets real world criteria
of swift programmer response! 8-)

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Thursday, January 29, 2015 at 6:58:35 AM UTC-6, Lucretia wrote:
> On Monday, 5 January 2015 18:43:57 UTC, Jeffrey Carter  wrote:
> > The GNAT Pro/GNAT GPL dichotomy seems unique: two products with essentially
> > identical features, differing only in the run-time license. Perhaps we should
> > dub GNAT GPL "RTL-ware".
> 
> They're not identical feature-wise. Pro has more work put into it than GPL as does GPL over FSF. 
> Therefore, it is crippleware as FSF is buggier than GPL and GPL is buggier than Pro. One feature 
> in Pro may be completely broken in FSF and partially working in GPL. God, it took them years to 
> sort out interfaces.

So how does this play out over time?  Is GPL x years behind and FSF is 2*x years behind?  Does the whole chain evolve over time?  In x more years is GPL the same as Pro today?  Overall is it worse than anything else (clang/llvm for example)?

Re: What is the best license to use for open source software?

[G.B.]

On 29.01.15 14:19, Dmitry A. Kazakov wrote:
> The idea is to check as much as possible. E.g. HTML tags with parameters
> like <img> would be mapped onto Ada subprograms with corresponding typed
> parameters (src, alt, height, width).

Almost all attempts at equating web applications and forms
programming have failed in one way or other.

And on the conceptual side: for a start, targeting "web devices",
one does not usually want _any_ style related instructions in
"business logic", hence no height, no width in Ada source text;
also, one doesn't want any i18n in source text, so you'd have
to introduce indirection to resources outside Ada in any case.

The typing issue cannot be solved practically, because
the "hardware" (browsers) is inconsistent WRT the "language",
leading to contradictory interpretations. Trying to tackle
the inconsistency by case distinction is hard, if at all
possible.

Re: What is the best license to use for open source software?

[Dmitry A. Kazakov]

On Thu, 29 Jan 2015 15:21:27 +0100, G.B. wrote:

> On 29.01.15 14:19, Dmitry A. Kazakov wrote:
> 
>>> XML not matching elements? I must
>>> be misunderstanding something.
>>
>> You are confusing the input language and the target (object) language.
> 
> No, I wasn't, as I was discussing documents to be used
> by both Ada/Gnoga programmers and professional designers,
> without any additional level of indirection: HTML 5 elements,
> for both I/O of Gnoga programs and I/O of HTML design work.
> (HTML 5 Elements seem quite fit for Gnoga programs…)
> 
> If you are thinking of a realistic transformation program
> between HTML 5 or something above it and Ada source text or
> whatever, introducing yet another unnecessary I/O layer,
> then that's different.
> And what for? HTML 5 editors can be quite MS Word-like.
> Also, good luck with even the draft of a practical use case
> of automatic transformation that meets real world criteria
> of swift programmer response! 8-)

If that were the case, no templates were needed.

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

Re: What is the best license to use for open source software?

[Dmitry A. Kazakov]

On Thu, 29 Jan 2015 15:41:04 +0100, G.B. wrote:

> On 29.01.15 14:19, Dmitry A. Kazakov wrote:
>> The idea is to check as much as possible. E.g. HTML tags with parameters
>> like <img> would be mapped onto Ada subprograms with corresponding typed
>> parameters (src, alt, height, width).
> 
> Almost all attempts at equating web applications and forms
> programming have failed in one way or other.

All web applications I saw failed, yet people are keeping on producing web
applications...

> And on the conceptual side: for a start, targeting "web devices",
> one does not usually want _any_ style related instructions in
> "business logic", hence no height, no width in Ada source text;
> also, one doesn't want any i18n in source text, so you'd have
> to introduce indirection to resources outside Ada in any case.
> 
> The typing issue cannot be solved practically, because
> the "hardware" (browsers) is inconsistent WRT the "language",
> leading to contradictory interpretations. Trying to tackle
> the inconsistency by case distinction is hard, if at all
> possible.

Which is exactly an argument in favor of not using HTML directly...

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

Re: GNAT GPL is not shareware

[Jeffrey Carter]

On 01/29/2015 05:58 AM, Lucretia wrote:
> 
> They're not identical feature-wise. Pro has more work put into it than GPL as
> does GPL over FSF. Therefore, it is crippleware as FSF is buggier than GPL
> and GPL is buggier than Pro. One feature in Pro may be completely broken in
> FSF and partially working in GPL. God, it took them years to sort out
> interfaces.

IIUC, GNAT GPL is a snapshot of GNAT Pro at some point with the license
exception removed. They then diverge as work on Pro continues.

-- 
Jeff Carter
"Ditto, you provincial putz?"
Blazing Saddles
86

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-29 20:12, Jeffrey Carter wrote:
> On 01/29/2015 05:58 AM, Lucretia wrote:
>>
>> They're not identical feature-wise. Pro has more work put into it than GPL as
>> does GPL over FSF. Therefore, it is crippleware as FSF is buggier than GPL
>> and GPL is buggier than Pro. One feature in Pro may be completely broken in
>> FSF and partially working in GPL. God, it took them years to sort out
>> interfaces.
> 
> IIUC, GNAT GPL is a snapshot of GNAT Pro at some point with the license
> exception removed. They then diverge as work on Pro continues.
> 

As I understood it, this is partially correct.
But I _think_ that paying customers, that
reports bugs that they think will compromise (somehow)
their business may have the bug-fix in gnat pro only, and
not merge it to gnat fsf or gpl.

So I wonder if gnat gpl really is a true snapshot.

I seem to recall that I've had code that compiles with
fairly old gnat pro (say 5.01), but not with gpl.

But I do not remember the details anymore.

--
Björn

Re: GNAT GPL is not shareware

[Brian Drummond]

On Thu, 29 Jan 2015 06:25:27 -0800, Jedi Tek'Unum wrote:

> On Thursday, January 29, 2015 at 6:58:35 AM UTC-6, Lucretia wrote:
>> On Monday, 5 January 2015 18:43:57 UTC, Jeffrey Carter  wrote:
>> > The GNAT Pro/GNAT GPL dichotomy seems unique: 
>> They're not identical feature-wise. Pro has more work put into it than
>> GPL as does GPL over FSF.
>> Therefore, it is crippleware as FSF is buggier than GPL and GPL is
>> buggier than Pro. One feature in Pro may be completely broken in FSF
>> and partially working in GPL. God, it took them years to sort out
>> interfaces.
> 
> So how does this play out over time?  Is GPL x years behind and FSF is
> 2*x years behind?  Does the whole chain evolve over time?  In x more
> years is GPL the same as Pro today?  Overall is it worse than anything
> else (clang/llvm for example)?

FSF is behind GPL in some respects but usually ahead in others. It is 
based on the current gcc version (e.g. 4.9.3 but you can build from trunk 
if that's not new enough) while GPL is still based on a gcc4.7 release.

So it isn't universally true that FSF has more bugs than GPL : if the bug 
happens to be in the gcc backend, FSF will likely have it fixed sooner. 
If it's in the Gnat part, then the fix probably appears in GPL before it 
is migrated into FSF.

-- Brian

Re: GNAT GPL is not shareware

[Marius Amado-Alves]

> The GNAT Pro/GNAT GPL dichotomy seems unique: two products with essentially
> identical features, differing only in the run-time license.

Not unique at all, this is called "double licensing" and last time I check it was a wide spread model.

I don't understand the above discussion of AdaCore's free GNAT vs. FSF's GCC: is the license not exactly the same (GPL)?

Re: GNAT GPL is not shareware

[G.B.]

On 30.01.15 12:48, Marius Amado-Alves wrote:
>> The GNAT Pro/GNAT GPL dichotomy seems unique: two products with essentially
>> identical features, differing only in the run-time license.
>
> Not unique at all, this is called "double licensing" and last time I check it was a wide spread model.
>
> I don't understand the above discussion of AdaCore's free GNAT vs. FSF's GCC: is the license not exactly the same (GPL)?

The Terms and Conditions are the same with one exception,

-- As a special exception under Section 7 of GPL version 3, you are 
granted --
-- additional permissions described in the GCC Runtime Library 
Exception,   --
-- version 3.1, as published by the Free Software Foundation. 
     --

Which see.

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-30 12:48, Marius Amado-Alves wrote:

> I don't understand the above discussion of AdaCore's 
> free GNAT vs. FSF's GCC: is the license not exactly the same (GPL)?

GPL for the compiler - yes both of then have the same license.
But GNAT GPL, also have GPL'd _runtime_ (files that the compiler
automatically links into the exe),
with makes the OUTCOME of the compiler GPL.

GNAT FSF has a runtime with exceptions,
so the OUTCOME is not GPL'd by the compiler.

In other words, you can make non-GPL programs/libraries
with GNAT-FSF. But EVERYTHING you create with GNAT-GPL
is GPL'd. Automatically.


The GPL part for the compiler concerns changes you do
with the compiler itself.


--
Björn

Re: GNAT GPL is not shareware

[Simon Wright]

Björn Lundin <b.f.lundin@gmail.com> writes:

> In other words, you can make non-GPL programs/libraries
> with GNAT-FSF. But EVERYTHING you create with GNAT-GPL
> is GPL'd. Automatically.

If you build/link against the supplied RTS. But if you don't use an RTS
(see Maciej's post about Ada on Cortex-M), or you use an RTS with the
runtime exception or equivalent (see my STM32F4 GNAT RTS), the GPL
doesn't apply (unless you want it to).

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-01-30 14:50, Simon Wright wrote:
> Björn Lundin <b.f.lundin@gmail.com> writes:
> 
>> In other words, you can make non-GPL programs/libraries
>> with GNAT-FSF. But EVERYTHING you create with GNAT-GPL
>> is GPL'd. Automatically.
> 
> If you build/link against the supplied RTS. But if you don't use an RTS
> (see Maciej's post about Ada on Cortex-M), or you use an RTS with the
> runtime exception or equivalent (see my STM32F4 GNAT RTS), the GPL
> doesn't apply (unless you want it to).
> 

Well, yes, correct.
And that is the (license) difference between GNAT FSF and GNAT GPL
 - The runtime.
So replacing the runtime with non-gpl runtime,
or runtime with gpl-exception would make that
outcome non-gpl, unless other reasons (libs) makes it GPL.

But using GNAT GPL as is, (with default runtime) will make outcome GPL
while GNAT FSF as is, will not.

--
Björn

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Thursday, January 29, 2015 at 2:57:34 PM UTC-6, björn lundin wrote:
> On 2015-01-29 20:12, Jeffrey Carter wrote:
> > On 01/29/2015 05:58 AM, Lucretia wrote:
> >>
> >> They're not identical feature-wise. Pro has more work put into it than GPL as
> >> does GPL over FSF. Therefore, it is crippleware as FSF is buggier than GPL
> >> and GPL is buggier than Pro. One feature in Pro may be completely broken in
> >> FSF and partially working in GPL. God, it took them years to sort out
> >> interfaces.
> > 
> > IIUC, GNAT GPL is a snapshot of GNAT Pro at some point with the license
> > exception removed. They then diverge as work on Pro continues.
> > 
> 
> As I understood it, this is partially correct.
> But I _think_ that paying customers, that
> reports bugs that they think will compromise (somehow)
> their business may have the bug-fix in gnat pro only, and
> not merge it to gnat fsf or gpl.
> 
> So I wonder if gnat gpl really is a true snapshot.
> 
> I seem to recall that I've had code that compiles with
> fairly old gnat pro (say 5.01), but not with gpl.
> 
> But I do not remember the details anymore.

GPL violators are common but nowhere else is an entire language held hostage.

Even commercially-originated languages (Java) are light years ahead in adoption.

Re: GNAT GPL is not shareware

[Jeffrey Carter]

On 01/30/2015 06:50 AM, Simon Wright wrote:
> Björn Lundin <b.f.lundin@gmail.com> writes:
> 
>> In other words, you can make non-GPL programs/libraries
>> with GNAT-FSF. But EVERYTHING you create with GNAT-GPL
>> is GPL'd. Automatically.
> 
> If you build/link against the supplied RTS. But if you don't use an RTS
> (see Maciej's post about Ada on Cortex-M), or you use an RTS with the
> runtime exception or equivalent (see my STM32F4 GNAT RTS), the GPL
> doesn't apply (unless you want it to).

You also have to not "with" any language-defined units.

-- 
Jeff Carter
It's better to be root than to reboot.
119

Re: GNAT GPL is not shareware

[Simon Wright]

Jeffrey Carter <spam.jrcarter.not@spam.not.acm.org> writes:

> On 01/30/2015 06:50 AM, Simon Wright wrote:
>> Björn Lundin <b.f.lundin@gmail.com> writes:
>> 
>>> In other words, you can make non-GPL programs/libraries
>>> with GNAT-FSF. But EVERYTHING you create with GNAT-GPL
>>> is GPL'd. Automatically.
>> 
>> If you build/link against the supplied RTS. But if you don't use an RTS
>> (see Maciej's post about Ada on Cortex-M), or you use an RTS with the
>> runtime exception or equivalent (see my STM32F4 GNAT RTS), the GPL
>> doesn't apply (unless you want it to).
>
> You also have to not "with" any language-defined units.

I don't believe there are any language-defined units that GNAT doesn't
implement as Ada source in the RTS? so it's the licensing terms on the
RTS you actually build against that matters?

I do agree that the argument would be clearer if one stuck to an FSF
compiler.

Re: GNAT GPL is not shareware

[Jeffrey Carter]

On 01/30/2015 10:34 AM, Simon Wright wrote:
> 
> I don't believe there are any language-defined units that GNAT doesn't
> implement as Ada source in the RTS? so it's the licensing terms on the
> RTS you actually build against that matters?

I somehow doubt that Ada.Containers.Hashed_Maps is part of the RTL. It's a
generic pkg that exists only as source. If that source lacks the exception, and
you "with" it, then your code must be GPL, regardless of the RTL the compiler
links in.

-- 
Jeff Carter
It's better to be root than to reboot.
119

Re: GNAT GPL is not shareware

[Simon Wright]

Jeffrey Carter <spam.jrcarter.not@spam.not.acm.org> writes:

> On 01/30/2015 10:34 AM, Simon Wright wrote:
>> 
>> I don't believe there are any language-defined units that GNAT
>> doesn't implement as Ada source in the RTS? so it's the licensing
>> terms on the RTS you actually build against that matters?
>
> I somehow doubt that Ada.Containers.Hashed_Maps is part of the
> RTL. It's a generic pkg that exists only as source. If that source
> lacks the exception, and you "with" it, then your code must be GPL,
> regardless of the RTL the compiler links in.

In GNAT, an RTS is a directory containing adainclude/ (all the RTS
source) and adalib/ (all the corresponding .ali files, and binary
libraries: either static or dynamic (perhaps both)).

Ada.Containers.Hashed_Maps is in files a-cohama.ad[bs], and the version
here in the GNAT GPL library has had the run time exception removed;
whereas the one in the FSF GCC library still has it.

I see no reason in principle why one shouldn't compile the FSF version
with the GPL compiler. A lot of work for no benefit.

I can't at the moment include Ada.Containers.* in my STM32F4 RTS,
because I don't support memory allocation, and AdaCore don't include any
Containers in their Ravenscar RTSs for the same board, and I only have
192K of RAM to play with! but if I did, I'd use the FSF version.

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Simon Wright" <simon@pushface.org> wrote in message 
news:lylhkkcdec.fsf@pushface.org...
...
> I can't at the moment include Ada.Containers.* in my STM32F4 RTS,
> because I don't support memory allocation,

The bounded containers shouldn't require any allocation; there is 
Implementation Advice to avoid that.

If there is an issue, it's probably with finalization. The containers 
themselves aren't supposed to use finalization, but its likely that the 
iterators and references do.

> and AdaCore don't include any
> Containers in their Ravenscar RTSs for the same board, and I only have
> 192K of RAM to play with! but if I did, I'd use the FSF version.

A bounded container is only as big as you need it to be. (Well, unless the 
compiler is doing something unfriendly.) Not having bounded containers is 
pretty much like not having arrays, IMHO.

                                  Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Jedi Tek'Unum" <jeditekunum@gmail.com> wrote in message 
news:dd0af6d6-f6bb-4330-bbf9-b888108df90b@googlegroups.com...

>GPL violators are common but nowhere else is an entire language held 
>hostage.

Bull. The GPL (and free software in general) have destroyed the professional 
software market by devaluing it. (What's less valued than free?). Instead of 
having a vibrant array of choices in both programming languages and 
implementations thereof, you really only have one choice for each (dressed 
up in different packages, but the same thing underlying).

Plenty of other professional languages "are held hostage", because they 
don't even exist (at least in any usable form). There is no way to get them 
built, because there is no hope of making any money on them. All one gets is 
hobby languages built to support trial-and-error (emphasis on the "error") 
program creation. Nothing remotely professional about that.

We'll be lucky if trial-and-error software development doesn't quickly lead 
to the destruction of civilation. All it would take is one uncontrollable 
program that takes over the Internet, or power generation, or water 
supplies, or ...

So one could say that Free Software most likely will lead directly to the 
destruction of human civilization. :-)

                                   Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

I said:
...
> So one could say that Free Software most likely will lead directly to the 
> destruction of human civilization. :-)

I think I best explain this smiley in case someone misinterprets what I 
think here.

I certainly don't believe that Free Software (specifically the GPL) is the 
sole cause of this result, or even the most important cause. It contributes, 
but clearly Twitter and similar systems are much more to blame. (Not to pick 
on Twitter too much, it's just a platform. Someone else would have done it 
if they didn't. It's the mentality of Twitter, the idea that anything 
valuable can be communicated in dribs-and-drabs, that's the problem. All 
that one can communicate in 140 characters are irrelevancies and 
distortions -- because that's all that will fit. Not to mention the frequent 
outright lies.) That instant gratification mentality leads directly to 
trial-and-error software, because people don't think they have the time to 
do it right (they're usually wrong, but the mentality of getting something 
up in 12 hours leads to trying to do too much too quick in some instant 
gratification platform and results in at best unmaintainable junk).

For a lot of people, computers will *have* to run their lives, because they 
won't be capable of anything else. (The recent studies on brain changes 
shows a clear loss of connected thinking in smartphone users.) For them, the 
ultimate result won't matter, so perhaps no one will even notice the loss of 
any valuable civilization.

Has anyone ever wondered why we've never been visited by other intelligent 
life, given that statistically there must be hundreds of thousands of such 
civilizations in our galaxy? One possibility is that intelligent life is 
effectively self-limiting, and we right now are at the peak of possible 
development -- at some point all such life gets so much technology that they 
lose the ability to grow anymore -- and we're right at that point now. (This 
is one of the rare cases that I hope I'm wrong about...)

                              Randy.

Re: GNAT GPL is not shareware

[Dirk Heinrichs]

Randy Brukardt wrote:

> Has anyone ever wondered why we've never been visited by other intelligent
> life, given that statistically there must be hundreds of thousands of such
> civilizations in our galaxy?

Maybe they just have the same problem that we have: The enormous distance 
between them and us. Just a wild guess... ;)

Bye...

	Dirk
-- 
Dirk Heinrichs <dirk.heinrichs@altum.de>
Tel: +49 (0)2471 209385 | Mobil: +49 (0)176 34473913
GPG Public Key CB614542 | Jabber: dirk.heinrichs@altum.de
Tox: heini@toxme.se
Sichere Internetkommunikation: http://www.retroshare.org
Privacy Handbuch: https://www.privacy-handbuch.de

Re: GNAT GPL is not shareware

[Simon Wright]

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

> "Simon Wright" <simon@pushface.org> wrote in message
> news:lylhkkcdec.fsf@pushface.org...
> ...
>> I can't at the moment include Ada.Containers.* in my STM32F4 RTS,
>> because I don't support memory allocation,
>
> The bounded containers shouldn't require any allocation; there is
> Implementation Advice to avoid that.

I thought of them,

> If there is an issue, it's probably with finalization. The containers
> themselves aren't supposed to use finalization, but its likely that
> the iterators and references do.

but Iterator is Limited_Controlled; and I haven't considered Streams.

Streams are what would stop the bounded Booch Components being used in
this context.

>> and AdaCore don't include any
>> Containers in their Ravenscar RTSs for the same board, and I only have
>> 192K of RAM to play with! but if I did, I'd use the FSF version.
>
> A bounded container is only as big as you need it to be. (Well, unless
> the compiler is doing something unfriendly.) Not having bounded
> containers is pretty much like not having arrays, IMHO.

Yes, well, they're on the list.

Re: GNAT GPL is not shareware

[G.B.]

"Randy Brukardt" <randy@rrsoftware.com> wrote:
> "Jedi Tek'Unum" <jeditekunum@gmail.com> wrote in message 
> news:dd0af6d6-f6bb-4330-bbf9-b888108df90b@googlegroups.com...
> 
>> GPL violators are common but nowhere else is an entire language held 
>> hostage.
> 
> Bull. The GPL (and free software in general) have destroyed the professional 
> software market by devaluing it.

Ada, through its better and fully working implementations,
has always suffered from overpricing.

That's not just a frequently heard observation. It's recorded history.

Ada was commissioned to reduce the number of programming languages
(400+, per Whitaker's assessment) used by one large organisation. C has
achieved this goal, in embedded systems or at the OS level.

> Plenty of other professional languages "are held hostage", because they 
> don't even exist (at least in any usable form). There is no way to get them 
> built, because there is no hope of making any money on them. All one gets is 
> hobby languages built to support trial-and-error (emphasis on the "error") 
> program creation. Nothing remotely professional about that.

There are still only very few opportunities for promising academics
and professionals from industry to cooperate on languages in
groundbreaking ways, long term. Like there seems to have been when
Ada did not exists yet, but was wanted. Outside the Big Corps (including
MIT?)
that are producing and controlling languages, there is little public
consultation and cooperation (surprise?).
Individualism disconnected, too strong the hope and the belief that venture
capital plus market mechanism will produce a good solution from individual
offerings. So, we are back to a multitude of incompatible and
incomplete drafts, some of them surviving because of the the Big Corps
and its followers.

Re: GNAT GPL is not shareware

[Brian Drummond]

On Fri, 30 Jan 2015 13:12:24 +0100, Björn Lundin wrote:

> On 2015-01-30 12:48, Marius Amado-Alves wrote:
> 
>> I don't understand the above discussion of AdaCore's free GNAT vs.
>> FSF's GCC: is the license not exactly the same (GPL)?
> 
> GPL for the compiler - yes both of then have the same license. But GNAT
> GPL, also have GPL'd _runtime_ (files that the compiler automatically
> links into the exe),
> with makes the OUTCOME of the compiler GPL.
> 
> GNAT FSF has a runtime with exceptions,
> so the OUTCOME is not GPL'd by the compiler.
> 
> In other words, you can make non-GPL programs/libraries with GNAT-FSF.
> But EVERYTHING you create with GNAT-GPL is GPL'd. Automatically.

Presumably that permits you to use the GPL compiler to produce non-GPL 
executables ... iff they are zero footprint so they include nothing from 
the RTS or libraries.

But outside of embedded microcontrollers, that's a vanishingly rare use 
case.

-- Brian

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Friday, January 30, 2015 at 2:15:34 PM UTC-6, Randy Brukardt wrote:
> "Jedi Tek'Unum" wrote:
> >GPL violators are common but nowhere else is an entire language held 
> >hostage.
> 
> Bull. The GPL (and free software in general) have destroyed the professional 
> software market by devaluing it. (What's less valued than free?). Instead of 

True. But that ship has sailed. All of us must adapt.

> having a vibrant array of choices in both programming languages and 
> implementations thereof, you really only have one choice for each (dressed 
> up in different packages, but the same thing underlying).

There are many proprietary (or non-GCC) C/C++ compilers. Every system vendor
has one. While GCC can be used on any of those platforms I, for one, could
care less - because the native toolset is better AND easier. When a new
version of an OS comes out one can be certain that the platform compiler
"just works". Linux is not everything.

> Plenty of other professional languages "are held hostage", because they 
> don't even exist (at least in any usable form). There is no way to get them 
> built, because there is no hope of making any money on them. All one gets is 

So here we are 30+ years since Ada was created and 20+ years since GNAT
was created. An ISO standard language. Still fractured (3 different
levels - FSF/GPL/Pro) and still huge platform availability barriers.

Ada is not going to grow until that is fixed. Ada has to become a tool
that is used to make money, not the money maker itself. Linux seems
to survive that way.

As long as the predominate maker of Ada technology refuses to enter
the 21st century then Ada is hostage.

> > So one could say that Free Software most likely will lead directly to the 
> > destruction of human civilization. :-)
> 
> I think I best explain this smiley in case someone misinterprets what I 
> think here.
> 
> I certainly don't believe that Free Software (specifically the GPL) is the 
> sole cause of this result, or even the most important cause. It contributes, 
> ...
> outright lies.) That instant gratification mentality leads directly to 
> trial-and-error software, because people don't think they have the time to 
> do it right (they're usually wrong, but the mentality of getting something 
> up in 12 hours leads to trying to do too much too quick in some instant 
> gratification platform and results in at best unmaintainable junk).

And this is new? Broadly speaking, software has always been junk.

> Has anyone ever wondered why we've never been visited by other intelligent 
> life

Because they are afraid of us. We are dangerous/crazy.

> development -- at some point all such life gets so much technology that they 
> lose the ability to grow anymore -- and we're right at that point now. (This 

Tribalism is eating away at everything on every level everywhere. I
include software as well - there are tribes for languages, operating systems,
...

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Saturday, January 31, 2015 at 3:50:02 AM UTC-6, G. B. wrote:
> There are still only very few opportunities for promising academics
> and professionals from industry to cooperate on languages in
> groundbreaking ways, long term. Like there seems to have been when
> Ada did not exists yet, but was wanted. Outside the Big Corps (including
> MIT?)
> that are producing and controlling languages, there is little public
> consultation and cooperation (surprise?).
> Individualism disconnected, too strong the hope and the belief that venture
> capital plus market mechanism will produce a good solution from individual
> offerings. So, we are back to a multitude of incompatible and
> incomplete drafts, some of them surviving because of the the Big Corps
> and its followers.

Not just programming languages. Operating systems are in the same gutter.

I lived through the wild west days of Unix. Forked early. It took many years
for all the players to realize there was advantage to being compatible.
(Converged was never going to happen.) Standardization was moderately
successful and things are definitely better for it.

Then came Linux, which also forked and then converged somewhat less
on the standards.

Then OSX that also moved towards standards.

Leaving us with an "array of choices" that aren't all that vibrant. Yet
much source code is still filled with ifdef hell.

All this combined with the failure of capitalism has left operating systems
in a state of perpetual stagnation.

Really everything in software is stagnated. Hardware too. Everything about
computing has become commoditized. Commoditized chaos is not good.

So back to Ada... Much better foundation technology; no forks. If one were
building software "civilization" from scratch, is there a better language
to start? Would creating yet another programming language really add
anything?

Containers on small systems (Was: GNAT GPL is not shareware)

[Simon Wright]

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

> "Simon Wright" <simon@pushface.org> wrote in message 
> news:lylhkkcdec.fsf@pushface.org...
> ...
>> I can't at the moment include Ada.Containers.* in my STM32F4 RTS,
>> because I don't support memory allocation,
>
> The bounded containers shouldn't require any allocation; there is 
> Implementation Advice to avoid that.
>
> If there is an issue, it's probably with finalization. The containers
> themselves aren't supposed to use finalization, but its likely that
> the iterators and references do.
>
>> and AdaCore don't include any
>> Containers in their Ravenscar RTSs for the same board, and I only have
>> 192K of RAM to play with! but if I did, I'd use the FSF version.
>
> A bounded container is only as big as you need it to be. (Well, unless
> the compiler is doing something unfriendly.) Not having bounded
> containers is pretty much like not having arrays, IMHO.

Of course this is just GNAT, but the amount of support software required
to support their Containers (called in by finalization, exception
propagation, dispatching, streams ...) is large. I see AARM A.18.19(6.a)
indicates that Iterator and Reference types could be left out in
restricted environments (so no "for A of B loop ..."?), which would
eliminate the need for finalization and dispatching .. maybe something
can be done.

What does C++ typically provide for small boards? The full STL? a
subset?

[1] http://www.ada-auth.org/standards/12aarm/html/AA-A-18-19.html#p6.a

Re: GNAT GPL is not shareware

[Marius Amado-Alves]

"Because they are afraid of us. We are dangerous/crazy." (J T'U)

Nah. Mostly harmless.

> ... an "array of choices" that aren't all that vibrant... (J T'U)

Interesting pattern.  Many items (languages, OSes, cars...) badly constructed, instead of a few excellent ones.  A system of mediocrity.  The Plural zones.

(Way off topic now. Philosophy of technology. Sorry.)

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Jedi Tek'Unum" <jeditekunum@gmail.com> wrote in message 
news:6950687c-7b03-440e-ba15-e1092f86a3d0@googlegroups.com...
> On Friday, January 30, 2015 at 2:15:34 PM UTC-6, Randy Brukardt wrote:
...
>> having a vibrant array of choices in both programming languages and
>> implementations thereof, you really only have one choice for each 
>> (dressed
>> up in different packages, but the same thing underlying).
>
> There are many proprietary (or non-GCC) C/C++ compilers. Every system 
> vendor
> has one.

Right. But...

...
>> Plenty of other professional languages "are held hostage", because they
>> don't even exist (at least in any usable form). There is no way to get 
>> them
>> built, because there is no hope of making any money on them. All one gets 
>> is
>
> So here we are 30+ years since Ada was created and 20+ years since GNAT
> was created. An ISO standard language. Still fractured (3 different
> levels - FSF/GPL/Pro) and still huge platform availability barriers.

Now you're complaining that there is *too* much choice in Ada. That's weird, 
Linux doesn't seem to have a problem with too much "fracturing" (Ubuntu, 
Debian, Red Hat, ad nausum...). Nor with platform availability (during most 
of its history, it was only practically available on x86). Not much 
difference between Linux and GNAT on that.

If Ada has a problem, it's that the alternative implementations are weak 
(and expensive in most cases). A truly vibrant community has lots of 
implementations (there were over 80 implementations of Ada 83). And the 
existence of strong standards and a test suite everyone agreed upon meant 
(and still does) that changing implementations is relatively painless 
compared to other languages.

> Ada is not going to grow until that is fixed. Ada has to become a tool
> that is used to make money, not the money maker itself. Linux seems
> to survive that way.
>
> As long as the predominate maker of Ada technology refuses to enter
> the 21st century then Ada is hostage.

Can't even imagine what you mean by this. Ada, as tool, will never make as 
much money as less professional languages. That's because you can't sell 
ongoing maintance to fix software that works right (and thus doesn't need to 
be fixed). Thus, there is very little advantage to using Ada as a contractor 
who makes a living creating software for others. Ada's real advantage is 
within a vertically integrated company - where lower maintance cost is 
actually as saving. But such an organization provides no opportunities for 
the tools creator - they'll use the lowest cost stuff that they can find 
that does the job; and moreover, if they're truly into saving money, they're 
unlikely to spend a lot of money on creating tools, and if they do they'll 
keep them in house. The people who can make money at this have to build 
things that need a lot of fixing (and some lock-in), and Ada programs aren't 
(usually) in that category.

AdaCore is doing the only thing that makes sense to monitize Ada. If there 
was any other way that made sense, my guess is that AdaCore would have tried 
it already.

Sadly, I don't think there is much future for doing things well, because for 
that one can neither sell maintenance nor get much effort for improvement. 
Which ultimately leads to a bleak future for humanity, IMHO.

                                           Randy.

Re: GNAT GPL is not shareware

[David Botton]

> AdaCore is doing the only thing that makes sense to monitize Ada. If there 
> was any other way that made sense, my guess is that AdaCore would have tried it already.

That is unfortunately not the case. They went direct from truly open -> lockin' using GPL as the gun.

Had they actually tried other possibilities like building a vertical solutions market, charging for higher level tools, etc. maybe we could start to say they even tried. They went from libre -> Sony overnight.


> Sadly, I don't think there is much future for doing things well, because for 
> that one can neither sell maintenance nor get much effort for improvement. 
> Which ultimately leads to a bleak future for humanity, IMHO.

Not true building a vertical market on a libre base, offering other services around the language and products, brokering consulting services, job placement services, training, etc. I can think of many other ways to monitize your work on an open source compiler (I say work on because the compiler was and is not the product, that falsehood alone has blinded them to innovation so far).

The one guaranteed long term failure plan history has proven out many times is customer lock-in methods...  I don't predict doom for them, only because enough people care about Ada to try and prevent it, despite themselves.

David Botton

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-02-02 21:44, Randy Brukardt wrote:

> Can't even imagine what you mean by this. Ada, as tool, will never make as 
> much money as less professional languages. That's because you can't sell 
> ongoing maintance to fix software that works right (and thus doesn't need to 
> be fixed). Thus, there is very little advantage to using Ada as a contractor 
> who makes a living creating software for others.

I'm not clear of if you are talking about creating Ada compilers or
creating software using Ada. If the latter, there is perhaps not so much
maintenance in form of error fixes (but they occur too),
but lots of maintenance in implementing changes, as in
changed requirements.

And I know that I'm a bit unusual here, making a living on
a mostly administrative system, but those (WMS/WCS systems) tend to live
for 10 to 20 years, and company business changes during that time,
driving changes. And I find using Ada a big advantage, easing
the change.

--
Björn

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Monday, February 2, 2015 at 2:44:20 PM UTC-6, Randy Brukardt wrote:
> "Jedi Tek'Unum" wrote in message 
> > So here we are 30+ years since Ada was created and 20+ years since GNAT
> > was created. An ISO standard language. Still fractured (3 different
> > levels - FSF/GPL/Pro) and still huge platform availability barriers.
> 
> Now you're complaining that there is *too* much choice in Ada.

Choice is good when it is similarly functional options.  Valid code that doesn't work on all of them is a problem!

The non-Pro should be the bleeding edge constantly being updated with fixes and enhancements.  The Pro should be the delayed quality version.

> That's weird, 
> Linux doesn't seem to have a problem with too much "fracturing" (Ubuntu, 
> Debian, Red Hat, ad nausum...). Nor with platform availability (during most 
> of its history, it was only practically available on x86). Not much 
> difference between Linux and GNAT on that.

I don't use Linux for a variety of reasons, that being one.

I suppose I'm now considered outdated but when something isn't available for Solaris something is wrong.  Perhaps the ACT thinking is that the GPL version only needs to be on "Desktop" OSes.  (Probably because they only see it as an evaluation release and a minimal way to appear to be complying with the GPL.) Yet this retired guy runs Solaris on his server because it simply kicks butt.  The same argument about using Ada because it is the best language applies to OSes too.  (Yeh, I can [and have] built Ada for Solaris - painfully.)

> Can't even imagine what you mean by this. Ada, as tool, will never make as 
> much money as less professional languages. That's because you can't sell 
> ongoing maintance to fix software that works right (and thus doesn't need to 
> be fixed).

So Ada kills itself then?

> AdaCore is doing the only thing that makes sense to monitize Ada. If there 
> was any other way that made sense, my guess is that AdaCore would have tried 
> it already.

And that is the problem.  A programming language largely controlled by one company that needs to monetize it.

Seems that Sun was able to create Java and monetize it (even more so with Oracle).  Yet I can still use it for my own development for free.  (Same for Solaris.)  Free for non-commercial uses is a perfect balance and it works.  Linux is free yet lots of companies seem to be making a lot of money on it.  I just don't believe that there isn't a way that can work for everyone.

> Sadly, I don't think there is much future for doing things well, because for 
> that one can neither sell maintenance nor get much effort for improvement. 
> Which ultimately leads to a bleak future for humanity, IMHO.

Agreed.  So how can we fix it?

Re: GNAT GPL is not shareware

[Randy Brukardt]

"David Botton" <david@botton.com> wrote in message 
news:a48c3f8f-dcee-4d66-aafb-8f3c13733b53@googlegroups.com...
>> Sadly, I don't think there is much future for doing things well, because 
>> for
>> that one can neither sell maintenance nor get much effort for 
>> improvement.
>> Which ultimately leads to a bleak future for humanity, IMHO.

>Not true building a vertical market on a libre base, offering other 
>services
>around the language and products, brokering consulting services, job
>placement services, training, etc. I can think of many other ways to 
>monitize
>your work on an open source compiler (I say work on because the compiler
>was and is not the product, that falsehood alone has blinded them to
>innovation so far).

I don't believe most of this. For one thing, AdaCore has lots of 
non-compiler products; they've clearly tried (and are trying) to provide 
many things other than the compiler.

Indeed, a compiler has *never* been a product. The product at the very least 
is an ecosystem of development tools. A compiler alone is not a very useful 
thing. And while the language is standardized, those other things are not. 
As such, vendor lock-in is almost inevitable -- changing IDEs, project 
management, debuggers, etc. is a lot more difficult than changing compilers.

But I contend that any business model based on software is ultimately 
doomed. Free Software has made it far too easy to copy any good ideas -- on 
top of which the later implementations can avoid mistakes made in the first. 
The pioneer, the visionary has no hope of making any money off their work --  
in order to make money, they have to do something totally unrelated ("job 
placement", what the heck does that have to do with anything?) and that 
takes way too much time away from the thing that would actually do good.

>The one guaranteed long term failure plan history has proven out many times
>is customer lock-in methods...  I don't predict doom for them, only because
>enough people care about Ada to try and prevent it, despite themselves.

I agree if you're only talking about lock-in alone. Customers get wise to 
that in a hurry. OTOH, GPS, gprbuild, etc. are also things that cause 
lock-in. But it would be hard to have a useful development system without 
something like those things. So to some extent, lock-in is pretty much 
built-into the territory.

                                                     Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Jedi Tek'Unum" <jeditekunum@gmail.com> wrote in message 
news:c5fe4081-ed33-40f4-a5a5-5c9d44744c45@googlegroups.com...
On Monday, February 2, 2015 at 2:44:20 PM UTC-6, Randy Brukardt wrote:
...
>I suppose I'm now considered outdated

Yup. :-)

>...but when something isn't available for Solaris something is wrong.

Nothing is available for Solaris. :-) I don't know why anyone would bother 
making anything for a dead system. How do you get tax software or 
bookkeeping software or any of the other things that one needs to do on a 
computer? My home computer runs Windows 98. I don't complain that nothing 
new runs on it anymore. :-)

We started a version for SunOS once, but that never went anywhere. So these 
days Janus/Ada is only available on Windows. I'd like to have it on Linux 
and possibly OSX, but I really see no point in anything else for a host. 
(Targets of course are a different issue.)

>> Can't even imagine what you mean by this. Ada, as tool, will never make 
>> as
>> much money as less professional languages. That's because you can't sell
>> ongoing maintance to fix software that works right (and thus doesn't need 
>> to
>> be fixed).
>
>So Ada kills itself then?

Dies a slow death, pretty much like everything else worthwhile.

>> AdaCore is doing the only thing that makes sense to monitize Ada. If 
>> there
>> was any other way that made sense, my guess is that AdaCore would have 
>> tried
>> it already.
>
>And that is the problem.  A programming language largely controlled by one
>company that needs to monetize it.

Ada has never been "controlled by" one company. It's controlled by the Ada 
standard, which has been independently maintained since it was originally 
created.

Perhaps it bothers you that all of the Ada implementations were created by 
commercial companies that are trying to make money. But it's rather 
un-American to be against capitalism. :-)

>Seems that Sun was able to create Java and monetize it

Really? The primary reason Sun went out of business was that they couldn't 
monetize Java enough for investors. They had to sell at a fire sale price to 
Oracle.

> (even more so with Oracle).

Everything I read suggests that Oracle has done more harm than good for the 
stuff that they acquired from Sun. They killed off OpenOffice and several 
other such products by trying to extract money -- they ended up forked or 
disappeared. Java survives in spite of Oracle's monitization attempts, not 
because of it.

>Yet I can still use it for my own development for free.

And you get what you pay for. :-)

>  (Same for Solaris.)  Free for non-commercial uses is a perfect balance 
> and it works.

Yeah, because there is no such thing as a "non-commercial" use that matters. 
Such users would never have bought the software in the first place. But 
almost all projects of interest at least have the potential for becoming 
commercial. And then what? You either have to change to something else or 
pay $$$$. Nice bait-and-switch. At least with the GPL you know the score 
going in.

> Linux is free yet lots of companies seem to be making a lot of money
> on it.  I just don't believe that there isn't a way that can work for 
> everyone.

I don't see it. It's not like I haven't tried to find such a way. I'd like 
to make more money than a bus driver, but I don't see how short of giving up 
on doing things right and taking a C job.

>> Sadly, I don't think there is much future for doing things well, because 
>> for
>> that one can neither sell maintenance nor get much effort for 
>> improvement.
>> Which ultimately leads to a bleak future for humanity, IMHO.
>
>Agreed.  So how can we fix it?

Kill all the marketers? :-)

I don't think it can be fixed. You can't stuff this genie back in the 
bottle.

                                     Randy.

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Tuesday, February 3, 2015 at 2:36:29 PM UTC-6, Randy Brukardt wrote:
> "Jedi Tek'Unum" wrote:
> >...but when something isn't available for Solaris something is wrong.
> 
> Nothing is available for Solaris. :-) I don't know why anyone would bother 
> making anything for a dead system. How do you get tax software or 
> bookkeeping software or any of the other things that one needs to do on a 
> computer? My home computer runs Windows 98. I don't complain that nothing 
> new runs on it anymore. :-)
> 
> We started a version for SunOS once, but that never went anywhere. So these 
> days Janus/Ada is only available on Windows. I'd like to have it on Linux 
> and possibly OSX, but I really see no point in anything else for a host. 
> (Targets of course are a different issue.)

Wow. I see your :-) but that really impacts credibility. The world has
never been about Windows, +Linux, +OSX. The desktop realm is not the
universe and, as you point out, mostly dead from a revenue perspective. There
is a lot of important stuff that runs elsewhere - and the bulk of it isn't
embedded stuff. You are starting to sound like one of those tribes I
mentioned earlier (Windows?). If so, then you are certainly out of date
as well - Windows is a zombie that doesn't yet understand it is dead :-)

I can't stand Windows or Linux; that is my *personal* preference. I want
important infrastructure software to run EVERYWHERE - equally! If I write
a pile of software I don't want my options constrained by what somebody
else thinks is worthwhile.

If Ada only means desktops and embedded targets then I'm definitely
without interest.

Is Ada just another tribe or does it mean MORE?

> Ada has never been "controlled by" one company. It's controlled by the Ada 
> standard, which has been independently maintained since it was originally 
> created.
> 
> Perhaps it bothers you that all of the Ada implementations were created by 
> commercial companies that are trying to make money. But it's rather 
> un-American to be against capitalism. :-)

A language without widespread availability, the same implementation or
not, is bound to be a failure. Widespread doesn't mean desktops + embedded.

> >Seems that Sun was able to create Java and monetize it
> 
> Really? The primary reason Sun went out of business was that they couldn't 
> monetize Java enough for investors. They had to sell at a fire sale price to 
> Oracle.

That sounds pretty tribal to me. For someone that used to work in that market
segment I know that is not the case. Sun had to sell because its biggest
buyers (banks, government, etc) stopped buying when the economy collapsed.
What did that have to do with product? They just didn't have enough other
revenue sources like professional services to ride it through.

I'd say Sun/Oracle is healthier than IBM or HP (which are just professional
services orgs now). Microsoft isn't in good shape either.

Why hasn't free software suppressed Apple? Does their universe not revolve
around software? (I know why - because its that much better!)
[Not perfect - better.] 

> > (even more so with Oracle).
> 
> Everything I read suggests that Oracle has done more harm than good for the 
> stuff that they acquired from Sun. They killed off OpenOffice and several 
> other such products by trying to extract money -- they ended up forked or 
> disappeared. Java survives in spite of Oracle's monitization attempts, not 
> because of it.

I wouldn't disagree about Oracle. Yet here I am still running the latest
Solaris and Studio (C/C++) on my x86_64 server for free. Note I said server.
I don't play with Java but I could. (My desktop is OSX.)

OpenOffice lives at Apache Foundation. A good thing. I suspect VirtualBox
is headed the same way - another good thing. I somewhat wish Solaris would go
the same way but then it would decay quickly due to the mob of inferior
"developers". If Oracle decided they weren't going to allow free non-commercial
use AND the cost was commensurate with the value, I would be willing to pay
for it because it is just that good.

Interesting how you so willing cast aside the best industrial strength
OS ever made while pontificating the best programming language.

> >Yet I can still use it for my own development for free.
> 
> And you get what you pay for. :-)

I don't pay for Ada. :-)

And so by your reasoning I could have the wonderful walled garden if
I paid. I doubt it.

> almost all projects of interest at least have the potential for becoming 
> commercial. And then what? You either have to change to something else or 
> pay $$$$. Nice bait-and-switch. At least with the GPL you know the score 
> going in.

Yep, you get something that you cannot depend on at all.

I can see that your gripe is that you make a living selling Ada products
and services. And indirectly that if Ada can't generate revenue for someone
that it shouldn't be used. Hence the hostage term I've used.

I don't like what totally free garbage software has done to the world -
and is going to continue to make worse in the future. But I also know that
bloodthirsty capitalism doesn't work either. Both extremes result in
chaotic fragmented mediocrity.

Re: GNAT GPL is not shareware

[Jeffrey Carter]

On 02/03/2015 01:36 PM, Randy Brukardt wrote:
> "Jedi Tek'Unum" <jeditekunum@gmail.com> wrote in message 
>>
>> And that is the problem.  A programming language largely controlled by one
>> company that needs to monetize it.
> 
> Perhaps it bothers you that all of the Ada implementations were created by 
> commercial companies that are trying to make money. But it's rather 
> un-American to be against capitalism. :-)

I think we can conclude from the name that Jedi Tek'Unum is from a galaxy far,
far away.

-- 
Jeff Carter
"Death awaits you all, with nasty, big, pointy teeth!"
Monty Python & the Holy Grail
20

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Tuesday, February 3, 2015 at 2:36:29 PM UTC-6, Randy Brukardt wrote:
> Perhaps it bothers you that all of the Ada implementations were created by 
> commercial companies that are trying to make money. But it's rather 
> un-American to be against capitalism. :-)

BTW, For an expert you seem to be confused about truth. American taxpayers paid for the language creation and the first and now dominate implementation.

Re: GNAT GPL is not shareware

[David Botton]

>I don't believe most of this. For one thing, AdaCore has lots of 
> non-compiler products; they've clearly tried (and are trying) to provide 
> many things other than the compiler.

Wrong, they didn't have any other products in production when they made the decision to pull the license gun and they simply didn't try a single thing else.

They could have tried keeping other tools proprietary and many other options. All of which would have been better choices for the community and for long term bottom lines.

> But I contend that any business model based on software is ultimately 
> doomed.

Not true, there is money just not directly in essential tools and that was and is a part of a social movement to prevent someone taking away your hammer (cough cough... and here some have tried in the name of Free Software...)

> Free Software has made it far too easy to copy any good ideas

That is the idea, innovate. With innovation also comes the challenge of innovating how to fund such projects as well.

> The pioneer, the visionary has no hope of making any money off their work 

No, he just needs to know how to make money (or how to partner with others that know how to make money) in different ways. Many, including myself, have done well in software and continue to do so. Most (perhaps today none) of us do not do it through direct sales.

>they have to do something totally unrelated ("job 
> placement", what the heck does that have to do with anything?)

A pull out of the hat example of cross domain revenue streams, head hunting even in Ada has made money for many.

> and that 
> takes way too much time away from the thing that would actually do good.

As time goes on competition gets stronger and requires more creativity and "different" types of hard work for payouts.

David Botton

Re: GNAT GPL is not shareware

[David Botton]

> BTW, For an expert you seem to be confused about truth. American taxpayers paid for the language creation and the first and now dominate implementation.

Actually Jeff was the one who pointed out the full scope of how that went down.

As I've pointed out many times, history has proven AdaCore's approach harms the Ada community past and present, but they have not trashed the community and have respected the Open Source movement enough that they have up-streamed over time their innovations to the original technology back to the FSF.

AdaCore may not be heros (they lost that status 10 years ago), but they are not villains by any account.

David Botton

Re: GNAT GPL is not shareware

[Pascal Obry]

David,

> Wrong, they didn't have any other products in production when they made the decision to pull the license gun and they simply didn't try a single thing else.

"licence gun" is a bit strong to me.

The only difference with GPL is that you must give the source if you
sell the software to customers asking for them. In many many cases this
is just ok (except if you plan working in the defense area or some other
critical projects), so I still think it is perfectly possible to do
business with the GPL compiler and libraries.

Isn't this an option for you?

-- 
  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: GNAT GPL is not shareware

[Mark Carroll]

Pascal Obry <pascal@obry.net> writes:

> The only difference with GPL is that you must give the source if you
> sell the software to customers asking for them.

No, it also means that those customers can pass it on to anyone else,
modify and resell it or give it away, whatever. The GPL is about far
more than just making the source available to customers.

-- Mark

Re: GNAT GPL is not shareware

[Pascal Obry]

Le mercredi 04 février 2015 à 08:00 +0000, Mark Carroll a écrit : 
> No, it also means that those customers can pass it on to anyone else,
> modify and resell it or give it away, whatever. The GPL is about far
> more than just making the source available to customers.

And? Do we have a single example of this happening?

That's just fear and doubt to me. Someone paying you to do a software
which will fit their very own needs do not have time to sell it or
whatever. They want to use it for their productivity need. And their is
also some case where a software is so tailored for some specific use
that no one else will be able to use it in their workflow.

-- 
  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: GNAT GPL is not shareware

[Simon Wright]

Pascal Obry <pascal@obry.net> writes:

> The only difference with GPL is that you must give the source if you
> sell the software to customers asking for them. In many many cases
> this is just ok (except if you plan working in the defense area or
> some other critical projects), so I still think it is perfectly
> possible to do business with the GPL compiler and libraries.

The UK MoD required access to the source code that we produced for
them. I'm not sure if that's always the case, and of course it didn't
apply to software that we bought in (there had to be some negotiation
about escrow, AFAICR).

Re: GNAT GPL is not shareware

[G.B.]

On 04.02.15 09:38, Pascal Obry wrote:
> Le mercredi 04 février 2015 à 08:00 +0000, Mark Carroll a écrit :
>> No, it also means that those customers can pass it on to anyone else,
>> modify and resell it or give it away, whatever. The GPL is about far
>> more than just making the source available to customers.
>
> And? Do we have a single example of this happening?

We have all seen this "re-distribution at no cost"
happening in the closed source business:

Microsoft got its market share also by insufficiently
protecting their office software from being copied.
They have continued to get market share by trying
to make the first encounter with computers cost-free,
e.g. to students and to researchers at universities.
(And to some African governments, they say.)

"Do you have a copy of ... for me?" is not unheard of
by anyone who had a PC.

Imagine OTOH what it would mean to Microsoft if they
started to sell Microsoft Office under a copyleft license!
I believe it would either kill them at once, or at least
make the company shrink a lot. Because the ROI depends on
the decency of users, a trait that is not shared by everyone
everywhere, in particular after the software market was
flooded for a long time with copies of pricey software
at no cost. Microsoft is not wealthy because of a developer
support business, TTBOMK, so they'd suffer from any kind
of uncontrollable "free" distribution, such as copyleft
or BSD.

The market for MS has been a mass market, and also
comparatively anonymous. Does such a market work for
vendors producing GPLed pieces of software?
First, assume a sum of $$ or $$$ per copy sold.
Is this enough money for the kind of software you
have in mind? I guess making this type of software will
take a larger number of customers who pay for a copy.
Try crowd funding.
And then, a sufficiently large fraction of customers
must prefer to not give away copies for free. Instead,
you would want them to point others to you, the producer.
Is this a realistic business plan?

I doubt that you can sell GPLed or otherwise freely
redistributable software if there isn't a contract
between two parties aware of business needs,
enough money to keep production going for some time,
and no intention to betray.

So, if there is an example of a piece of GPLed software
fully financing a business, then it is an example of an
exceptional situation, I think.

Re: GNAT GPL is not shareware

[David Botton]

> "licence gun" is a bit strong to me.

It is strong and meant to be. Ada advocacy was shot by the change.

> The only difference with GPL

No, there is a difference for advocacy do to market perception and needs for small developers.

I've discussed this many times, consulting customers don't care what you explain about GPL licensing. From a small real estate office to multi-billion dollar companies, almost no one will accept a consultant choosing a tool that forces GPL on their "IP".

> Isn't this an option for you?

I would never have chosen to write a single line of Ada had the runtime had the GPL virus when I started. I specifically chose Ada because of the GMGPL and I specifically stopped developing (for years) public Ada projects since with out it Ada is a waste of any developers time not employed by someone in the AdaCore niche customer demographic.

Things have changed enough with non-license virused FSF gcc/ada for me to invest time again in Ada and Ada advocacy.

Ada advocacy still needs stronger work on marketing FSF Ada as the professional choice for non-safety critical system and packaging (both in terms of available tools and libraries that are GMGPL and actual delivery on Windows, etc).

Advocating Ada already takes a lot of effort to educate others to understand why it is more beneficial, we don't need to be forced to educate them also about the GPL as a beneficial as a social movement to be part of that advocacy. Even the FSF realizes that is a mistake...

David Botton

Re: GNAT GPL is not shareware

[David Botton]

> So, if there is an example of a piece of GPLed software
> fully financing a business, then it is an example of an
> exceptional situation, I think.

Exactly. I do know some examples of direct sales that have worked, but they are few.

However GPL/Libre Software is the indirect cause for more money than anyone can count.

First comes the hammer, the initial sale of the hammer and the big money it makes, people start using hammers, competition in the hammer market starts, the price of hammers drops and there is no business in making hammers eventually.

If a company is too short sighted to understand that you need to go beyond hammer direct sales... well what happens happens.

How much money is wasted on litigation to slow the bleed using IP laws... If that same money was invested in advancing tech and R&D for the companies in future directions, etc......

David Botton

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-02-04 09:38, Pascal Obry wrote:
> Le mercredi 04 février 2015 à 08:00 +0000, Mark Carroll a écrit : 
>> No, it also means that those customers can pass it on to anyone else,
>> modify and resell it or give it away, whatever. The GPL is about far
>> more than just making the source available to customers.
> 
> And? Do we have a single example of this happening?
> 
> That's just fear and doubt to me. 

And that is powerful.
I've tried to convince my bosses that we should
deploy/sell on Linux. And use GNAT GPL.
But no go, due to the _possibility_
that our competitors may see the source.

Of course, in reality this is nonsense.
We ship the code to our customers anyway,
but they (managers that is) _feel_ confident that
no one is allowed to change/re-distribute the code but us.

I _highly_ doubt that anyone would dissect our code,
and take business advantage of it.

However, a real threat (to our business) would be ex-co-workers,
that can sell consultant hours, and do changes to the code.

So it is partly fear and doubt, but also some more


--
Björn

Re: GNAT GPL is not shareware

[Björn Lundin]

On 2015-02-03 23:54, Jedi Tek'Unum wrote:
> I don't pay for Ada. :-)
> 
> And so by your reasoning I could have the wonderful walled garden if
> I paid. I doubt it.

If you do pay for Ada, you could get it for Solaris.

<http://www.adacore.com/gnatpro/platforms>

at least 32-bit

--
Björn

Re: GNAT GPL is not shareware

[Simon Wright]

Björn Lundin <b.f.lundin@gmail.com> writes:

> On 2015-02-03 23:54, Jedi Tek'Unum wrote:
>> I don't pay for Ada. :-)
>> 
>> And so by your reasoning I could have the wonderful walled garden if
>> I paid. I doubt it.
>
> If you do pay for Ada, you could get it for Solaris.
>
> <http://www.adacore.com/gnatpro/platforms>
>
> at least 32-bit

I built GCC 4.7.0 for Solaris 11 on x86; see
http://forward-in-code.blogspot.co.uk/2012/05/building-gcc-with-ada-on-solaris-x86.html

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Jedi Tek'Unum" <jeditekunum@gmail.com> wrote in message 
news:b09289f2-df64-464b-ab22-def6b2357bdb@googlegroups.com...
> On Tuesday, February 3, 2015 at 2:36:29 PM UTC-6, Randy Brukardt wrote:
...
>> >Yet I can still use it for my own development for free.
>>
>> And you get what you pay for. :-)
>
> I don't pay for Ada. :-)

Exactly. The best Ada implementations I;ve ever used were never free.

...
> I can see that your gripe is that you make a living selling Ada products
> and services. And indirectly that if Ada can't generate revenue for 
> someone
> that it shouldn't be used. Hence the hostage term I've used.

Replace the word "Ada" by "software" and you'd be corrrect. It's not about 
Ada, it's about any software; if the developer can't make a living from it, 
then it necessarily has to be a secondary project (because everyone has to 
make a living somehow). In which case the quality will suffer.

Part of my objection to your rant here is that you keep making this about 
Ada. It's not about Ada, its about any software with built professionally 
(or, practically any other way). There's nothing special about Ada in this 
regard, there are only a few things that truly are available everywhere.

                                                Randy.

Re: GNAT GPL is not shareware

[Randy Brukardt]

"Jedi Tek'Unum" <jeditekunum@gmail.com> wrote in message 
news:32313ac1-a8d2-48be-aaf1-6a89d2dc4c77@googlegroups.com...
> On Tuesday, February 3, 2015 at 2:36:29 PM UTC-6, Randy Brukardt wrote:
>> Perhaps it bothers you that all of the Ada implementations were created 
>> by
>> commercial companies that are trying to make money. But it's rather
>> un-American to be against capitalism. :-)
>
> BTW, For an expert you seem to be confused about truth.

Must be that after 35 years working in Ada that I've forgotten who paid for 
what. Not likely.

> American taxpayers paid for the language creation and the first and now 
> dominate implementation.

If you're talking indirectly, American taxpayers paid for the creation of 
the entire electronics industry. So what?

As far as the standard goes, I mentioned that it was and continues to be 
developed independent of any developer. I was clearly talking about 
implementations.

And as far as the implementations, none of them have had any significant 
portion funded directly by the government. A lot of the customers were 
government contractors, so one could say that the companies were indirectly 
funded by taxpayer dollars. But a capitalist doesn't care all that much who 
the customers are, just that they can serve them properly. And of course if 
you look broadly, the American taxpayers has paid for a large part of almost 
everything. You could say that about almost any company or industry.

                                       Randy.

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Wednesday, February 4, 2015 at 1:42:01 PM UTC-6, Simon Wright wrote:
> Björn Lundin writes:
> > On 2015-02-03 23:54, Jedi Tek'Unum wrote:
> >> I don't pay for Ada. :-)
> >> 
> >> And so by your reasoning I could have the wonderful walled garden if
> >> I paid. I doubt it.
> >
> > If you do pay for Ada, you could get it for Solaris.
> >
> > <http://www.adacore.com/gnatpro/platforms>
> >
> > at least 32-bit

I wouldn't take out another mortgage so I could buy it. I'm non-commercial use and for that they might as well be flipping me the bird.

> I built GCC 4.7.0 for Solaris 11 on x86; see
> http://forward-in-code.blogspot.co.uk/2012/05/building-gcc-with-ada-on-solaris-x86.html

I have 4.9.2 built on Solaris 11.1 x86. Years ago I stepped through several versions of gcc building up from a really old version that I had.

My point isn't that it can't be done but that it takes a lot of effort in general. I thank Simon for building and publishing it but it is a bit old - especially the ".0" is scary. Any semblance of "current" requires one to build their own - and it isn't a drop it in and hit go proposition (typical of gcc). The average developer is not going to spend that time to get it running.

I briefly tried 64bit but gcc is even more broken there. Solaris isn't a "chosen one" for gcc in general, not just Ada.

So I have a working Ada on Solaris, and on OSX, and even (thanks to Simon) an OSX cross to STM32F429I board. Still doesn't cover everything I play with (other ARM, larger AVR [yeh, I know I could get AVR-Ada]). But even if it did, the expense of time required to repeat this hunter/gather operation every couple of years as platforms evolve presents a big barrier to committing applications to it.

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Wednesday, February 4, 2015 at 2:57:17 PM UTC-6, Randy Brukardt wrote:
> Part of my objection to your rant here is that you keep making this about 
> Ada. It's not about Ada, its about any software with built professionally 
> (or, practically any other way). There's nothing special about Ada in this 
> regard, there are only a few things that truly are available everywhere.

Yes, I get it and agree with the whole software picture. Like I said, we all have to adapt.

http://en.wikipedia.org/wiki/ISO/IEC_JTC_1/SC_22 list 7 active ISO standard programming languages.  They fall in the 2015 TIOBE rankings as follows (* for supported in GCC) (yeh I already hear the complaints about how TIOBE works so http://www.langpop.com/ is another).

 1 C*
 4 C++*
13 COBOL
22 Ada*
43 Prolog
44 Fortran*

My experience has been that there are far more pre-packaged gcc builds that include Fortran than there are that include Ada (which until this moment was almost zero - I just discovered that CSW [Solaris freeware package manager] has 4.9.2 Ada so that's a start!).

I think Ada has been sinking on the TIOBE rankings. Surely everyone in this group would like to see it going the other way. Before any of the other issues - real or imaginary - get addressed this problem with easy availability has to be fixed.

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Wednesday, February 4, 2015 at 5:17:47 PM UTC-6, Jedi Tek'Unum wrote:
> I just discovered that CSW [Solaris freeware package manager] has 4.9.2 Ada so that's a start!).

http://www.opencsw.org/packages/CSWgcc4ada/

Reading specs from /opt/csw/lib/gcc/i386-pc-solaris2.10/4.9.2/specs
COLLECT_GCC=/opt/csw/bin/gcc
COLLECT_LTO_WRAPPER=/opt/csw/libexec/gcc/i386-pc-solaris2.10/4.9.2/lto-wrapper
Target: i386-pc-solaris2.10
Configured with: /home/dam/mgar/pkg/gcc4/trunk/work/solaris10-i386/build-isa-pentium_pro/gcc-4.9.2/configure --prefix=/opt/csw --exec_prefix=/opt/csw --bindir=/opt/csw/bin --sbindir=/opt/csw/sbin --libexecdir=/opt/csw/libexec --datadir=/opt/csw/share --sysconfdir=/etc/opt/csw --sharedstatedir=/opt/csw/share --localstatedir=/var/opt/csw --libdir=/opt/csw/lib --infodir=/opt/csw/share/info --includedir=/opt/csw/include --mandir=/opt/csw/share/man --enable-cloog-backend=isl --enable-java-awt=xlib --enable-languages=ada,c,c++,fortran,go,java,objc --enable-libada --enable-libssp --enable-nls --enable-objc-gc --enable-threads=posix --program-suffix=-4.9 --with-cloog=/opt/csw --with-gmp=/opt/csw --with-included-gettext --with-ld=/usr/ccs/bin/ld --without-gnu-ld --with-libiconv-prefix=/opt/csw --with-mpfr=/opt/csw --with-ppl=/opt/csw --with-system-zlib=/opt/csw --with-gnu-as --with-as=/opt/csw/bin/gas
Thread model: posix
gcc version 4.9.2 (GCC) 

Note EVERY language GCC supports - as it should be on EVERY platform that packages GCC.

Re: GNAT GPL is not shareware

[Simon Wright]

"Jedi Tek'Unum" <jeditekunum@gmail.com> writes:

> I thank Simon for building and publishing [GCC 4.7.0 for Solaris] but
> it is a bit old - especially the ".0" is scary.

Well, it was in May 2012! (during a protracted house move ...)

Re: GNAT GPL is not shareware

[Simon Wright]

"Jedi Tek'Unum" <jeditekunum@gmail.com> writes:

> --enable-languages=ada,c,c++,fortran,go,java,objc --enable-libada

> Note EVERY language GCC supports - as it should be on EVERY platform
> that packages GCC.

Objective C++?!

Re: Containers on small systems

[Simon Wright]

Simon Wright <simon@pushface.org> writes:

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

>> A bounded container is only as big as you need it to be. (Well,
>> unless the compiler is doing something unfriendly.) Not having
>> bounded containers is pretty much like not having arrays, IMHO.
>
> Of course this is just GNAT, but the amount of support software
> required to support their Containers (called in by finalization,
> exception propagation, dispatching, streams ...) is large. I see AARM
> A.18.19(6.a) indicates that Iterator and Reference types could be left
> out in restricted environments (so no "for A of B loop ..."?), which
> would eliminate the need for finalization and dispatching .. maybe
> something can be done.

Haven't tried Containers yet, but adding tagged types, secondary stack
and allocators increased the size of RTS from 12276 bytes to 20584. That
was compiled with -O0 (still need the debugger a lot!) which
more-or-less doubles the size from -O2; I'll try -Os (minimise size) and
see how that plays with the debugger.

Oh, and it doesn't support wide characters in tag names. I think that'd
just be a matter of including the support packages and uncommenting the
parts of Ada.Tags that use them.

Re: GNAT GPL is not shareware

[Jedi Tek'Unum]

On Thursday, February 5, 2015 at 3:06:51 AM UTC-6, Simon Wright wrote:
> "Jedi Tek'Unum" writes:
> 
> > --enable-languages=ada,c,c++,fortran,go,java,objc --enable-libada
> 
> > Note EVERY language GCC supports - as it should be on EVERY platform
> > that packages GCC.
> 
> Objective C++?!

Sigh. Indicative of the failure of software - there is always something missing.

Re: Containers on small systems

[Simon Wright]

Simon Wright <simon@pushface.org> writes:

> Haven't tried Containers yet

I think Ada.Containers.Bounded_* is a non-starter until GCC 5 comes
along (or GNAT GPL 2015).

My first attempt was to allow finalization.

This isn't insuperable; I managed to get the Containers package to
compile (though I can see why AdaCore have No_Finalization in their
STM32F4 RTS! Crikey!)

Unfortunately, when it came to bind a user program, it turned out that
gnatbind doesn't understand this particular situation; it thinks that if
you have finalization, you need to finalize at the end of the program;
and it gets confused to the point that the binder-generated main program
won't compile.

So I backed those changes out and hacked out all the modern Iterator
stuff from Ada.Containers.Bounded_Vectors (but not the modern Indexing
features).

Unfortunately, when it came to bind a user program, gnatbind thought
that it was violating No_Implicit_Heap_Allocations. I couldn't find any;
it turns out that both GCC 4.9.1 and GNAT GPL 2014 insert a spurious
"RV NO_IMPLICIT_HEAP_ALLOCATIONS" in the .ali file (RV => this unit
violates the named restriction, so the bind has to fail if the
restriction is actually imposed).

GCC 5.0.0 20141228 doesn't have this problem.

Re: Containers on small systems

[Simon Wright]

Simon Wright <simon@pushface.org> writes:

> Unfortunately, when it came to bind a user program, gnatbind thought
> that it was violating No_Implicit_Heap_Allocations. I couldn't find
> any; it turns out that both GCC 4.9.1 and GNAT GPL 2014 insert a
> spurious "RV NO_IMPLICIT_HEAP_ALLOCATIONS" in the .ali file (RV =>
> this unit violates the named restriction, so the bind has to fail if
> the restriction is actually imposed).

Fortunately, on the other hand, you can work round this by saying

   pragma Restrictions (No_Implicit_Heap_Allocations);

on the unit where the instantiation takes place.

Weird.