chapotraphouse @hexbear.net aldalire @lemmy.dbzer0.com 3 mo. ago

When the revolution comes we need to unify the programming languages

Seriously. There’s so many floating around. It feels like there’s a cycle of

Random programmer thinks xyz language sucks -> she/he makes a slightly different, slightly faster, slightly more secure version -> by luck this gains mass adoption-> random programmer thinks new xyz language sucks

I propose when the revolution comes and the last guillotine falls we decide a general-purpose programming language that coders should stick to. I vote Lisp or any of the dialects (scheme, clojure, racket), but i also feel something about the Julia language for scientific research. Maybe we can decriminalize using C. Absolutely ban and hunt down the use of any of the hipster languages teenagers are into these days.

Nim? Zig? Crystal?? I am absolutely losing my damn mind. It compiles to bytecode people. Make up ur damn minds. To jail with all of u

76 comments

After the revolution we should unify fasteners. There's just too many. Nails? Screws? Glue? Velcro? It's all an illusion of choice because they do the same thing anyways. We'll need to pick one, and I'm thinking staples.
- Epoxy is peak, time to split the political party again
When the revolution comes we need to unify tools

Hammer? Screwdriver? Spanner? One of these should be enough
- Single handle with interchangeable heads.
- EXACTLY
All these cutting edge new languages are just wrappers around the same C libraries some anonymous grad students wrote in the 70s funded by some tiny government grants.
- "You could not live with your own failure. Where did that bring you? Back to C."
- All these cutting edge new languages are just wrappers around the same assembly code by Kathleen Booth in the 1940s for her university computer.
  
  I don't see all my programs linking against that
- Programming languages and operating systems are really best developed together tbh
  
  Otherwise you end up building an new, extremely unimaginative operating system into your programming language that is usually permanently linked with the operating system you developed it with anyway
part of project 2025 is making javascript the only programming language
- Never thought I'd say this, but we gotta vote Biden.
Rust
Wish granted, Brainfuck
- Understandable implementation of turing's own programming language >_<
Can we ban all tools that aren't hammers while we are here?
After the revolution we should just unify english. Theres so many spoken languages around.
- Hearies when there's more than one sign language type beat
- Lojban. We make Lojban the international language.
  
  Toki pona
Language design and theory has made some legitimate gains over the past couple decades. And different languages have different strengths suited for different problems. I think the issue is that even people who agree with this aren’t gonna agree on the language to standardize on. It’s the XKCD comic.
there are 28 coding languages

"We need to invent a universal language that brings all these together so everybody can just use one"

there are 29 coding languages
- There's a lot of languages but people usually have a favorite that probably isn't very unique lol
  
  There's no such thing as a universal language but we can build better languages (and operating systems) that dominate
  
  There are THAT many people coding in assembly? There's no way. I refuse to believe it.
  
  I like visual basic. It was really easy to learn for loops with
- Not saying we invent one. I'm saying we choose one and proclaim it as the One True Language
And then we can use our unified programming language to write a program so tall it breaches Heaven itself
- I swear my personal conspiracy theory is that corporations like to introduce flashy new programming languages to divide programmers so they don't get too powerful for their own britches and rise up against the executives that control them.
  
  Imagine if there was a single, unified programming language, used both in industry, research and for hobbyists. Then we can standardize all of tech
Yeah I program in WebAssembly, what about it?
- At least we recognize that programming in sex pressions is the right way to go
learn more languages - it makes the code you write more effective on the human level. like learning Haskell taught me how to conceive of ideas that you would just solve by duplicating code or building a shitty interface that falls apart when you need to combine it with anything else. code is math and code is a means by which you communicate with other people. and you need to learn to express yourself in more ways in order to come to a deeper understanding of both of those facets.

I don't want fewer languages. I want more diversity and more experimentation. I'd love to see more domain-specialized languages that borrow ideas from the more academic languages and refine them. look at Elm and how much ground it broke - so much so that it's impacted how new javascript UI frameworks are designed. but Elm couldn't exist without languages like Haskell and Ocaml. and those couldn't exist without ML, Miranda, etc, etc.

putting limits on human creativity defeats the entire purpose of the left. we dream of being unshackled, of the genuine freedom that can only come from the defeat of capitalism and the dawn of a new, socialist political economy. perhaps if one day I write a better Lean, it will inspire someone to write a web language that brings proofs into the developers' lexicon and we will all have less shitty, poorly conceived, brittle code to maintain. and maybe you'll inspire me with a great idea of your own.
- Preach daddy but i gotta say u write lean? 👀
I like Guile with its compiler tower. You can use multiple languages on the same VM, even using libraries from one language on another, which is fucking cool. The core language for Guile is Scheme, and it supports standards from R4RS-R7RS, along with plenty of built-in SRFIs, some implemented out-of-tree and many of its own Guile-specific extensions.

For the compiler tower, so far we've got the aforementioned ballin' Scheme implementation, Emacs Lisp, an unfinished JavaScript implementation that doesn't even fully implement ES3, Brainfuck, Python, wonky Lua, and Guile-specific Clojure. Hopefully there's more to come and there's some I missed.

While the main purpose for the compiler tower is to lower a language into the IR (Tree-IL) (although you can lower a language into another language too, which then itself can be lowered into IR), which gets lowered to more verbose IR (CPS), then bytecode - we can also raise IR through decompilation. For example, Guile-JavaScript compiles Scheme to IR, then decompiles the IR and raises it to JavaScript.

Then there's also Guile Hoot, which I believe lowers the IR into WASM. In theory, when its complete, the above languages could work with Hoot and he compiled to Hoot, but I'm not entirely sure on this.
- compiler tower
  
  Could I get a ELI5?
  
  I googled but doing that made me more confused.
  
  https://www.gnu.org/software/guile/manual/html_node/Compiler-Tower.html
  
  Guile’s compiler is quite simple – its compilers, to put it more accurately. Guile defines a tower of languages, starting at Scheme and progressively simplifying down to languages that resemble the VM instruction set (see Instruction Set).
  
  Each language knows how to compile to the next, so each step is simple and understandable. Furthermore, this set of languages is not hardcoded into Guile, so it is possible for the user to add new high-level languages, new passes, or even different compilation targets.
  
  Let's use the tower metaphor for a moment. Consider Scheme:
  
  Scheme | | v Tree Intermediate Language (Tree-IL) | | v Continuation-Passing Style (CPS) | | v Bytecode
  
  To compile Scheme to Bytecode, it's lowered through different stages until it's Bytecode.
  
  We can also decompile, and raise code instead of lowering it - for example, here's how Guile-JavaScript works, which compiles Scheme to JavaScript, by first lowering Scheme to Tree-IL, then raising that Tree-IL to JavaScript through decompilation.
  
  Scheme JavaScript | ^ | | v | Tree Intermediate Language (Tree-IL)
  
  We take code through the tower to transform it into its desired form.
  
  Hope this made sense. Or maybe it confused you even more =).
- For example, Guile-JavaScript compiles Scheme to IR, then decompiles the IR and raises it to JavaScript.
  
  Guile it is then. Also, that's pretty cool. You're saying Guile can compile scheme into javascript? I've been looking at clojurescript for this exact same purpose actually
  
  Yes. It can. But I believe some other Schemes can actually do this better, and the Scheme->JavaScript implementation for Guile is beyond, beyond unfinished.
  
  You'll proboably have a better time with Guile Hoot, which compiles Scheme to WASM. It's also unfinished, but it's much more complete and currently making a lot of progress. It's meant to allow Goblins, an actor-based decentralized framework by the same people that made ActivityPub (Spritely Institute), to run on the web.
  
  Also Guile's lead developer, and Hoot's project lead, Andy Wingo, may or may not be a Marxist - reading his blog, and watching some of his talks, I've noticed some references to Hegel and Lenin, but I'm not quite sure on this. He's also called out sexism at various developer conferences he's been to, from GNU Hackers' meetings to FOSDEM.
  
  Did I mention Guile is a GNU Project?
- Guile is the configuration language for Guix right? I didn't know it was used outside that purpose, that's pretty cool
  
  "configuration language" is a bit of an understatement, as most of Guix itself is written in Guile, along with the PID 1, called Shepherd. Guile is literally the first thing the kernel starts on Guix.
Rust
Yeah literally mostly all I want is a better C with less weird quirks and undefined behavior, may as well drop null-terminated strings except for compatibility too, maybe some kind of memory-safety mechanism too, ooh also better support for multi-dimensional arrays

Rust was kinda like that until it became the better C++

Maybe in 10 years someone will be designing a better Rust because they made the same mistakes of C++ and forced so much shit into it it's extremely difficult to write any new, better implementations and port to new systems
- If you like this idea I've been watching this project closely and you might want to too:
  
  https://harelang.org/
- Yeah literally mostly all I want is a better C with less weird quirks and undefined behavior, may as well drop null-terminated strings except for compatibility too, maybe some kind of memory-safety mechanism too, ooh also better support for multi-dimensional arrays
  
  I think maybe Zig fits the bill here? It doesn't seem to have anywhere near the memory safety that Rust has tho.
  
  Ooh I've heard of this but at some point years ago I decided it wasn't for me for some reason... I'm gonna give it another look though, thank you
  
  It doesn't seem to have anywhere near the memory safety that Rust has tho.
  
  I don't mind tbh, Rust has a ridiculously elaborate but effective compile-time static analyzer that has developed over years and years. Pretty difficult to replicate lol
  
  Edit: I just realized the OP listed Zig as a hipster language teenagers are into
- Zig and Hare are both vying for the better-C category these days.
Terrible take tbh

You can pry Julia out of my cold dead hands but if you make me work with other people in it I'll start sobbing
Banning programming languages seems like a bad idea to me, humanity has come to regret all that language standardization and cultural genocide that happened with the imposition of one universal linguistic language. My official (so the communist position) on programming languages is let a thousand alternates to C+ bloom, then crush them all under the jackboot of the communist party. THEY WILL ALL BE THE LANGUAGE OF COMMUNISM!
In my communist future it's all Torqur3D, Python, and BASIC. No, I do not know any of those.
I'm only familiar with Python...
- Python will be outlawed unfortunately.
  
  Nao
such decisions will be made scientifically, without the liberal farce of the voting ritual.

it's javascript
Scheme , BQN and SED used to make a really nice OCaML p compiler
Unless you are writing a hard-realtume system, Common Lisp is the only language you will ever need.
- Be quiet parentheses diddler, (((((()((((((())((do-thing (())(())))))0((( who the fuck wants to look at that all day.
  
  But seriously tho how do you get used to the syntax? I've read some moderately complex Lisp code and it was very hard to read for me, do you just kinda get used to it over time or is there extra tooling involved?
  
  OK fair point actually. You just gotta write some lisp code yourself (I'm a fairly new lisper although I had emacs for a while now and have dabbled in some elisp to edit my config) to appreciate how the parentheses are actually helpful when you write things. To read things, well-written lisp code will be properly indented, or else a reasonably powerful editor (emacs with sly, etc) is able to indent the code for you
  
  Take a look at my (shameless plug) eratosthenes sieve function i wrote just yesterday
  
  (defun range (start end) (if (< start end) (cons start (range (1+ start) end)))) ;; Checks if d is a factor of n (defun factorofp (d n) (zerop (rem n d))) ;; Sieve in lisp?? (defun sieve (n) (let ((primes (range 2 n)) (curprime 2)) (maplist (lambda (tail) (delete-if (lambda (n) (factorofp curprime n)) (cdr tail)) (setf curprime (cadr tail))) primes) primes))
  
  u don't have to understand it. But the general principle is, things that are indented at the same level are arguments to the same function. In other words, notice that the delete-if and the setf are indented together. So they must be part of the same "argument:" namely, the body of the anonymous function lambda. So really, you don't have to count the parentheses or anything. The indentation makes things clear and unambiguous.
  
  Other things that aid in reading are, obviously, patterns that you pick up along the way. Do not fear the parentheses. Embrace them
- Never been a Lisp person but
  
  Looking into this

You've viewed 76 comments.