4 ms·

I think that it is sad that we keep on creating new programming languages that are not radically different. The Zig language ecosystem faces the same problems a

I think that it is sad that we keep on creating new programming languages that are not radically different. The Zig language ecosystem faces the same problems as C and the compiler will preform many of the same tasks, lexing, parsing, optimizing, documentation, supporting all sorts of weird edge cases and use cases. From what I see in the introduction, I don't see a convincing case for a new language here. This kind of incrementalism is not worth another persons years of effort to create a parallel path. I think that if you are going to spend years creating a new language, you ought at least to try something new. Otherwise, you become just another amateur landscape artists. Maybe you're paintings will look nice, but they'll never really be of any great value to society.

ngrilly 9y ago
I disagree. We don't have enough incremental improvements, because it's difficult to improve a language and migrate the existing code base at the same time. I'd be happy with a better C (for example get rid of header files and #include), a better Python (for example better parallelism without a GIL), a better Go (for example with a solution for generics and marginally less verbose error handling), a better JavaScript, etc. I'm mentioning "mainstream" languages on purpose.
sitharus 9y ago
The problem with incremental improvements is you have to keep backwards compatibility. This is a big issue when it comes to keywords. For instance this is valid C#: using async = Task<string>; class BadIdea { public async async async(async async) { } }
- steveklabnik 9y ago
  Rust has a fun similar one. I'm assuming for the same reason as C#: contextual keywords. union union<'union> { union: &'union union<'union>, } https://github.com/rust-lang/rust/blob/59675d29eb47eb743026dcc0737884f548f2197a/src/test/run-pass/weird-exprs.rs#L110-L112 https://github.com/rust-lang/rust/blob/59675d29eb47eb743026d...
  - AndyKelley 9y ago
    please, I have to know, what is evil_lincoln testing?
    - steveklabnik 9y ago
      This is why I love this file. To understand what evil_lincoln is doing, you have to understand very old Rust. Here's the commit that introduced it: https://github.com/rust-lang/rust/commit/664b0ad3fcead4fe4d22c05065a82a338770c429 https://github.com/rust-lang/rust/commit/664b0ad3fcead4fe4d2... fn evil_lincoln() { let evil <- log "lincoln"; } log was a keyword to print stuff to the screen. Hence the joke, https://en.wikipedia.org/wiki/Lincoln_Logs https://en.wikipedia.org/wiki/Lincoln_Logs Now that log is the println! macro, the joke is lost. It doesn't say explicitly why this is "weird", but given some other comments in the file, // FIXME: Doesn't compile //let _x = log true == (ret 0); I am assuming that using the return value of log was buggy, and so this tested that you could save it in a variable. I don't remember the exact semantics of log, but if it's like println!, it returns (), which is useless, so binding it to a variable is something you'd never write in real code, so it's "weird" in that sense.
- vram22 9y ago
  Here is a similar one in Python (in the sense of using the same word or identifier multiple times): x = [[1,2], [3,4], [5,6]] [x for x in x for x in x] For more details see: https://jugad2.blogspot.in/2014/03/flatten-list-of-lists-with-list.html https://jugad2.blogspot.in/2014/03/flatten-list-of-lists-wit...
  - earenndil 9y ago
    How about shell? function in() { echo $@; } for for in in; do in for; done
    - vram22 9y ago
      Ha, nice one, didn't know it could be done in shell too.
hota_mazi 9y ago
> This kind of incrementalism is not worth another persons years of effort to create a parallel path Historically, incrementalism is pretty much the only way that languages can reach mainstream status e.g. C/ObjC/Javascript/C++/Java/C#/Kotlin. Of course, having languages that break away from the mainstream is equally important to generate new avenues of research, but it's clear to me both approaches are a requirement for a healthy PLT field.
noxecanexx 9y ago
As far as I know, the only mainstream language to so what you are talking about is Eve. And I doubt it fits the use case he described in his intro.
hasenj 9y ago
The other language that does what Zig is trying to do is the Jai language that Jonathan Blow has been developing, but it's not open to the public yet. We don't need a radically different language, really. We just need a language that combines some of the best ideas that have been developing recently in a clean way while keeping the language simple, not complex. D was trying to do that but then it exploded and became a monster just like C++. It's kind of just a slightly cleaner C++, but it's still a monster.
- curun1r 9y ago
  Perhaps what we need is more tools for creating languages so that it doesn't take a massive engineering effort to create a new language and to enable language features to be implemented once rather than for each new language. That way, we could have a ton of languages and everyone can choose their own "Goldilocks" language. LLVM is a great effort in this direction and now language designers can target multiple architectures and get a ton of optimizations essentially for free. And it's great to see things like coroutines get added at that level. But more could be built at that level and on top of it to give higher-level language features in that same essentially free manner. It'd be cool to see stuff like borrow checking and garbage collection get added in a similarly reusable way. The end result of this would be that syntax, the stuff that's mostly easy and yet most prone to bike shedding and developer aesthetics, could be mostly decoupled from the serious work normally associated with creating a language and compiler. And developers with less expertise could build quality languages that appeal to an unmet syntactical aesthetic without having to reinvent as much of the wheel as is currently necessary. Instead of having one language that brings together the best ideas, we'd just make those best ideas reusable so that any language could easily bring them together using whatever syntax shakes out of the bike shedding process.
- adamrezich 9y ago
  Friendly reminder that jblow's language still isn't named, and "jai" is just the file extension currently being used.
  - billytetrud 9y ago
jaredklewis 9y ago
What languages were “radically” different when they were relased? My take: COBOL, C, SmallTalk, lisp, ML, prolog, Shell. I’m might be missing some, but I think the pattern is clear. Only C remains among the most popular languages. Almost all widely used languages today (c++, php, ruby, java, python, javascript, etc...) are incremental improvements on old ideas. I think your opinion that the most used programming languages today are not “of any great value” to be bumpkis.
- oblio 9y ago
  I'd add SQL, Forth and Prolog. Haskell also, maybe?
  - mbrock 9y ago
    Haskell was an "incremental" improvement on Miranda and a consolidation of features from a zoo of lazy functional languages sprouting forth from Landin's 1966 article "The Next 700 Programming Languages."
- kbp 9y ago
  What was radically different about C when it was released? It doesn't seem to stand out that much to me from the backdrop of BCPL, Algol, Bliss, Pascal, etc.
  - moomin 9y ago
    I’d say you’re right, it wasn’t that different. I think what made the difference for C was Unix (and a very good introductory book).

ngrilly 9y ago

I disagree. We don't have enough incremental improvements, because it's difficult to improve a language and migrate the existing code base at the same time. I'd be happy with a better C (for example get rid of header files and #include), a better Python (for example better parallelism without a GIL), a better Go (for example with a solution for generics and marginally less verbose error handling), a better JavaScript, etc. I'm mentioning "mainstream" languages on purpose.

sitharus 9y ago

The problem with incremental improvements is you have to keep backwards compatibility. This is a big issue when it comes to keywords. For instance this is valid C#: using async = Task<string>; class BadIdea { public async async async(async async) { } }

steveklabnik 9y ago
Rust has a fun similar one. I'm assuming for the same reason as C#: contextual keywords. union union<'union> { union: &'union union<'union>, } https://github.com/rust-lang/rust/blob/59675d29eb47eb743026dcc0737884f548f2197a/src/test/run-pass/weird-exprs.rs#L110-L112 https://github.com/rust-lang/rust/blob/59675d29eb47eb743026d...
- AndyKelley 9y ago
  please, I have to know, what is evil_lincoln testing?
  - steveklabnik 9y ago
    This is why I love this file. To understand what evil_lincoln is doing, you have to understand very old Rust. Here's the commit that introduced it: https://github.com/rust-lang/rust/commit/664b0ad3fcead4fe4d22c05065a82a338770c429 https://github.com/rust-lang/rust/commit/664b0ad3fcead4fe4d2... fn evil_lincoln() { let evil <- log "lincoln"; } log was a keyword to print stuff to the screen. Hence the joke, https://en.wikipedia.org/wiki/Lincoln_Logs https://en.wikipedia.org/wiki/Lincoln_Logs Now that log is the println! macro, the joke is lost. It doesn't say explicitly why this is "weird", but given some other comments in the file, // FIXME: Doesn't compile //let _x = log true == (ret 0); I am assuming that using the return value of log was buggy, and so this tested that you could save it in a variable. I don't remember the exact semantics of log, but if it's like println!, it returns (), which is useless, so binding it to a variable is something you'd never write in real code, so it's "weird" in that sense.
vram22 9y ago
Here is a similar one in Python (in the sense of using the same word or identifier multiple times): x = [[1,2], [3,4], [5,6]] [x for x in x for x in x] For more details see: https://jugad2.blogspot.in/2014/03/flatten-list-of-lists-with-list.html https://jugad2.blogspot.in/2014/03/flatten-list-of-lists-wit...
- earenndil 9y ago
  How about shell? function in() { echo $@; } for for in in; do in for; done
  - vram22 9y ago
    Ha, nice one, didn't know it could be done in shell too.

hota_mazi 9y ago

> This kind of incrementalism is not worth another persons years of effort to create a parallel path Historically, incrementalism is pretty much the only way that languages can reach mainstream status e.g. C/ObjC/Javascript/C++/Java/C#/Kotlin. Of course, having languages that break away from the mainstream is equally important to generate new avenues of research, but it's clear to me both approaches are a requirement for a healthy PLT field.

noxecanexx 9y ago

As far as I know, the only mainstream language to so what you are talking about is Eve. And I doubt it fits the use case he described in his intro.

hasenj 9y ago

The other language that does what Zig is trying to do is the Jai language that Jonathan Blow has been developing, but it's not open to the public yet. We don't need a radically different language, really. We just need a language that combines some of the best ideas that have been developing recently in a clean way while keeping the language simple, not complex. D was trying to do that but then it exploded and became a monster just like C++. It's kind of just a slightly cleaner C++, but it's still a monster.

curun1r 9y ago
Perhaps what we need is more tools for creating languages so that it doesn't take a massive engineering effort to create a new language and to enable language features to be implemented once rather than for each new language. That way, we could have a ton of languages and everyone can choose their own "Goldilocks" language. LLVM is a great effort in this direction and now language designers can target multiple architectures and get a ton of optimizations essentially for free. And it's great to see things like coroutines get added at that level. But more could be built at that level and on top of it to give higher-level language features in that same essentially free manner. It'd be cool to see stuff like borrow checking and garbage collection get added in a similarly reusable way. The end result of this would be that syntax, the stuff that's mostly easy and yet most prone to bike shedding and developer aesthetics, could be mostly decoupled from the serious work normally associated with creating a language and compiler. And developers with less expertise could build quality languages that appeal to an unmet syntactical aesthetic without having to reinvent as much of the wheel as is currently necessary. Instead of having one language that brings together the best ideas, we'd just make those best ideas reusable so that any language could easily bring them together using whatever syntax shakes out of the bike shedding process.
adamrezich 9y ago
Friendly reminder that jblow's language still isn't named, and "jai" is just the file extension currently being used.
- billytetrud 9y ago

jaredklewis 9y ago

What languages were “radically” different when they were relased? My take: COBOL, C, SmallTalk, lisp, ML, prolog, Shell. I’m might be missing some, but I think the pattern is clear. Only C remains among the most popular languages. Almost all widely used languages today (c++, php, ruby, java, python, javascript, etc...) are incremental improvements on old ideas. I think your opinion that the most used programming languages today are not “of any great value” to be bumpkis.

oblio 9y ago
I'd add SQL, Forth and Prolog. Haskell also, maybe?
- mbrock 9y ago
  Haskell was an "incremental" improvement on Miranda and a consolidation of features from a zoo of lazy functional languages sprouting forth from Landin's 1966 article "The Next 700 Programming Languages."
kbp 9y ago
What was radically different about C when it was released? It doesn't seem to stand out that much to me from the backdrop of BCPL, Algol, Bliss, Pascal, etc.
- moomin 9y ago
  I’d say you’re right, it wasn’t that different. I think what made the difference for C was Unix (and a very good introductory book).