Hacker News Reader

Comment by ksec | Hacker News Reader

>Ada can be difficult to approach due to using a different vernacular to most other languages,

I guess people dont learn Pascal anymore. I still remember Turbo Pascal was what brought me into programming. It took me a very very long time to get used to C style programming.

View on HN

It's a real pity. They are awesome beginner languages, and even when you are not a beginner any more, they go a long way. I also like their syntax a lot.

I haven't touched Ada in like 20 years and now that it seems to be having a small resurgence it looks like a good time to relearn it. It has potential to become one of my favourite languages.

I find this somewhat amusing as Ada occupies the same space that Rust is in. At first glance I find Ada vastly more approachable than Rust, which to me feels like line-noise language/Perl. Or even C++ tbh.

But I can relate that Ada feels like you should be writing it one a flickering green terminal in ALL CAPS and debugged with a daisy wheel printer.

Or a Ada Machine, that is how Rational was founded.

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

http://datamuseum.dk/wiki/Rational/R1000s400

Think Lisp Machine experience, with Ada instead.

> But I can relate that Ada feels like you should be writing it one a flickering green terminal in ALL CAPS and debugged with a daisy wheel printer.

In a way, the reason for such a limited character set and clunky syntax (including, e.g. case insensitivity) was precisely to maintain backward compatibility with those earlier machines.

I learn Turbo Pascal before Turbo C (about 2 decades ago, in high school). Both used the same procedural programming approach. It was a really easy switch.

Trying to learn Haskell after C++, on the other side, was difficult for me.

The thing that tripped me up the most in Ada was the single quote syntax.

    Character'Val

I literally failed an exam because I couldn't locate the right function in the online manual for 2 hours. And I'm pretty liberal .. I like lisp, forth and APL but still to this day, it trips me up.

Attributes tripped me up as well, which is why I talked about them in the presentation. The language server provides completions for them, which helps significantly.

I don't think it's about the Pascal syntax. Nobody complains about using Lua, Ruby, Crystal, Elixir. Do...end blocks are perfectly fine syntax wise. Go is a Wirth lineage language too. The issue is tooling, languages like VHDL and Ada (to a lesser extent SQL too) have poor developer experiences and they never bothered to improve and add more syntactic sugar like C++ and Java.

No, the language is constantly evolving (ada95, 2012,2020), and they do add syntax sugar and new features on a regular basis.

You can submit language rfcs here: https://github.com/AdaCore/ada-spark-rfcs

For an example of the latest additions : https://blog.adacore.com/ada-202x-support-in-gnat

As to the developer experience, I find the tooling to be quite satisfactory (IDE, build system, memory/stack analyzers, provers, etc) , the main pain point being the lack of a decent package manager (there is one now, but there are few packages).

Edit: almost all the standard c/c++ tools work out of the box as well (profilers, debuggers, etc), so it's no different from c/c++ on this regard.

almost all the standard c/c++ tools

By that do you mean the GNU ones, or…?

Gnu, intel vtune, rr, pernosco, etc. Basically anything which works from a binary with dwarf symbols. The compiler is actually gcc.

In the interest of completeness: GNAT is the most well-known Ada compiler and uses GCC as its backend, but there are at least 6 other commercial Ada compilers out there. [0] As far as I know, GNAT is the only one that uses GCC.

[0] https://news.ycombinator.com/item?id=27603292

You're right, thanks for the clarification. I tend to see gcc as the only major ada compiler, and afaik, the only one implementing all the latest additions to the language.

I think PTC has upgraded to Ada 2012, or so I hear.

It has, since two years now.

https://www.ptc.com/en/products/developer-tools/objectada

> Go is a Wirth lineage language too.

Is this commonly accepted? I thought it came off the better-C camp, plus GC.

https://en.wikipedia.org/wiki/Limbo_(programming_language)

See Robert Griesemer's talk on "The Evolution Of Go"

https://www.youtube.com/watch?v=0ReKdcpNyQg

https://go.dev/talks/2015/gophercon-goevolution.slide

> In 1960, language experts from America and Europe teamed up to create Algol 60.

> In 1970, the Algol tree split into the C and the Pascal branch.

> ~40 years later, the two branches join again in Go.

https://go.dev/talks/2015/gophercon-goevolution.slide#29

Yes, not only did Robert Griesemer work under Niklaus Wirth assistence doing a PhD on an Oberon variant, the Go method syntax is based on Oberon-2, and unsafe meta-package is pretty much UNSAFE package from Oberon/Modula variants.

Then you merge that with Limbo's syntax and channels, and you more or less get Go.

Arguably it's more a comeback from Alef, this time with GC faction winning.

(C begat a bunch of research languages, those begat Alef, a conflict about whether to add GC led to Alef dying and its features reimplemented as Plan9 libraries with side effect of Limbo, years later Go is built on top of Plan9 C compiler & runtime with syntax sugar for Alef-derived libraries).

Sure, still neither of them have Oberon-2 method syntax nor UNSAFE meta package.

Plan 9 compiler was used as means to quickly get a prototype running, and naturally Rob Pike knows the toolchain quite well.

I also agree with the Alef remark.

The legacy of Plan9 compiler stack still remains despite being rewritten purely in Go - I'd say that Pike liked his previous design :)

Lol, I actually realized that the other day, hacking on the golang compiler. The amd64 cpu instruction definitions are in a file called asm6.go and I was all "wait a minute, I recognize this from plan 9", where the amd64 compiler, linker, and assembler are 6c, 6l, and 6a respectively.

Before Go 1.5, it would literally keep around an alternative port of Plan9 C compiler plus all core system libraries, and I think it still does for C ffi

There's a lot of Pascal in go's approach to compiling/modules etc. I'm not sure I can agree there's a lot of Pascal in go syntax.

If you removed the c pre-processor and translated (the syntax of) a Pascal program to C, I imagine it might look a bit like go if you squint?

I'd say go is to Pascal and C as Javascript is to Scheme/Self and Java.

> have poor developer experiences and they never bothered to improve and add more syntactic sugar

Ada actually did in Ada 2012 and moreso in Ada 202x.

- Expression functions, and expression forms of if/else and case statements

- more natural "aspect" versions of a lot of pragmas

- iterator syntax for containers which can be user-defined

- user-defined indexing into containers (Variable_Indexing and Constant_Indexing)

- user-defined aggregate initialization (such as for containers, the Yeison library exploits this to provide JSON-like initialization)

Overall though, the language syntax is coherently put together with orthogonal elements, despite the various pieces coming together over decades. The language designers have done a superb job ensuring that Ada 2012 felt uniform, and not like a collection of bolted on parts.

Ironic to put it that way, given that Ada was of the first languages with commercial IDEs available.

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

Now you can complain that none of them exist as free beer, and that GNAT Studio came too late, but that is another matter.

I went from Pascal directly to C. Had no issues. It was a relief not to have to do BEGIN END anymore :-) Never wrote another line of Pascal.

https://www.freepascal.org Spend your weekends coding Pascal.

I'm generally sympathetic to Ada and its design decisions, as compared against C, but on this point I agree. C's braces syntax is at least as readable. If anything I'd say it's more readable as there's an immediately obvious visual symmetry between the two brace symbols.

I also prefer the C++/modern C approach to declarations, where local variable declarations can be freely intermixed with other statements. Ada uses a noisier declare/begin/end syntax. [0][1]

[0] https://stackoverflow.com/a/59192530/

[1] https://www.radford.edu/~nokie/classes/320/declareblocks.htm...

Not me. I took typing in high school and pressing Shift and stretching fingers to get braces is much harder on my hands then typing a few extra unshifted letters.

This always sends me to HyperPolyglot* for a syntax comparison.

* https://hyperpolyglot.org/pascal

Reply on news.ycombinator.com