This is series of interviews with software developers interested in Ada programming language. The goal is to promote the community members and the language itself. Do you want to take part in this? Contact me!
The previous interview, with Fabien Chouteau, can be found here.
I’m Edward Fish, my formal educational background is Computer Science with a bit of passion for Software Engineering. I taught myself programming with Turbo Pascal for Windows 1.5, just the compiler and printed documentation back when I was perhaps 12 or so. After that I did a little Delphi 5 and got into college where we did C, C++ and Java — the former two were quite a shock because of how bad these were from a usability and correctness perspective: at least 90% of the segment fault/core dump errors beginning students encountered could have been detected by the compiler given saner language-design.
During this time I developed a bit of a passion for Operating Systems and their design, as well as a dislike for C, Unix, and Linux — the latter because any time I brought up my interest in Operating Systems my fellow-students in the CS program would say “why don’t you just download Linux [and tweak it from there]?”, completely missing the point that I didn’t want to merely “tweak” other source code, be constrained to their design & architectures, or hampered by the implementation-language’s (read C’s) pitfalls — and ended up writing an OS (or rather the beginnings of one), in Borland Pascal 7. I got it to the point where I had screen-display/mode-control, could recognize commands, and then got stumped on memory-management (which I wanted to be available not only to the OS, but programs as well, much like .NET Framework or Java do for their programs) before getting swamped with schoolwork and backburnering the project.
I was introduced to Ada in one single class, Programming Languages, which did a high-level introduction/survey of various languages and instantly felt at-home. It did raise the question as to why a lot of the features aren’t common in more languages: range-types; tasks; generics that can take functions, values, and other generics as parameters — why do so many languages instead opt to copy C and its inherently broken syntax and anemic view of problem-solving? — I still don’t have a real answer to this question, but suspect that it’s because C was easy to implement and basing a language on it allowed a lot of language-designers to skip-over the hard parts… essentially ignoring “Everything should be as simple as it can be but not simpler!” because the superficial solution seems to work; much like trying to use RegEx to parse HTML or CSV.
After getting my degree, most of most of my career has been maintenance, everything from PHP to VB.net to C#, and it’s this experience that made me really appreciate how Ada was designed for both correctness and for maintainability. About a year ago I got onto the ARG and VASG boards, the standardization bodies for respectively Ada and VHDL, albeit as a nonvoting member on both.
Nowadays I’m working for NMSU at the Dunn Solar Telescope at the observatory in Sunspot, NM. The system has everything from a vxWorks running on a Motorola 68k to Solaris running on SPARC and Intel, to Windows 7 and Server 2008, all kind-of organically grown over the course of three or four decades. — Right now I’m doing more IT support than software-development, but I do have the intention of simplifying things into a designed system which Ada plays a big part.
As some people have answered there’s no single feature — I really like Tasks, the generics, Private types, and Packages… but I suppose a lot of this can be distilled to a single feature: design which values correctness and maintainability.
It’s arguable if that’s a feature of the language though, so I’ll let the readers decide the answer for themselves.
If you’re referring to the language itself, then how protected-objects expose implementation within the specification rather than forcing that into the private or body of the protected object.
If you’re referring to the standard-defined/-mandated libraries and such, then the combinatorial explosion of packages due to
Wide_Wide_Character, their respective
Strings, and text-handling — I’d really love to condense these down so that e.g.
[Wide_[Wide_]]Text_IO were merely instantiations of a single generic package.
I can see it going both ways, though obviously I hope for the good outcome. A lot of the issues can be illustrated by the dominance of the language by AdaCore; on one hand it’s problematic in that they’re ignoring a lot of possibility by marketing to the safety-critical and embedded-systems folks, on the other it’s positive in that there is some corporate sponsorship of the language.
There’s a lot the language offers, and I think that a game-company jumping on the language could dominate the industry on a technical level… or an OS developed in Ada, taking advantage of things like the Task construct — but both of these have other factors that would make-or-break their success: the game-company is going to fail if the games aren’t fun or they treat their customers poorly, even if vastly technically superior; just like the OS will fail if they mindlessly copy existing OS-environments (e.g. rewrite Linux in Ada!) or don’t have user-applications.
There’s also a lot of “chicken-and-the-egg”-style bootstrapping problems that need to be overcome in various ways. Just like the OS example above, or new/better tooling, or a successful game-company, or even getting a new & functional open-source compiler into the environment. It’ll take a lot of work, and perhaps a little luck, but the best possible future of Ada is great… and even a modestly good future is pretty good.
Towards alleviating some of these problems, I am working on re-launching Byron — which is a MIT-licensed Ada compiler written in Ada — after I redo the design-documentation; and I am interested in doing an OS in Ada, and might start a thread to that effect on OS-dev and/or comp.lang.ada if and when I write up a design-document for it.
Aside from the stuff already going in like parallel-blocks, parallel-for, and reductions? My own proposal, which is a way to automatically instantiate generics from the parameters of generics — admittedly some of that might be my own pride, but I think the idea could be helpful in allowing tighter, more maintainable code.
It would also be really nice to have a sort of provable, abstract generic whereby [current (and future)] features of the language could be described and verified… but that’s getting into a sort of meta-language rather than the language itself.