Ada: A beginners experience

Ada: A beginners experience

[blakemichael073]

Greetings,

 I thought that I would offer a quick beginners insights into the Ada world. 
First off, a little background, I am a mature aged first year electronics/automation engineering student that has taken an interest in real time control systems. This has lead me to interest in the Ada language.
I have read books/tutorials that have been written by posters to this group and I am grateful for the resources that are available. I have been trying to learn to program micro-controllers. 
 I have watched the thread on "Why isn't Ada more popular" and thought that I would give my perspective. Trying to learn to use Ada without the assistance of someone experienced is hard. There are so many problems along the way, and much of the available documentation assumes background knowledge that most learners would try something easier. 
 It would seem that the current strategy is to hope that once beginners are experienced enough using arduino or C that they will see the error of their previous ways and convert to the Ada language. I would argue that to make Ada more popular the barriers to using Ada need to be lowered. At the moment I spend too much time trying understand how to make my tools work, and not enough time using my tools. 

Mike Blake 

Re: Ada: A beginners experience

[Dan'l Miller]

On Friday, July 13, 2018 at 9:36:32 PM UTC-5, blakemi...@gmail.com wrote:
> At the moment I spend too much time trying understand how to make my tools work, and not enough time
> using my tools. 

Specifically what do you mean by “make the tools work”?  Do you spend
1) more time tweaking the command-line and build scripts and surrounding ecosystem, as getting exasperated trying to get the toolchain to work together (almost independent of Ada-the-language-per-se) 
or
2) more time having lengthy errors/warnings-from-compiler conversations with the GNAT compiler about Ada source code, as cycles of learning of learning Ada itself?

Re: Ada: A beginners experience

[blakemichael073]

On Saturday, July 14, 2018 at 10:53:02 AM UTC+8, Dan'l Miller wrote:
> On Friday, July 13, 2018 at 9:36:32 PM UTC-5, blakemi...@gmail.com wrote:
> > At the moment I spend too much time trying understand how to make my tools work, and not enough time
> > using my tools. 
> 
> Specifically what do you mean by “make the tools work”?  Do you spend
> 1) more time tweaking the command-line and build scripts and surrounding ecosystem, as getting exasperated trying to get the toolchain to work together (almost independent of Ada-the-language-per-se) 
> or
> 2) more time having lengthy errors/warnings-from-compiler conversations with the GNAT compiler about Ada source code, as cycles of learning of learning Ada itself?

The first of the two options, well at least most of the time. An example of the entry barrier level is the Inspirel tutorials for Ada on the Cortex-M. I have tried many times to make this work, but so far I have had no luck. (The author posts here so I will add that I have still learnt a lot from the tutorial). This is the only beginner style tutorial that I have found, but I have run into trouble with it.
 I have been able to get lights blinking on a STM32F4discovery board using the GPL-2018-community release and I am working my way through the code to truely understand it. I've been able to get some external leds flashing so I am having some success along the way. 
 I don't mind the compiler telling me off, and correcting my mistakes but fighting the toolchain, and even trying to understand the toolchain completely is hard going.
 I am determined to understand how it all works, and learning to deal with problems of building software and board support packages may simply come with the territory. But some clear documentation that doesn't make assumptions about prior knowledge would also help.

Mike Blake 

Re: Ada: A beginners experience

[Brian Drummond]

On Fri, 13 Jul 2018 20:53:13 -0700, blakemichael073 wrote:

> On Saturday, July 14, 2018 at 10:53:02 AM UTC+8, Dan'l Miller wrote:
>> On Friday, July 13, 2018 at 9:36:32 PM UTC-5, blakemi...@gmail.com
>> wrote:
>> > At the moment I spend too much time trying understand how to make my
>> > tools work, and not enough time using my tools.
>> 
>> Specifically what do you mean by “make the tools work”?  Do you spend
>> 1) more time tweaking the command-line and build scripts and
>> surrounding ecosystem, as getting exasperated trying to get the
>> toolchain to work together (almost independent of
>> Ada-the-language-per-se)
>> or 2) more time having lengthy errors/warnings-from-compiler
>> conversations with the GNAT compiler about Ada source code, as cycles
>> of learning of learning Ada itself?
> 
> The first of the two options, well at least most of the time. An example
> of the entry barrier level is the Inspirel tutorials for Ada on the
> Cortex-M. I have tried many times to make this work, but so far I have
> had no luck. (The author posts here so I will add that I have still
> learnt a lot from the tutorial). This is the only beginner style
> tutorial that I have found, but I have run into trouble with it.

First, thank you for persisting.

Second, what you are seeing is primarily the result of being one of 
relatively few people going down this path; it's a vicious circle, 
because there are relatively few peoplo on the path, there aren't many 
good maps (tutorial examles, easy to install tools) and lots of weeds. 
Which makes it harder to get started and puts off some people.

Third - I'd agree it's easier to learn the language itself on a desktop 
environment, but I don't agree you have to put the STM32 aside for very 
long. You can combine both approaches with some advantage, and it will 
stand you in good stead in the longer term.

For example, you can write a loop

loop
   Wait(1.0);
   Led_On;
   Wait(1.0);
   Led_Off;
end loop;

and test it with procedures like

procedure Led_On is
begin
   Ada.Text_IO.Put_line("LED is ON");
end Led_On;

(and use the Delay subprogram for Wait)

and compile and test it on the desktop.

Put the subprograms in a package and write two package bodies; one which 
works on the desktop as above, and one which works on the STM32 (or 
Arduino, or MSP430 [1]). Packages are basic and very useful, worth 
learning early.

Then learn enough about the build system (either Gnatmake or Gprbuild) to 
compile either package body and link for either target, and you are well 
on the way to keeping your code easily portable to other targets.

For serious large scale control applications, you'll need to learn 
tasking, as Dmitry says (more likely a subset of full tasking like the 
Ravenscar profile), but you can go quite a long way before that stage.
And again that's easier if you prototype on the desktop and move to the 
micro once it's working.

Just some suggestions for getting started.

-- Brian

[1] https://sourceforge.net/projects/msp430ada/
Not easy to install, and seriously needs updating...

Re: Ada: A beginners experience

[blakemichael073]

On Saturday, July 14, 2018 at 7:26:21 PM UTC+8, Brian Drummond wrote:
> On Fri, 13 Jul 2018 20:53:13 -0700, blakemichael073 wrote:
> 
> > On Saturday, July 14, 2018 at 10:53:02 AM UTC+8, Dan'l Miller wrote:
> >> On Friday, July 13, 2018 at 9:36:32 PM UTC-5, blakemi...@gmail.com
> >> wrote:
> >> > At the moment I spend too much time trying understand how to make my
> >> > tools work, and not enough time using my tools.
> >> 
> >> Specifically what do you mean by “make the tools work”?  Do you spend
> >> 1) more time tweaking the command-line and build scripts and
> >> surrounding ecosystem, as getting exasperated trying to get the
> >> toolchain to work together (almost independent of
> >> Ada-the-language-per-se)
> >> or 2) more time having lengthy errors/warnings-from-compiler
> >> conversations with the GNAT compiler about Ada source code, as cycles
> >> of learning of learning Ada itself?
> > 
> > The first of the two options, well at least most of the time. An example
> > of the entry barrier level is the Inspirel tutorials for Ada on the
> > Cortex-M. I have tried many times to make this work, but so far I have
> > had no luck. (The author posts here so I will add that I have still
> > learnt a lot from the tutorial). This is the only beginner style
> > tutorial that I have found, but I have run into trouble with it.
> 
> First, thank you for persisting.
> 
> Second, what you are seeing is primarily the result of being one of 
> relatively few people going down this path; it's a vicious circle, 
> because there are relatively few peoplo on the path, there aren't many 
> good maps (tutorial examles, easy to install tools) and lots of weeds. 
> Which makes it harder to get started and puts off some people.
> 
> Third - I'd agree it's easier to learn the language itself on a desktop 
> environment, but I don't agree you have to put the STM32 aside for very 
> long. You can combine both approaches with some advantage, and it will 
> stand you in good stead in the longer term.
> 
> For example, you can write a loop
> 
> loop
>    Wait(1.0);
>    Led_On;
>    Wait(1.0);
>    Led_Off;
> end loop;
> 
> and test it with procedures like
> 
> procedure Led_On is
> begin
>    Ada.Text_IO.Put_line("LED is ON");
> end Led_On;
> 
> (and use the Delay subprogram for Wait)
> 
> and compile and test it on the desktop.
> 
> Put the subprograms in a package and write two package bodies; one which 
> works on the desktop as above, and one which works on the STM32 (or 
> Arduino, or MSP430 [1]). Packages are basic and very useful, worth 
> learning early.
> 
> Then learn enough about the build system (either Gnatmake or Gprbuild) to 
> compile either package body and link for either target, and you are well 
> on the way to keeping your code easily portable to other targets.
> 
> For serious large scale control applications, you'll need to learn 
> tasking, as Dmitry says (more likely a subset of full tasking like the 
> Ravenscar profile), but you can go quite a long way before that stage.
> And again that's easier if you prototype on the desktop and move to the 
> micro once it's working.
> 
> Just some suggestions for getting started.
> 
> -- Brian
> 
> [1] https://sourceforge.net/projects/msp430ada/
> Not easy to install, and seriously needs updating...

My learning approach at the moment is to work on learning Ada programming on application type programming from some of the books available. The adacraft book by John English has been very good,  I started with Andrew Schvets Introduction to Ada Programming and there are other good resources out there. 
 My interest is particularly in real time systems, and I thought that starting with micro-controllers would be a good place to start. It would give me a good understanding of interacting with the hardware as well as building my programming skills. So for the moment I will most likely try to learn these skills in C for a while which is well supported, and try to cross reference to Ada when I can. I did look at rtems as a possible learning platform for real time systems (they have google summer of code students after all) and could not get access to their email forum, so I am already light years ahead here.
 
Mike Blake

Re: Ada: A beginners experience

[Dan'l Miller]

On Friday, July 13, 2018 at 10:53:15 PM UTC-5, blakemi...@gmail.com wrote:
> On Saturday, July 14, 2018 at 10:53:02 AM UTC+8, Dan'l Miller wrote:
> > On Friday, July 13, 2018 at 9:36:32 PM UTC-5, blakemi...@gmail.com wrote:
> > > At the moment I spend too much time trying understand how to make my tools work, and not enough time
> > > using my tools. 
> > 
> > Specifically what do you mean by “make the tools work”?  Do you spend
> > 1) more time tweaking the command-line and build scripts and surrounding ecosystem, as getting exasperated trying to get the toolchain to work together (almost independent of Ada-the-language-per-se) 
> > or
> > 2) more time having lengthy errors/warnings-from-compiler conversations with the GNAT compiler about Ada source code, as cycles of learning of learning Ada itself?
> 
> The first of the two options, well at least most of the time. An example of the entry barrier level is the Inspirel tutorials for Ada on the Cortex-M. I have tried many times to make this work, but so far I have had no luck. (The author posts here so I will add that I have still learnt a lot from the tutorial). This is the only beginner style tutorial that I have found, but I have run into trouble with it.
>  I have been able to get lights blinking on a STM32F4discovery board using the GPL-2018-community release and I am working my way through the code to truely understand it. I've been able to get some external leds flashing so I am having some success along the way. 
>  I don't mind the compiler telling me off, and correcting my mistakes but fighting the toolchain, and even trying to understand the toolchain completely is hard going.
>  I am determined to understand how it all works, and learning to deal with problems of building software and board support packages may simply come with the territory. But some clear documentation that doesn't make assumptions about prior knowledge would also help.
> 
> Mike Blake

I figured that might be what you mean, because it is perennially my obstacle whenever learning new languages.

On one hand, the Ada community & compiler vendors shouldn't just stop at giving advice (e.g., via c.l.a; StackOverflow) and at teaching (e.g., books, Ada Gems).

https://github.com/Microsoft/Windows-iotcore-samples
The Ada community & compiler vendors should take a page from, say, Microsoft's culture to put a generous amount of well-collected/organized examples* for various single-focus use-cases.  What is most excellent about Microsoft's approach to this in particular is that they give the entire solution file (and project file) that is a canned set-up of the entire ecosystem that is guaranteed to work for a specific version of their toolchain.  Ada community & compiler vendors would do well to mimic all that to the Nth degree.

(Alex Gamper's integration of GNAT into Visual Studio should directly benefit from being part of these solution files for Microsoft-OS targets.  License permitting, eventually one could envision a usecase-by-usecase transliteration of each of the numerous C++/CX, C++/WinRT, C# Microsoft-authored samples in GitHub to Ada-WinRT.  Despite people sometimes avoiding Microsoft, Alex Gamper's work is likely to eventually attract & deeply/widely teach Ada in a very accessible way to a entirely untapped new audience.  Much the same could be done for other OSes.)

* Unfortunately, Microsoft uses the word •samples• (instead of the more-correct •examples•), as if a statistician is pulling a few random manufactured goods going by on the assembly line as a quality check.

On the other hand, Ada compiler vendors should be extra diligent in making their toolchain easy to quickly & obviously configure in the top 5 dozen commonplace usecases without consulting the incantations in a semisecret book of magic spells that only a few magicians have.  (Even Microsoft doesn't do a good job at all on this variant:  there is no set of “samples” on GitHub regarding how to tweak their build scripts in dozens of different usecase ways.)

Re: Ada: A beginners experience

[Jere]

On Friday, July 13, 2018 at 11:53:15 PM UTC-4, blakemi...@gmail.com wrote:
> On Saturday, July 14, 2018 at 10:53:02 AM UTC+8, Dan'l Miller wrote:
> > On Friday, July 13, 2018 at 9:36:32 PM UTC-5, blakemi...@gmail.com wrote:
> > > At the moment I spend too much time trying understand how to make my tools work, and not enough time
> > > using my tools. 
> > 
> > Specifically what do you mean by “make the tools work”?  Do you spend
> > 1) more time tweaking the command-line and build scripts and surrounding ecosystem, as getting exasperated trying to get the toolchain to work together (almost independent of Ada-the-language-per-se) 
> > or
> > 2) more time having lengthy errors/warnings-from-compiler conversations with the GNAT compiler about Ada source code, as cycles of learning of learning Ada itself?
> 
> The first of the two options, well at least most of the time. An example of the entry barrier level is the Inspirel tutorials for Ada on the Cortex-M. I have tried many times to make this work, but so far I have had no luck. (The author posts here so I will add that I have still learnt a lot from the tutorial). This is the only beginner style tutorial that I have found, but I have run into trouble with it.
>  I have been able to get lights blinking on a STM32F4discovery board using the GPL-2018-community release and I am working my way through the code to truely understand it. I've been able to get some external leds flashing so I am having some success along the way. 
>  I don't mind the compiler telling me off, and correcting my mistakes but fighting the toolchain, and even trying to understand the toolchain completely is hard going.
>  I am determined to understand how it all works, and learning to deal with problems of building software and board support packages may simply come with the territory. But some clear documentation that doesn't make assumptions about prior knowledge would also help.
> 
> Mike Blake

Back a few years ago, I started similarly to where you did.  I did find
the Inspirel book to be very good, but you had to understand the context
it was coming from.  It seemed to assume you were natively (not cross)
compiling your code.  I ran into trouble because I wanted to work on
a controller bare-metal (it was too small for a full Ada runtime).  There
were various small issues with the examples in the book vs what I found
trying to cross compiler, so I stopped for a bit and decided to change up.

I looked into taking baby steps of making a Zero-Foot-Print (ZFP) runtime.
I grabbed a copy of one of Simon Wright's old ZFP projects and took
the time to figure out what needed to be changed for that board, this
included not only the ada files, but the linker script as well.  Once
I got that working and I continued on with the Inspirel book and got
some basic IO stuff working.  I found some other inconsistencies which
appeared to be due to differences in the linkerscript I was using and
the one used in the book.  After that I worked on adding small extra
features (leaving ZFP behind at this point and becoming nearly-ZFP).

I guess the point of all this, is bare-metal is not easy in Ada, it
takes a lot of small steps.  I do wish there were more beginner friendly
resources, but what I have found is that there is just not enough
community with both time and money to get there (perhaps in the future
though).  I think the suggestions to go with a higher level embedded
project targetting something like the beagle bone or raspberry pi are
very good suggestions until you are more comfortable with the tools.

I agree, definitely not very beginner friendly, which is a shame.

Re: Ada: A beginners experience

[Maciej Sobczak]

> Back a few years ago, I started similarly to where you did.  I did find
> the Inspirel book to be very good, but you had to understand the context
> it was coming from.  It seemed to assume you were natively (not cross)
> compiling your code.

Hi there, thank you for taking the time to check that tutorial. Still, I think there is some correction needed here - the examples in the tutorial were written with the assumption of native compilation (for example on RaspberryPi), simply because this makes the command-line the most compact and kind of neutral as well. All commands should give the same results in the cross-compilation environment. If you found any troubles with this, let me know. This can help improve the future tutorial revisions.

> I ran into trouble because I wanted to work on
> a controller bare-metal (it was too small for a full Ada runtime).

The tutorial was exactly focusing on zero-foot-print, bare-metal development. There are other sources that cover the (more or less) full runtime approach, with ready runtimes and driver libraries, so the tutorial tried to fill the niche for smaller chips or those projects that chose zero-foot-print for other reasons (traceability, IP politics, etc.).

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

Re: Ada: A beginners experience

[Jere]

On Monday, July 16, 2018 at 5:38:58 PM UTC-4, Maciej Sobczak wrote:
> > Back a few years ago, I started similarly to where you did.  I did find
> > the Inspirel book to be very good, but you had to understand the context
> > it was coming from.  It seemed to assume you were natively (not cross)
> > compiling your code.
> 
> Hi there, thank you for taking the time to check that tutorial. Still, I think there is some correction needed here - the examples in the tutorial were written with the assumption of native compilation (for example on RaspberryPi), simply because this makes the command-line the most compact and kind of neutral as well. All commands should give the same results in the cross-compilation environment. If you found any troubles with this, let me know. This can help improve the future tutorial revisions.

This was a few years ago, so this is from memory (take it with a
grain of salt).

The biggest troubles I had with it was I was coming from cross-compile
instead of native.  In bare metal, it is somewhat rare to compile from
native since you won't have an OS or shell.  Just following along blindly
came up with various errors like that it needed system.ads.  A new 
beginner is not going to immediately link this to not having and RTS. 

My first workaround was to find a system.ads and add it.  This placated
the compiler so I moved on.  Next I think I needed system.storage_elements,
so I added the spec for that to my source.  I was moving along fairly 
well until I needed something from the package body for
system.storage_elements.  When I tried to add s-stoele.adb then the compiler
said it could compile system files (or a similar error).  This was where
I had to stop with your book as I hit a road block.  I needed an actual
RTS and there was really no help there.  I spent a couple of weeks 
trying to find a simple ZFP package that I could modify that didn't come
from Adacore (I didn't want the base GPL license from GNAT GPL).  Once
I got one working, I went back to your book.

Like I said, it was good.  I just wanted the OP to understand that 
while it mentions cross-compile, just blinding following the steps
and replacing the commands with the cross compile ones doesn't work.
This isn't a deficiency of the book, it is written from a native
context, but as a beginner it can be really confusing if one doesn't
understand the implications of that.

The only other thing I found different was the section on shared
state.  I didn't have a full runtime as alluded to (I had a ZFP,
which was much more bare).  However, I was able to correctly
create:

package body Program is

   X : Integer := 123; -- This actually worked correctly for me

   procedure Run is
   -- ...

end Program;

I'm guessing it had something to do with how my linker script was
setup, but it surprised me as it contrasted what was stated in
the book.  I don't think this is an error or anything, but 
bringing this up to you just incase.

> 
> > I ran into trouble because I wanted to work on
> > a controller bare-metal (it was too small for a full Ada runtime).
> 
> The tutorial was exactly focusing on zero-foot-print, bare-metal development. There are other sources that cover the (more or less) full runtime approach, with ready runtimes and driver libraries, so the tutorial tried to fill the niche for smaller chips or those projects that chose zero-foot-print for other reasons (traceability, IP politics, etc.).

I would say the major thing here is if it really is meant to be for
bare-metal ZFP style development, it was missing some more detailed
discussion on how to get and setup a quick ZFP runtime.  For beginners
this will be a huge deal.  Developing on a Raspberry Pi really isn't
bare-metal since you are compiling native with in an OS.  Yes, you can
emulate bare-metal programming on it, but it isn't exactly the same.
Note, I am not saying have an exhaustive section on how the ZFP runtime
works or anything, but just some resource on how to setup your environment
for one of the book's targeted boards.

I really think your book is great, so please don't take any comments
as antagonistic.  I recommend it to anyone I see getting started in
micro-controller development.

Re: Ada: A beginners experience

[Maciej Sobczak]

> Just following along blindly
> came up with various errors like that it needed system.ads.
[...]

OK, I see where this comes from. Indeed, it might be the case that the native compiler on Raspberry has the language details set up fortunately enough that such manipulations are not necessary - while cross-compilers on other systems can use different setups and cause troubles. Indeed, this is a valuable note to take.
You might find it interesting that the whole tutorial was created from experiments that involved analysis of the resulting assembly output. As long as the assembly was as expected for the target microcontroller, the narrative and examples evolved. It might not be easy to adopt, but I'm prone to conclude that this step is part of the game and perhaps it could also help discover some of the cross-compilation issues earlier.

> A new 
> beginner is not going to immediately link this to not having and RTS.

Right.

> Like I said, it was good.  I just wanted the OP to understand that 
> while it mentions cross-compile, just blinding following the steps
> and replacing the commands with the cross compile ones doesn't work.

Good point, thank you. Note also that even with the compiler on Raspberry, there is no guarantee that all examples will work forever - new compiler versions might introduce some minor differences here and there. I have noticed myself some new ABI calls where they weren't needed, after upgrading the compiler. Yes, embedded systems is a hobby for tinkerers. :-)

> package body Program is
> 
>    X : Integer := 123; -- This actually worked correctly for me

Interesting! I cannot explain that without analyzing the assembly and the linker script, but I can imagine it being the case.

> I really think your book is great, so please don't take any comments
> as antagonistic.  I recommend it to anyone I see getting started in
> micro-controller development.

Thank you for the good comments.

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

Re: Ada: A beginners experience

[Simon Wright]

Maciej Sobczak <see.my.homepage@gmail.com> writes:

>> package body Program is
>> 
>>    X : Integer := 123; -- This actually worked correctly for me
>
> Interesting! I cannot explain that without analyzing the assembly and
> the linker script, but I can imagine it being the case.

At the end of program.s, in section .data,

           .align  2
           .type   program__x, %object
           .size   program__x, 4
   program__x:
           .word   123
           .ident  "GCC: (GNU) 8.1.0"

(If you don't assign X within Run, this gets put into .rodata)

Re: Ada: A beginners experience

[Paul Rubin]

blakemichael073@gmail.com writes:
>  I have watched the thread on "Why isn't Ada more popular" and thought
> that I would give my perspective. Trying to learn to use Ada without
> the assistance of someone experienced is hard.

This won't be a popular viewpoint here but IMHO Ada isn't a great choice
as a first language.  It's designed to help deal with the problems of
writing and maintaining very large code bases.  But there is a lot of
overhead in the features it supplies for that.

If you want to start playing with microcontrollers with minimal fuss, I
suggest getting a CircuitPython board, plugging it into your PC and
playing with it for a while.  This should be a good one to start with:

   https://www.adafruit.com/product/3727

There are lots of other models too:

  https://www.adafruit.com/category/957

Worry about Ada once you're more concerned about large-scale
engineering, performance, etc.  Start out with something simple for
playing around with, and by the time you hit its limits, you'll have
enough experience that Ada will make more sense to you than it currently
does.

Re: Ada: A beginners experience

[blakemichael073]

On Saturday, July 14, 2018 at 11:36:51 AM UTC+8, Paul Rubin wrote:
> blakemichael073@gmail.com writes:
> >  I have watched the thread on "Why isn't Ada more popular" and thought
> > that I would give my perspective. Trying to learn to use Ada without
> > the assistance of someone experienced is hard.
> 
> This won't be a popular viewpoint here but IMHO Ada isn't a great choice
> as a first language.  It's designed to help deal with the problems of
> writing and maintaining very large code bases.  But there is a lot of
> overhead in the features it supplies for that.
> 
> If you want to start playing with microcontrollers with minimal fuss, I
> suggest getting a CircuitPython board, plugging it into your PC and
> playing with it for a while.  This should be a good one to start with:
> 
>    https://www.adafruit.com/product/3727
> 
> There are lots of other models too:
> 
>   https://www.adafruit.com/category/957
> 
> Worry about Ada once you're more concerned about large-scale
> engineering, performance, etc.  Start out with something simple for
> playing around with, and by the time you hit its limits, you'll have
> enough experience that Ada will make more sense to you than it currently
> does.

This is the approach that I will most likely end up following, there is simply more learning material available for other languages aimed at my level. 
It is an odd strategy for Ada itself though, essentially hoping that programmers migrate to your product for it's features once they have learnt the basics of their trade. Many people will try to add the features to the product that they are familiar with.

Mike Blake

Re: Ada: A beginners experience

[Paul Rubin]

blakemichael073@gmail.com writes:
> It is an odd strategy for Ada itself though, essentially hoping that
> programmers migrate to your product for it's features once they have
> learnt the basics of their trade. 

Before you study how to pilot an aircraft carrier, you might first
get comfortable in the water by paddling a canoe.

Re: Ada: A beginners experience

[Rene]

Paul Rubin wrote:
> blakemichael073@gmail.com writes:
>> It is an odd strategy for Ada itself though, essentially hoping that
>> programmers migrate to your product for it's features once they have
>> learnt the basics of their trade.
> 
> Before you study how to pilot an aircraft carrier, you might first
> get comfortable in the water by paddling a canoe.
> 

But the consequence of this approach is that people start with C, and 
later they stick with it because they learn to live with its 
shortcomings, rather than searching for something better.

--
René Hartmann

Re: Ada: A beginners experience

[Paul Rubin]

Rene <rehartmann@t-online.de> writes:
> But the consequence of this approach is that people start with C

That's also a poor idea these days.  My suggestion was Python.
And if that suffices for everything you do, then fine.

Re: Ada: A beginners experience

[Jere]

On Friday, July 13, 2018 at 11:36:51 PM UTC-4, Paul Rubin wrote:
> This won't be a popular viewpoint here but IMHO Ada isn't a great choice
> as a first language.  It's designed to help deal with the problems of
> writing and maintaining very large code bases.  But there is a lot of
> overhead in the features it supplies for that.
> 
I know you probably know all this (you have a lot of experience), but
for the benefit of new folks, I wanted to get a bit more specific on
this.  Languages like Ada and C++ can have a lot of overhead if
used like one is writing a desktop application.  However, Ada (and C++) 
has a lot of those features at either no cost or almost no cost.  I've
spent a lot of time writing Ada (and C++) code for a chip with 64k flash, 
so I've definitely spent time deciphering what causes overhead.  

The type system (the big draw for me to Ada) is actually very streamlined.
I've extensively used generics as well and have found almost no extra
cost at all (verifying the generated assembly).  Mind you, not only is
this compiler specific, but it also requires you to consider how you
are defining your types, variables, and functions.  If the compiler
can make things at compile time, that's when the cost goes drastically
down.  Creating things based on runtime inputs is where it can start
to skyrocket if not monitored.  However, there are definitely things
in Ada that are costly.  Tasks and Protected objects are a big one.  
Full exception handling capability is another.  I haven't been able
to get Finalization working (haven't tried hard honestly), so I cannot
comment on that one.  As a side note, even some runtime components
can actually be better than compile time.  In every practical case
of my C++ projects, using dynamic dispatching was faster and smaller
code size than trying to use case statements.  It's not always the
case, but again, that is something a developer has to keep tabs on.

None of this is beginner friendly though obviously.

Re: Ada: A beginners experience

[Paul Rubin]

Jere <jhb.chat@gmail.com> writes:
> Languages like Ada and C++ can have a lot of overhead if used like one
> is writing a desktop application.  However, Ada (and C++) has a lot of
> those features at either no cost or almost no cost.

I meant overhead in terms of source code verbosity, not computer cycles.
E.g. a Python "hello world" program:

   print("hello, world")

the same thing in Ada is much more code.  If you look on rosettacode.org
the Ada examples are almost always much larger than the Python counterparts.

Re: Ada: A beginners experience

[Dmitry A. Kazakov]

On 2018-07-14 17:42, Paul Rubin wrote:
> Jere <jhb.chat@gmail.com> writes:
>> Languages like Ada and C++ can have a lot of overhead if used like one
>> is writing a desktop application.  However, Ada (and C++) has a lot of
>> those features at either no cost or almost no cost.
> 
> I meant overhead in terms of source code verbosity, not computer cycles.
> E.g. a Python "hello world" program:
> 
>     print("hello, world")
> 
> the same thing in Ada is much more code.

As if you didn't have to import modules in Python. If this example shows 
anything then bad design of Python where standard modules get special 
treatment. In Ada all packages are same. The package Standard is minimal.

> If you look on rosettacode.org
> the Ada examples are almost always much larger than the Python counterparts.

While Python code is incredibly ugly and impossible to understand being 
counterintuitive, cryptic and lacking any regularity.

My experience with Python was out of necessity, short and totally unhappy.

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

Re: Ada: A beginners experience

[Dennis Lee Bieber]

On Sat, 14 Jul 2018 18:01:20 +0200, "Dmitry A. Kazakov"
<mailbox@dmitry-kazakov.de> declaimed the following:

>While Python code is incredibly ugly and impossible to understand being 
>counterintuitive, cryptic and lacking any regularity.
>
>My experience with Python was out of necessity, short and totally unhappy.

	Interesting -- since I find Python to effectively be "executable
pseudo-code". Block structure is indicated by indentation -- which
shouldn't be a concern given how many pretty-printers are used for Ada, C,
etc. that give the same effect.

	PERL is cryptic... (I had to help someone once with a problem debugging
a PERL script... I basically had to get a verbal description of what the
program was supposed to do, sketched it in Python, THEN did look ups in the
index of the camel book to find the PERL equivalent for everything I used
in Python).


-- 
	Wulfraed                 Dennis Lee Bieber         AF6VN
	wlfraed@ix.netcom.com    HTTP://wlfraed.home.netcom.com/ 

Re: Ada: A beginners experience

[Paul Rubin]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
> As if you didn't have to import modules in Python. If this example
> shows anything then bad design of Python where standard modules get
> special treatment. In Ada all packages are same. The package Standard
> is minimal.

Only one standard Python module ("builtins") is imported automatically.
You have to import the rest.  I think there is a way to suppress the
automatic import of the builtins module.  Haskell similarly has the
standard Prelude, OCaml has something similar, etc, fwiw.  

> While Python code is incredibly ugly and impossible to understand
> being counterintuitive, cryptic and lacking any regularity.

I haven't found this most of the time.  Python has some weird and
confusing features like metaclasses, that might or might not be badly
designed, but that are usually irrelevant for beginners.

Re: Ada: A beginners experience

[Simon Wright]

Jere <jhb.chat@gmail.com> writes:

> However, there are definitely things in Ada that are costly.  Tasks
> and Protected objects are a big one.  Full exception handling
> capability is another.  I haven't been able to get Finalization
> working (haven't tried hard honestly), so I cannot comment on that
> one.

Tasking and POs were my main problem in Cortex GNAT RTS[1], not so much
the actual tasking/sychronization, which I delegate to FreeRTOS, so much
as the interface between the compiler and the RTS, and the way it
changes between different releases, see [2].

Exception handling is something I haven't even attempted (after one look
at the work GNAT has to do). See [3], espectially the Robert Dewar quote
at the end - "exceptions are a huge pain in the neck to implement".

Finalization is something I've actually implemented, but it's still in a
branch because of binder problems, now nearly resolved in GCC8/GNAT CE
2018 (the binder generates incorrect code if your code doesn't use the
secondary stack!! [4])

[1] https://github.com/simonjwright/cortex-gnat-rts
[2]
https://github.com/simonjwright/cortex-gnat-rts/blob/master/INSTALL.md
[3]
https://github.com/simonjwright/cortex-gnat-rts/wiki/ExceptionHandling
[4] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85380

Re: Ada: A beginners experience

[Bill Findlay]

On 14 Jul 2018, Jere wrote
(in article<6febe5d6-0339-4da5-afe5-9af4e2255597@googlegroups.com>):

> On Friday, July 13, 2018 at 11:36:51 PM UTC-4, Paul Rubin wrote:
> > This won't be a popular viewpoint here but IMHO Ada isn't a great choice
> > as a first language. [...]
>
> [...] The type system (the big draw for me to Ada) is actually very streamlined. [...]
>
> None of this is beginner friendly though obviously.

I disagree very strongly with the idea that Ada is not a good beginners 
language, and I
do so as a result of the experience of introducing an Ada-based CS1 course in 
1996.

Most of its advanced features will never arise in such a course, and the good 
design
of Ada means that beginners are very unlikely to stumble upon them by 
mistake.

The Ada course replaced one based on Pascal, and the improvement in outcomes
was clear at an early stage. Ada is easier for beginners than Pascal, because 
its
syntax and semantics are more consistent. In fact, it's just amuch better 
language.

It was interesting to stand in the lab and watch Ada-based and Pascal-based 
beginners
working side by side. One day, about week 6 of term, the Ada studentshad 
nearly all
successfully written a program that 2-D animated balls bouncing around in a 
box.
The Pascalstudents were grappling, mostly unsuccessfully, with a trivial 
text-based
read-process-output loop.

-- 
Bill Findlay

Re: Ada: A beginners experience

[Jere]

On Sunday, July 15, 2018 at 6:44:06 PM UTC-4, Bill Findlay wrote:
> On 14 Jul 2018, Jere wrote
> 
> > On Friday, July 13, 2018 at 11:36:51 PM UTC-4, Paul Rubin wrote:
> > > This won't be a popular viewpoint here but IMHO Ada isn't a great choice
> > > as a first language. [...]
> >
> > [...] The type system (the big draw for me to Ada) is actually very streamlined. [...]
> >
> > None of this is beginner friendly though obviously.
> 
> I disagree very strongly with the idea that Ada is not a good beginners 
> language, and I
> do so as a result of the experience of introducing an Ada-based CS1 course in 
> 1996.
> 

I never said that about Ada.

In the context of my reply, trying to get a full Ada environment
working on a board that doesn't already have one is not a beginner
friendly project (and that is not limited to just Ada).

I personally think Ada, as a language, is a great for beginners. 

Re: Ada: A beginners experience

[Paul Rubin]

Jere <jhb.chat@gmail.com> writes:
> In the context of my reply, trying to get a full Ada environment
> working on a board that doesn't already have one is not a beginner
> friendly project (and that is not limited to just Ada).

I'd say in general that dealing with getting a toolchain of any sort
working for an embedded board is a separate set of headaches over and
above actually programming the thing.  So it's nice when the tools are
already installed.

I like the Adafruit boards that way.  They already have Circuit Python
and you can just plug them into a USB port and start typing at them
interactively.  The MCU flash memory appears on your computer like a USB
flash drive, so you can drag and drop Python files to it, and execute
them on the MCU board, etc.  Python is not that great for hard realtime
stuff, but those boards are a very sweet setup in other regards.

Re: Ada: A beginners experience

[Bill Findlay]

Jere <jhb.chat@gmail.com> wrote:
> On Sunday, July 15, 2018 at 6:44:06 PM UTC-4, Bill Findlay wrote:
>> On 14 Jul 2018, Jere wrote
>> 
>>> On Friday, July 13, 2018 at 11:36:51 PM UTC-4, Paul Rubin wrote:
>>>> This won't be a popular viewpoint here but IMHO Ada isn't a great choice
>>>> as a first language. [...]
>>> 
>>> [...] The type system (the big draw for me to Ada) is actually very streamlined. [...]
>>> 
>>> None of this is beginner friendly though obviously.
>> 
>> I disagree very strongly with the idea that Ada is not a good beginners 
>> language, and I
>> do so as a result of the experience of introducing an Ada-based CS1 course in 
>> 1996.
>> 
> 
> I never said that about Ada.

I never said you did.

-- 
Bill Findlay

Re: Ada: A beginners experience

[Dan'l Miller]

On Sunday, July 15, 2018 at 5:44:06 PM UTC-5, Bill Findlay wrote:
> On 14 Jul 2018, Jere wrote
> (in article<6febe5d6-0339-4da5-afe5-9af4e2255597@googlegroups.com>):
> 
> > On Friday, July 13, 2018 at 11:36:51 PM UTC-4, Paul Rubin wrote:
> > > This won't be a popular viewpoint here but IMHO Ada isn't a great choice
> > > as a first language. [...]
> >
> > [...] The type system (the big draw for me to Ada) is actually very streamlined. [...]
> >
> > None of this is beginner friendly though obviously.
> 
> I disagree very strongly with the idea that Ada is not a good beginners 
> language, and I
> do so as a result of the experience of introducing an Ada-based CS1 course in 
> 1996.
> 
> Most of its advanced features will never arise in such a course, and the good 
> design
> of Ada means that beginners are very unlikely to stumble upon them by 
> mistake.
> 
> The Ada course replaced one based on Pascal, and the improvement in outcomes
> was clear at an early stage. Ada is easier for beginners than Pascal, because 
> its
> syntax and semantics are more consistent. In fact, it's just amuch better 
> language.
> 
> It was interesting to stand in the lab and watch Ada-based and Pascal-based 
> beginners
> working side by side. One day, about week 6 of term, the Ada studentshad 
> nearly all
> successfully written a program that 2-D animated balls bouncing around in a 
> box.
> The Pascalstudents were grappling, mostly unsuccessfully, with a trivial 
> text-based
> read-process-output loop.
> 
> -- 
> Bill Findlay

It seems that this result could have and should have been the subject of scientific studies on first-programming-language acquisition (or at least as much as incoming freshmen approximate that, eliding any exposure in high school).  Pascal versus Ada versus C should have been quite the empirically-observable comparison during the late 1980s and throughout the 1990s.  And then Java versus Ada versus  Python should have been quite the empirically-observable comparison from the latter Nineties through the latter Naughties/Aughties.

Mechanisms of, facilitators for, and impediments to first and second language acquisition has always been a primary scientific research area in natural-language linguistics, certainly since Jean Piaget or Noam Chomsky.  Our field should do the same, if for no other reason than to separate the men* from the boys** among programming languages that shape the way a programmer thinks for good or ill, perhaps actually fulfilling the Sapir-Whorf hypothesis in programming & software design:  one's conceptions & mental model are shaped by the programming language in which one thinks design thoughts mentally.

* Ada, perhaps Rust, perhaps OCaml or Haskell

** C, C++, all the ‘This time for sure’ Bullwinkle-hat-trick C-done-right/C++-done-right languages (e.g., Java, J++, C#, Objective-C, Swift, Go), all the Algol-but-slightly-different languages (e.g., Pascal, Ruby, Lua), PL/I

Re: Ada: A beginners experience

[Bill Findlay]

> On Sunday, July 15, 2018 at 5:44:06 PM UTC-5, Bill Findlay wrote:
> >
> > I disagree very strongly with the idea that Ada is not a good beginners
> > language, and I
> > do so as a result of the experience of introducing an Ada-based CS1 course
> > in
> > 1996.
> >
> > Most of its advanced features will never arise in such a course, and the
> > good
> > design
> > of Ada means that beginners are very unlikely to stumble upon them by
> > mistake.
> >
> > The Ada course replaced one based on Pascal, and the improvement in outcomes
> > was clear at an early stage. Ada is easier for beginners than Pascal,
> > because
> > its
> > syntax and semantics are more consistent. In fact, it's just amuch better
> > language.
> >
> > It was interesting to stand in the lab and watch Ada-based and Pascal-based
> > beginners
> > working side by side. One day, about week 6 of term, the Ada studentshad
> > nearly all
> > successfully written a program that 2-D animated balls bouncing around in a
> > box.
> > The Pascalstudents were grappling, mostly unsuccessfully, with a trivial
> > text-based
> > read-process-output loop.

That was remarkably mangled.

-- 
Bill Findlay

Re: Ada: A beginners experience

[Dmitry A. Kazakov]

On 2018-07-14 04:36, blakemichael073@gmail.com wrote:
> Greetings,
> 
>   I thought that I would offer a quick beginners insights into the Ada world.
> First off, a little background, I am a mature aged first year electronics/automation engineering student that has taken an interest in real time control systems. This has lead me to interest in the Ada language.
> I have read books/tutorials that have been written by posters to this group and I am grateful for the resources that are available. I have been trying to learn to program micro-controllers.

OK, but that is a strange and hardest method to get into.

Strange, because automation systems tend to walk away from 
"microcontrollers" in the sense of a bare-metal-16-bit-1K thing. You can 
comfortably do everything on an ARM board running Linux.

>   I have watched the thread on "Why isn't Ada more popular" and thought that I would give my perspective. Trying to learn to use Ada without the assistance of someone experienced is hard. There are so many problems along the way, and much of the available documentation assumes background knowledge that most learners would try something easier.
>   It would seem that the current strategy is to hope that once beginners are experienced enough using arduino or C that they will see the error of their previous ways and convert to the Ada language. I would argue that to make Ada more popular the barriers to using Ada need to be lowered. At the moment I spend too much time trying understand how to make my tools work, and not enough time using my tools.

Integrating Ada in the Ardiuno framework is a bit different thing. I 
agree that it will be very cool not to be forced to program it in C. But 
the problem would be having binding to thousands of C libraries used to 
deal with the hardware. It is a huge work with almost no practical use 
in the end except for showing presence.

And it is not a quite good starting point, because, IMO, learning Ada 
for automation and control must start with tasking and protected objects.

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

Re: Ada: A beginners experience

[blakemichael073]

On Saturday, July 14, 2018 at 4:01:34 PM UTC+8, Dmitry A. Kazakov wrote:
> On 2018-07-14 04:36, blakemichael073@gmail.com wrote:
> > Greetings,
> > 
> >   I thought that I would offer a quick beginners insights into the Ada world.
> > First off, a little background, I am a mature aged first year electronics/automation engineering student that has taken an interest in real time control systems. This has lead me to interest in the Ada language.
> > I have read books/tutorials that have been written by posters to this group and I am grateful for the resources that are available. I have been trying to learn to program micro-controllers.
> 
> OK, but that is a strange and hardest method to get into.
> 
> Strange, because automation systems tend to walk away from 
> "microcontrollers" in the sense of a bare-metal-16-bit-1K thing. You can 
> comfortably do everything on an ARM board running Linux.
> 
> >   I have watched the thread on "Why isn't Ada more popular" and thought that I would give my perspective. Trying to learn to use Ada without the assistance of someone experienced is hard. There are so many problems along the way, and much of the available documentation assumes background knowledge that most learners would try something easier.
> >   It would seem that the current strategy is to hope that once beginners are experienced enough using arduino or C that they will see the error of their previous ways and convert to the Ada language. I would argue that to make Ada more popular the barriers to using Ada need to be lowered. At the moment I spend too much time trying understand how to make my tools work, and not enough time using my tools.
> 
> Integrating Ada in the Ardiuno framework is a bit different thing. I 
> agree that it will be very cool not to be forced to program it in C. But 
> the problem would be having binding to thousands of C libraries used to 
> deal with the hardware. It is a huge work with almost no practical use 
> in the end except for showing presence.
> 
> And it is not a quite good starting point, because, IMO, learning Ada 
> for automation and control must start with tasking and protected objects.
> 
> -- 
> Regards,
> Dmitry A. Kazakov
> http://www.dmitry-kazakov.de

If setting up a beaglebone black with one of the linux operating systems and working with Ada from there will be an easier option then I start from this point.

Re: Ada: A beginners experience

[Dmitry A. Kazakov]

On 2018-07-14 14:20, blakemichael073@gmail.com wrote:

> If setting up a beaglebone black with one of the linux operating systems and working with Ada from there will be an easier option then I start from this point.

This should work out of the box. Debian or Fedora either has the latest 
GNAT FSF Ada in GCC 8. BB has enough memory to compile right on the 
board, so you need not to bother setting up a cross compiler. Even GPS 
should work.

BTW, use a small external hard-drive to keep the system there or at 
least the user home. SD card is unreliable under extensive writing, you 
may experience system crashes if you would compile your things on SD. 
(You still boot from the SD but then switch to the hard-drive)

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

Re: Ada: A beginners experience

[blakemichael073]

On Saturday, July 14, 2018 at 9:15:47 PM UTC+8, Dmitry A. Kazakov wrote:
> On 2018-07-14 14:20, blakemichael073@gmail.com wrote:
> 
> > If setting up a beaglebone black with one of the linux operating systems and working with Ada from there will be an easier option then I start from this point.
> 
> This should work out of the box. Debian or Fedora either has the latest 
> GNAT FSF Ada in GCC 8. BB has enough memory to compile right on the 
> board, so you need not to bother setting up a cross compiler. Even GPS 
> should work.
> 
> BTW, use a small external hard-drive to keep the system there or at 
> least the user home. SD card is unreliable under extensive writing, you 
> may experience system crashes if you would compile your things on SD. 
> (You still boot from the SD but then switch to the hard-drive)
> 
> -- 
> Regards,
> Dmitry A. Kazakov
> http://www.dmitry-kazakov.de

Thank you for this advice, I will start giving this a try soon.

Mike Blake

Re: Ada: A beginners experience

[Jeffrey R. Carter]

On 07/14/2018 04:36 AM, blakemichael073@gmail.com wrote:
> 
>   I thought that I would offer a quick beginners insights into the Ada world.
> First off, a little background, I am a mature aged first year electronics/automation engineering student that has taken an interest in real time control systems. This has lead me to interest in the Ada language.
> I have read books/tutorials that have been written by posters to this group and I am grateful for the resources that are available. I have been trying to learn to program micro-controllers.

This is an unusual way to go about it. Getting things to work on a 
micro-controller involves a number of difficulties that interfere with learning 
the language. I would recommend that you first learn the language in a typical 
desktop environment, and only once you are comfortable with it add the 
complications of the micro-controller environment.

There are several tutorials and other material for general-purpose Ada learning 
on the Ada Information Clearinghouse:

http://www.adaic.org/learn/materials/

There's also the Ada Tutor Ada-95 tutorial at

https://pragmada.x10hosting.com/adatutor.html

HTH

-- 
Jeff Carter
"What lazy lout left these wires all over the lawn?"
Poppy
98

Re: Ada: A beginners experience

[fabien.chouteau]

On Saturday, July 14, 2018 at 4:36:32 AM UTC+2, blakemi...@gmail.com wrote:
> Greetings,
> 
>  I thought that I would offer a quick beginners insights into the Ada world. 

Hi Mike,

Thanks for sharing your experience.

I work for AdaCore and I'm very interested in making embedded/bare-metal Ada easier for beginners.

For instance we have the Ada Drivers Library project [1], you didn't mention it so maybe you don't know it yet. The goal of this project is to provide drivers and support for boards like the STM32 discovery, the BBC micro:bit or the RISC-V HiFive1.

The documentation is still not good enough but we are making progress. This month I worked on documented examples for the micro:bit [2]. I think they are good for beginners, any comment would be greatly appreciated of course. 

For the learning experience, we are going to launch a new interactive learning website. Stay tuned on that, I will share the info here once it's available (hopefully this week).

You might be interested by the embedded programming competition that we organize in October: www.makewithada.org

Looking forward seeing you projects,

[1] https://github.com/AdaCore/Ada_Drivers_Library
[2] https://github.com/AdaCore/Ada_Drivers_Library/tree/master/examples/MicroBit

Re: Ada: A beginners experience

[blakemichael073]

On Monday, July 16, 2018 at 5:25:34 PM UTC+8, fabien....@gmail.com wrote:
> On Saturday, July 14, 2018 at 4:36:32 AM UTC+2, blakemi...@gmail.com wrote:
> > Greetings,
> > 
> >  I thought that I would offer a quick beginners insights into the Ada world. 
> 
> Hi Mike,
> 
> Thanks for sharing your experience.
> 
> I work for AdaCore and I'm very interested in making embedded/bare-metal Ada easier for beginners.
> 
> For instance we have the Ada Drivers Library project [1], you didn't mention it so maybe you don't know it yet. The goal of this project is to provide drivers and support for boards like the STM32 discovery, the BBC micro:bit or the RISC-V HiFive1.
> 
> The documentation is still not good enough but we are making progress. This month I worked on documented examples for the micro:bit [2]. I think they are good for beginners, any comment would be greatly appreciated of course. 
> 
> For the learning experience, we are going to launch a new interactive learning website. Stay tuned on that, I will share the info here once it's available (hopefully this week).
> 
> You might be interested by the embedded programming competition that we organize in October: www.makewithada.org
> 
> Looking forward seeing you projects,
> 
> [1] https://github.com/AdaCore/Ada_Drivers_Library
> [2] https://github.com/AdaCore/Ada_Drivers_Library/tree/master/examples/MicroBit

Hi Fabien
I have looked at the Ada Drivers Library, and tried to work with it, though I have not had much luck. I think that I don't understand the difference between the board support packages and the drivers well enough, and where I need to be building things to access the required libraries to make much progress.
I think that Adacore choosing to support the microbit is a good idea. The microbit gives a lot of choices for how to interact with it. You can start with micropython and go on to other programming languages from there. 
Trying to understand a topic/learn something new from a distance without any experience or guidance can lead to trouble. Picking where to start is the most difficult part, every path seems equal when you know nothing. 
The advice from Dmitry seems to have been very wise and I have been able to find some really good information to get be started with either the Beaglebone Black or the Raspberry Pi. The Exploring Beaglebone Black book by Derek Molloy seems to be exactly the sort of resource that I have been looking for (there is no Ada programming, but I can add that in later with a bit of luck). There is enough information about the background Linux environment to get me started. 

Regards
Mike Blake   

Re: Ada: A beginners experience

[Dennis Lee Bieber]

On Mon, 16 Jul 2018 18:18:02 -0700 (PDT), blakemichael073@gmail.com
declaimed the following:

>I have looked at the Ada Drivers Library, and tried to work with it, though I have not had much luck. I think that I don't understand the difference between the board support packages and the drivers well enough, and where I need to be building things to access the required libraries to make much progress.
>I think that Adacore choosing to support the microbit is a good idea. The microbit gives a lot of choices for how to interact with it. You can start with micropython and go on to other programming languages from there. 
>Trying to understand a topic/learn something new from a distance without any experience or guidance can lead to trouble. Picking where to start is the most difficult part, every path seems equal when you know nothing. 
>The advice from Dmitry seems to have been very wise and I have been able to find some really good information to get be started with either the Beaglebone Black or the Raspberry Pi. The Exploring Beaglebone Black book by Derek Molloy seems to be exactly the sort of resource that I have been looking for (there is no Ada programming, but I can add that in later with a bit of luck). There is enough information about the background Linux environment to get me started. 

	Problem is that Molloy is from the era of Debian Wheezy and kernel
(run-time) Device Tree loading and the "Cape Manager"... Jessie saw the
transition to using u-Boot Device Tree loading and removal of the Cape
Manager... And Stretch has just taken that further... Pretty much anything
to do with device trees and pin-muxing has changed. And some of what I've
read implies that even the sysfs method of accessing GPIO and other
peripherals will be changing.



-- 
	Wulfraed                 Dennis Lee Bieber         AF6VN
	wlfraed@ix.netcom.com    HTTP://wlfraed.home.netcom.com/ 

Re: Ada: A beginners experience

[fabien.chouteau]

On Tuesday, July 17, 2018 at 3:18:04 AM UTC+2, blakemi...@gmail.com wrote:
> Hi Fabien
> I have looked at the Ada Drivers Library, and tried to work with it, though I have not had much luck. I think that I don't understand the difference between the board support packages and the drivers well enough, 

Maybe this doc will help you:
https://github.com/AdaCore/Ada_Drivers_Library/blob/master/docs/design.md

> and where I need to be building things to access the required libraries to make much progress.

The best is to start from examples and then move from there.

Re: Ada: A beginners experience

[Philip Munts]

Try MuntsOS, available at: http://git.munts.com/arm-linux-mcu

If you are willing to cross-compile from Debian (or equivalent) Linux, MuntsOS provides a reduced OS environment and cross-toolchains including FSF GNAT.  You can develop programs for the Raspberry Pi Model Zero ($5), any other Raspberry Pi model, and the BeagleBone family including the PocketBeagle.

For native development (e.g. Raspbian on the Raspberry Pi), you can use the regular Debian GNAT packages and my Linux Simple I/O Library at: http://git.munts.com/libsimpleio

Nearly all of Ada example programs in MuntsOS can be compiled and run natively as well.

Regards, Phil

Re: Ada: A beginners experience

[blakemichael073]

On Friday, July 20, 2018 at 9:08:40 AM UTC+8, Philip Munts wrote:
> Try MuntsOS, available at: http://git.munts.com/arm-linux-mcu
> 
> If you are willing to cross-compile from Debian (or equivalent) Linux, MuntsOS provides a reduced OS environment and cross-toolchains including FSF GNAT.  You can develop programs for the Raspberry Pi Model Zero ($5), any other Raspberry Pi model, and the BeagleBone family including the PocketBeagle.
> 
> For native development (e.g. Raspbian on the Raspberry Pi), you can use the regular Debian GNAT packages and my Linux Simple I/O Library at: http://git.munts.com/libsimpleio
> 

> Nearly all of Ada example programs in MuntsOS can be compiled and run natively as well.
> 
> Regards, Phil

Hello,

I have found your libsimpleio library and I am going to try and use it soon. I have a beaglebone black which I am going to try and get started with programming on soon, I just need to connect to a monitor etc. When I run in to any problems I hope that it is okay to ask for some guidance.

One of the unusual parts of learning technology in general is the 'moving target' nature of the field. Tutorials that are very practical in nature are obsolete very quickly when the complier/operating system/drivers etc are updated. This takes a little getting used to, and is very different to my previous field of study.

Anyway the good news is that I think that I can see a viable pathway to getting underway with a different approach. There seems to be more learning material available for embedded linux, and it is easier to relate it to simple application programming. 

Regards
Mike Blake   

Re: Ada: A beginners experience

[Dennis Lee Bieber]

On Sun, 22 Jul 2018 21:04:05 -0700 (PDT), blakemichael073@gmail.com
declaimed the following:

>
>One of the unusual parts of learning technology in general is the 'moving target' nature of the field. Tutorials that are very practical in nature are obsolete very quickly when the complier/operating system/drivers etc are updated. This takes a little getting used to, and is very different to my previous field of study.

	The BBB is especially afflicted with that... The earliest documentation
is based upon Angstrom OS, later stuff on Debian Wheezy with run-time
cape-manager to load kernel device tree overlays... While the last year or
two have seen the drop of the cape-manager and a move to u-Boot loading of
device tree overlays. And let's not think about the two competing PRU
systems...


-- 
	Wulfraed                 Dennis Lee Bieber         AF6VN
	wlfraed@ix.netcom.com    HTTP://wlfraed.home.netcom.com/ 

Re: Ada: A beginners experience

[fabien.chouteau]

On Monday, July 16, 2018 at 11:25:34 AM UTC+2, fabien....@gmail.com wrote:
> For the learning experience, we are going to launch a new interactive learning website. Stay tuned on that, I will share the info here once it's available

It's live : learn.adacore.com

Re: Ada: A beginners experience

[G. B.]

<blakemichael073@gmail.com> wrote:
> Greetings,
> . At the moment I spend too much time trying understand how to make my
> tools work, and not enough time using my tools. 


The GNAT User‘s Guide used to have an introduction to getting from source
to executable. The relevant sections were, or are, instructive; they go
beyond just mentioning the knobs and switches of the current tool chain.
They explain compiling, binding, and linking so as to make you understand
what you are doing when you need a compiler for producing your executable.

I thought that the time spent reading this well written guide was both
helpful and enjoyable. Understanding translation is part of becoming a
successful apprentice.

Re: Ada: A beginners experience

[Simon Wright]

G. B. <nonlegitur@nmhp.invalid> writes:

> <blakemichael073@gmail.com> wrote:
>> Greetings,
>> . At the moment I spend too much time trying understand how to make my
>> tools work, and not enough time using my tools. 
>
>
> The GNAT User‘s Guide used to have an introduction to getting from
> source to executable. The relevant sections were, or are, instructive;
> they go beyond just mentioning the knobs and switches of the current
> tool chain.  They explain compiling, binding, and linking so as to
> make you understand what you are doing when you need a compiler for
> producing your executable.
>
> I thought that the time spent reading this well written guide was both
> helpful and enjoyable. Understanding translation is part of becoming a
> successful apprentice.

Beginning here:
http://docs.adacore.com/gnat_ugn-docs/html/gnat_ugn/gnat_ugn/getting_started_with_gnat.html

However, OP is looking to work with microcontrollers, and that's likely
to be a bit more fraught.

Re: Ada: A beginners experience

[Paul Rubin]

Simon Wright <simon@pushface.org> writes:
> However, OP is looking to work with microcontrollers, and that's likely
> to be a bit more fraught.

Yes.  OP, someone else suggested starting out with desktop systems until
you get a little more familiar with programming in general.  Embedded
adds a big layer of complexity to getting even simple things done.  A
multi-stage toolchain like Ada uses adds even more complexity.