The text of the Ada Reference manual is the source of the formal Ada Programming Language Standards. This site contains the ARM in multiple formats, the master version control system for the original source files (including the source for the tools) for the ARM, and other helpful documents. File:Ada Programming Keywords.pdf, File:Ada Programming Operators.pdf Licensing Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. Programming in ada 2012 Download programming in ada 2012 or read online here in PDF or EPUB. Please click button to get programming in ada 2012 book now. All books are in clear copy here, and all files are secure so don't worry about it.

If Im going to make robots, which language do you recommend me? In our university we can choose between several languages. Most of the students are choosing Ada just because our teacher uses it.

After some research I found out that ada is old. What are your thoughts? Is is worth to learn it?

7 Answers

Yes. Very much so, in my opinion.

Ada is very good in two points that are often overlooked in other programming languages:

• The generic system: packages, functions, and procedures can all be generic. This works together particularly well for ingraining the DRY [Don't Repeat Yourself] principle. Yes, you can go overboard on generics, but the thing I've seen in (other language) projects was that cut-and-paste programming seems to be more common. [and that just introduces multiple points-of-failure if a bug needs fixed on that spot of code.]
• Native multitasking. One of the great things about a language-level tasking feature is that multithreading doesn't feel 'tacked on' and isn't an unwieldy extension but integrated into the language.

That said, there's other good reasons to learn/use Ada. One is the picky compiler, by being so picky it forces you to start to think in ways that naturally reduce programming errors. (Like the prohibition on and and or in the same conditional.)

Another is the concept of subtypes; subtypes are the opposite from objects in OOP, instead of branching out the further derevitions you go, you narrow the type (it's acceptable values) the more you get away from the base type. {Think of it in terms of proper sets; Integer is your base type, Natural are your non-negative Integers, and Positive are your positive-integers... and with Ada 2012, you can have interesting exclusions on your subtypes, say Primes which are subtypes of Positives (sorry for being a bit vague on that last point; I'm still learning the 2012 stuff).}

With Ada 2012, you can also have pre- and post-conditions on your subprograms; this alone can make your libraries more stable. (As can null-excluding pointers.)

Peter Norvig's advice is probably relevant here:

When asked 'what operating system should I use, Windows, Unix, or Mac?', my answer is usually: 'use whatever your friends use.' The advantage you get from learning from your friends will offset any intrinsic difference between OS, or between programming languages.

The whole essay is a good read.

Incidentally, Ada was the first language that I learned. Learning Ada first had one major advantage: no one uses Ada, so I was forced to learn another language before doing anything else, and thereby gain perspective. One of the worst problems that beginning programmers can have is the belief that the way things are done in their first language is just The Way Things Are Done. Learning a new language is easy and immensely valuable.

If your teacher and most of your fellow students use Ada, it is probably best to go with Ada. It is a very good language, both for small and large scale programs. It is very readable and it protects you (to some degree) against a lot of common mistakes.

Ada is for software engineering. As darkestkhan said, it is not a 'hack and hope for the best' language.

The advice of Paul Stansifer is very good: Learn several languages. Make sure you have a plenty of tools at your disposal - don't limit yourself to just one language. The perspective you gain from learning different languages is very valuable. There's definitely more than one way to skin a cat - take a look at Haskell for example. You'll gain a whole new perspective on how to solve problems.

Language syntax is the least of learning how to program. The hard part is learning how to model complex real world problems into something that makes sense in the very limited scope of a programming language. With its strong type system, tasking model, generics and solid tools for real-time and concurrent programming Ada is ideally suited to this job.

Since you're asking specifically about robotics, a good book to get might be 'Building Parallel, Embedded, and Real-Time Applications with Ada' by John W. McCormick, Frank Singhoff and Jerome Hugues. It's a very good read.

Ada is definitively worth it. In addition to 2 things written by Shark8 one has to add that almost all languages are focusing on the easiness of writing instead of reading (and most often you are going to write once and read many times). Also culture surrounding Ada is quite different from mainstream - focusing on correct working of programs and readability of source instead on 'hack and make it work while counting on luck that no bugs will introduced'.

As for age - oh, come on - C is even older. What is so important about the age of language itself? you should take look at what was put into Ada 83 first before you can even speak about age being issue (hint: mainstream languages started reaching feature set of Ada 83 in second half of 90s, and many features [notably subtypes] still aren't in mainstream). Beside newest Ada standard is from 2012 - if you can call that old then I don't know what is 'new'.

While Shark8 has some very good points about Ada as a language in general, the question was specifically about robotics. In this respect, I would say 'don't bother'. After more than 10 years of experience doing all sorts of robotics that range from Lego to state of the art robot arms and hands, I have never seen a robotic system that used Ada.

At the end of the day, robotics is hard. So hard that you are not going to tackle it all on your own. And that means leveraging lots of existing libraries and frameworks. And this means that you will be using their languages, interfaces, etc. Your robotic system will likely include a mountain of code, only a tiny fraction of which will be custom for your specific application. While it is possible to write your tiny part in Ada and do some wrapper or interface so it can play nice with the rest of the code. But I think you will find that is a lot of work with very little benefit.

When embarking on a new robotics project, i take a pragmatic approach. I look at the existing tools, libraries, and utilities and pick the one that best suits my needs. Then i use whatever language it does. And 95% of the time that is C++ or Python.

C++ isn't exactly a spring chicken you know. I think it is all of one decade younger than Ada.

To make matters worse, both C++ and C# derive the core of their language from C, which is actually a decade older than Ada.

C was designed to make construction of compilers easier (not the programmer's job) back in the days when 16KB was a lot of RAM and hard drives were as big as industrial air conditioners. C++ basically started as good old late-60's C with OO features bolted on, and C# is essentially Microsoft's tweaks to C++ to make it more Java-like. At their core, C# and C++ are actually older than Ada.

There are a lot of hip new languages out there to learn (and at some point you should learn them). However, C++ and C# aren't them.

It depends on what you want to do with this language. Lisp is even older than Ada and is widely used within artificial intelligence. Learn the language you want to, learn the language which is easy for you to learn and easy for you to understand it's concepts. Then you can go further and learn more languages.

Original file ‎(1,240 × 1,753 pixels, file size: 3.2 MB, MIME type: application/pdf, 410 pages)

Licensing

Original upload log

• 2007-12-28 19:28 ManuelGR 1275×1650× (2822082 bytes) Updated version based on [[:Image:PDF template..sxw]]
• 2007-06-23 20:03 ManuelGR 1239×1754× (2726374 bytes) New version with table of contents. Generated using OpenOffice.org export to PDF feature. JPEG compression for images.
• 2007-06-23 19:44 ManuelGR 1239×1754× (7272933 bytes) New version with table of contents. Generated using OpenOffice.org export to PDF feature.
• 2007-02-04 23:14 ManuelGR 1237×1752× (1520540 bytes) Updated version.
• 2006-11-02 07:20 Krischik 1239×1754× (1304936 bytes) New version from 2. Nov. 2006. This PFD is part 2 of a 3 volume set.
• 2006-06-22 22:43 ManuelGR 1237×1752× (1188907 bytes) Updated version
• 2006-01-09 22:35 ManuelGR 1237×1752× (1033686 bytes) PDF version of [[Ada Programming/All Chapters]]. Generated using Mozilla Seamonkey and CUPS PDF printer.

File history

Click on a date/time to view the file as it appeared at that time.

File usage

Global file usage

The following other wikis use this file:

• Usage on bn.wikibooks.org
• Usage on en.wikibooks.org

Programming In Ada David Cook

Metadata

Concurrent And Real-time Programming In Ada Pdf