syntax difference

[Chris Angelico]

On Wed, Jun 20, 2018 at 8:14 AM,  <bart4858 at gmail.com> wrote:
> Features? Important ones? Go back 40 years and see how important they were then. Most of them,nobody had heard of, and would not be meaningful.
>

Let's see. Forty years ago was 1978. Databasing was a little bit
important. I mean, not much... just that it was the main reason a lot
of companies would buy computers. It was a simpler time; a time when
people didn't have to worry about silly things like "standards",
because you would just always buy from the same manufacturer. You
didn't have to worry about "security" because people didn't send
information out on the internet. Oh, and people like you weren't
writing programming languages, so nobody cared about checklists.

Fortunately, it's 2018, and we have this little thing called the
"internet" in every single person's home, more or less. Internet
protocols, consequently, are fairly important.

> Now do the same with my list - most are programming features that could be understood and appreciated even then.
>
> Finally, imagine going forward 40 years; how many of those acronyms will still be relevant?

Here are all of the acronyms I used:

* TCP, UDP: Definitely going to be relevant for the foreseeable future.
* HTTP, SMTP, IMAP: Probably going to be relevant.
* SSL: Definitely relevant, although you might prefer to use the
acronym "TLS" today, and maybe others in the future. But the concept
will still stand, and libraries will migrate.
* JSON, MIME: Likely to be relevant. Maybe others will be as well, but
without tipping these out.
* GUI: Definitely relevant. So long as we have humans, GUIs will be wanted.
* GNU: https://xkcd.com/1508/
* lzma: Maybe, maybe not.
* sha: Definitely.

I'd go with "most of them".

> But anyone still involved in coding algorithms will likely still find some of my features useful. Although the language will long be gone.

Ahh, coding algorithms. Okay. Do you have:

1) A way to guarantee that a function is pure?

2) A simple means of constructing a list/array from another list/array
by performing a transformation on it? ("map" or a comprehension)

3) A simple means of filtering a list/array to only those which fit
some criterion? ("filter" or a comprehension)

4) First-class functions, and closures?

5) A way to easily see whether a function will mutate its arguments?

That's a basic start. If you can do all of those, you might possibly
have a language that is beautifully aimed at whiteboards and
blackboards across the world. Mathematicians will love you.

ChrisA