Hacker News Reader

Comment by johnisgood | Hacker News Reader

> I don't know the exact rules

This pretty much sums it up for me. You need to know so many rules... you need to know what those symbols mean... when people refer to Perl's syntax that they frown upon, they are referring to this: heavy use of symbols whose meanings must be memorized. I cannot just look at the code and understand it as I can with say, Ada. Pretty frustrating. I do not have to learn Ada to know what the code does. Funny that. :D At times Rust code looks very similar to Perl and Haskell. Especially Perl.

View on HN

Yeah I mean, it really depends on your perspective. The compiler has your back; there's no need to memorize the rules, because that's what it's there for.

Forget the rules and don't write a lifetime where you needed one? You get this:

    error[E0106]: missing lifetime specifier
     --> src/lib.rs:1:29
      |
    1 | fn foo(x: &i32, y: &i32) -> &i32 {
      |           ----     ----     ^ expected named lifetime parameter
      |
      = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
    help: consider introducing a named lifetime parameter
      |
    1 | fn foo<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
      |       ^^^^    ^^^^^^^     ^^^^^^^     ^^^

It even shows the syntax and where things changed.

Now, it's not an AI; this may not be the signature you wanted, exactly, but the point is, you don't need to memorize the elision rules. You just don't write any lifetimes until the compiler makes you deal with it, and then you deal with your problem, and move on with life.

Yeah, I do find the compiler errors useful, I just wish I did not have to see them to understand the code. I am not really trying to "trashtalk" Rust or anything, I just "keep on" expressing my opinion on my dislike of heavy use of symbols. That is all. :) I have written plenty of Perl code, too, and I was even proud of myself! Problem is that after a few weeks I could not tell what particular bits of code did. :D

"There comes a time when words are more appropriate than symbols."

I have a camel tattoo. I don’t find a Rust to look anything like Perl. YMMV :)

I find Ada very hard to read. ... come to think of it, doesn’t it also have unbalanced apostrophes? It’s been a while.

Yeah, it does have its differences, that is true.

> unbalanced apostrophes?

What are you referring to exactly? Can you give me an example? Do you mean something like Integer'Last, which is the largest value of type Integer?

Yes! This syntax is in the first example on https://learn.adacore.com/.

As for the above example: they are called attributes. Here is a list of attributes: https://en.wikibooks.org/wiki/Ada_Programming/Attributes

> The concept of attributes is pretty unique to Ada. Attributes allow you to get - and sometimes set - information about objects or other language entities such as types. A good example is the Size attribute. It describes the size of an object or a type in bits:

    type Byte is range -128 .. 127; -- The range fits into 8 bits but the compiler is still free to choose.
    for Byte'Size use 8; -- Forces the compiler to use 8 bits.

I find it particularly neat.

Of course one of the best things I love about Ada is pre- and post-conditions or contract-based programming (that are actually checked, unless in languages like Kotlin that just bolted on some contracts that are just there for the reader, i.e. pretty useless, to be honest). Ranged types are awesome, too, as you tell the compiler the range you want and the compiler chooses an appropriate sized integer to suit the range, which is the important bit. For example, instead of asking for "16-bit signed integer", you say: "I want a type which can store values between -1 and 1000", and maybe even a hint for the compiler where you can ask the compiler to pick you a faster type or a smaller type, so you say:

    type Index is range -1 .. 1000;

Types like these are much more readable, and you can use attributes on them such as 'Min, 'Max, 'Range, and so forth. It is such a good feature, and you can remove the range checks if you want, and you can even have them checked at compile-time. These kind of features are what I would like to see from a C replacement.

See more at https://learn.adacore.com/courses/intro-to-ada/chapters/stro....

---

https://www.adaic.org/learn/materials/intro/part1/

https://www.adaic.org/resources/add_content/docs/craft/html/...

https://www.adaic.org/advantages/features-benefits/

https://www.radford.edu/nokie/classes/320/designGoals.html

https://hackaday.com/2019/09/10/why-ada-is-the-language-you-...

Those links might give you some idea about the language and its goals, if you really are interested. Of course there are much more, up-to-date sources, but I think these got most of it right.

Thanks. I went through all of the learn.adacore.com stuff, but it was like 18 months ago.

You know what? You might be even able to implement this in Rust!

    index = num(-1->1000);

or something. :D

I dunno how attributes would work, but man, they really are handy. It is very, very difficult to shoot yourself in the foot.

Rust's "associated constants" are a very similar feature. You can also do runtime checked ranged integer types, and compile-time checked ones, though that's very awkward at the moment. It'll get un-awkward at some point; an implementation of the feature needed is in nightly.

> have unbalanced apostrophes? It’s been a while.

I see what you did there (but maybe you don't see it yourself :-)

PS: at least MY parentheses are balanced.

You don't need to know the rules though, it's impossible to get the rules wrong, the compiler will check for you.

> "Pretty frustrating. I do not have to learn Ada to know what the code does"

That seems unlikely, or anyone - even if they hadn't learned to program ever - would be able to read Ada. More likely that a) you've already learned enough to cover Ada by learning other programming languages or b) you assume you know what the Ada code does but are incorrect.

Let's charitably go with a) then what you're implicitly supporting is that "all languages must look and behave the same, and there's no possible benefit in a language being different enough that it requires me to learn something new".

And therefore that the lowest-common-denominator intersection of all popular languages combined is also the pinnacle of language design.

Something which seems unlikely.

I am referring to the explicitness of the code. What the code does is not hidden behind symbols, for example. I probably have learnt enough to cover Ada by learning other programming languages, but it somehow does not apply to reading Rust vs. reading Ada, is what I meant. Of course you do have to follow some guidelines to make the code even more readable, but still. For me, without knowing Ada and Rust, Ada is way much easier to understand. Ada was designed with maintainability and readability in mind, and I think it shows, at least according to my experience. People have written stuff like "I see Ada as a verbose language, however, unlike say Java, the verbosity actually benefits readability.". I find it to be true.

Perhaps you could compare some Ada code (something from AdaCore (GNAT, GNATColl)) with the Rust equivalent.

> "For me, without knowing Ada and Rust, Ada is way much easier to understand."

If you don't know Ada then you don't /know/ that you understand it, you're assuming you do - and if you do that's because it looks like languages you already know. And if that's what you're saying is good about it, then what you're saying is "things I know are good". You're seeing "Ada looks familiar" and saying "Ada has good design" as if those are the same thing. You only need to look at some beginner programming discussions to see that block-structured, scoped, procedural, looped, branched, etc. features are not things people are born understanding - that you know them already and Ada has them is convenient for you.

> "What the code does is not hidden behind symbols, for example."

I looked at the Wikipedia page, it has equals, colon-equals, slash-equals, greater-than, less-than, apostrophe, parentheses, ampersand, double-quotes, equals-greater-than which seems to be an arrow not a comparison, double-dots, and of course "when" "is" "protected" etc. they're as much symbols as they are words.

> "Ada and Rust, Ada is way much easier to understand"

I'll quote Erik Naggum from an old comp.lang.lisp(?) comment: "When I work at this system up to 12 hours a day, I'm profoundly uninterested in what user interface a novice user would prefer.".

Reply on news.ycombinator.com