Rust. It’s so good, it can’t be popular enough.
I wish it was more popular so more job offers would pop up :P
for real. I’m very lucky to have landed a job in it, but it’s a dry market for anyone looking if they don’t want to be doing crypto. Rust has made a big name for itself but still isn’t that popular where it matters.
I just wish it finally had “efficient inheritance”.
We want some way to have code sharing which is more efficient than traits (in terms of time and space) and more flexible than enums. Our primary use case is the Servo DOM, but we would like this to be more general purpose too. Our constraints are:
- cheap field access from internal methods;
- cheap dynamic dispatch of methods;
- cheap downcasting;
- thin pointers;
- sharing of fields and methods between definitions;
- safe, i.e., doesn’t require a bunch of transmutes or other unsafe code to be usable.
But that discussions seems to have died down and nobody’s working on it.
Not quite what you’re asking for, but I wish Erlang had gotten popular before Java took off. I think that could have massively changed the course of “mainstream” languages. Maybe the JVM itself would have been BEAM-inspired. Heck, in an ideal world, the Netscape corporation and Brendan Eich would have created something based on Erlang/BEAM to ship with Navigator, instead of inventing JavaScript.
in an ideal world, the Netscape corporation and Brendan Eich would have created something based on Erlang/BEAM to ship with Navigator, instead of inventing JavaScript.
I completely agree that in an ideal world JavaScript wouldn’t exist. 😀
BEAMScript!
elixer?
But in the browser. My complaint with JavaScript is that it was effectively the only choice for in-browser logic up until WebAssembly was stabilized, and even now it requires JS glue code.
This but elixir
It’s basically erlang but nice
Or Gleam!
I took a glance at it a while back, and it looks like Elixir + Go. Meh. Elixir could use gradual typing (and it’s coming along there), but turning to Go isn’t the answer.
Elixir is running on the BEAM. It wasn’t invented until 2012, though, so it couldn’t have become popular in time to influence the JVM or Netscape.
Yes, I’m aware, I’m more wishing it was elixir rather than saying it was actually possible.
deleted by creator
Oh, I’m sure someone is going to hate me for this, but I really liked Lua when I was making simple games in Love2D. I think it’s a shame how there’s basically no applications for Lua outside of game development and modding.
I don’t hate you, I just hate your one-indexed table-shaped horror language ;P
But actually would anyone really hate someone for liking Lua? I hope not. That’s weird, even as someone who finds the language kinda obnoxious. Maybe I’m reading too much into the “hate” part and it wasn’t meant so severely 😅
Well configuring NeoVim is basically game development / modding. But yeah it’s built as an embedded mostly single thread thing so. I also used it for AwesomeWM many years ago, whole thing was lua. I do think it’s one of the most elegant languages ever designed, with it’s very simple table/metatable mechanics
Presenting: an excerpt from my lua windows management script:
-- Exists because lua doesn't have a round function. WAT?! function round(num) return math.floor(num + 0.5) endYeah, not a fan.
Related: There is an article on LWN called Lua and Python, which is mostly about the approach of the two languages WRT being “batteries included” or not.
I think Lua being a bit barebones is 100% fine… if you just pair it with a good helper library, or set of libraries with a coherent API, that allows it to thrive. Then you can either use the framework library or not, depending on whether your project requires the extras, or can do without.
As a parallel, I’ve been doing C++ development for almost two decades, and I cannot imagine doing anything non-trivial without Qt. For example, Qt has a debug framework that pretty prints automatically most containers, and adds the newline also automatically. Also, QString is an actual string type, whereas std::string is more like QByteArray. It’s functionality that it’s essential for me (and it’s just the minimal examples… then Qt has all the GUI functionality, of course, but I use Qt even in console-only programs!).
This is surely opinionated on my side, and most C++ devs don’t see it this way, but my point is that a language with a “core experience” that it’s lackluster to you should not be a bad thing if the language is capable enough to provide an ecosystem with a good 3rd party library that adds exactly what you want. In the Lua ecosystem that maybe it’s Penlight.
But I totally get your point. Penlight doesn’t even seem to have a math library, so I found no round implementation there. This can be not a problem for some, but deal breaking for others.
I’ve been writing Lua off and on for probably close to a decade, and I can’t remember the lack of a
roundfunction being an issue. I may have needed it at some point, but it’s not exactly a complicated function to write up in a minute.To me, the biggest appeal of Lua is actually the lack of an overbearing standard library. It has just enough to be usable as a scripting language within a larger application, and the larger application can always include its own helper library that gets loaded into the interpreter automatically on initialization. Feature-wise, there is enough to define your own OOP helpers (but no language built-in specific OOP stuff beyond metatables basically), there is enough to build your own async/await and generators using coroutines, etc.
Not having a huge built-in standard lib comes with the benefit of not needing to distribute a huge standard lib with your larger application.
Lua is used as built-in language in more and more apps. I use it on a daily basis for configuring and extending neovim
lua is a really cute and surprisingly capable language! it’s how I got my start, and it’s one of the easiest languages I’ve ever played with. it would’ve been a good pick for web, I think. probably just needed to be fleshed out more.
I loved using PLUA on the Palm Pilot back in the day
dont forget scripting/configuring! i love lua despite its feature we dont mention
C#.
It’s a pleasure to work with, cross platform, superb documentation, great support and a robust ecosystem. The only complaint people ever seem to have is moaning about Microsoft.
Fucking Microsoft, with their fully featured toolsets, libraries for everything, fantastic IDE, second fantastic IDE, and cloud infrastructure that actually delivers on the promise of cloud, and isn’t just “bare metal bullshit in the sky”. Hate those fucking pricks.
Is VS for C# actually good or is it just that there are no alternatives?
Rider is an alternative that’s in my experience better
If you mean Visual Studio IDE (not VS Code), it’s actually the most robust fully featured IDE I’ve used. Using other IDEs, including other frameworks or languages, don’t come as close.
Easy management for external packages, easy build and project dependency mappings, easy unit test suites, etc. A lot of extensions work great out of the box (DB integrations, code coverage tools, security/vulnerability tools, benchmark testing, etc.).
Seeing as a lot of C#/.NET things are open source now, I wish that they would also work on an IDE for Mac and Linux. They’re about to retire the Mac preview VS, which didn’t compare to the Windows counterpart, but still usable.
Ye an closed source debuger and non free extension for vscode, that developer kit thing that is not free to use if more then 5 people
And PowerShell, as an addendum
I despise powershell. But I have no actual reason for that opinion. … I’m just familiar with Bash so anything else looks like too much effort.
Personally, I think, it’s dumb, because it’s more verbose than most programming languages. I’m normally even a fan of verbosity, but Powershell just feels like using big words when little words would do.
It’s weird to have something that verbose for using in the shell. I don’t want to use verbose commands when just doing stuff interactively, so I never learn how to really use its features as a concequence. Bash, while it has more footguns, is more readable to me because I’m more familiar with the individual commands. For most programing you spend more time reading it than writing it, but that’s not the case for the shell so there it’s the wrong tradeoff imo.
I’ve been a Java developer and even I find powershell obnoxiously verbose. Especially for a friggin shell.
Yeah, my word choice was quite deliberate there, because there’s this other full-fledged programming language, which is also often less verbose than PowerShell, called
Microsoft JavaC#.There is some nuances, which don’t make this quite as hard-cut, but in far too many cases, PowerShell is just an objectively worse choice than C#.
(And I’m not saying that C# is a particularly good choice, but since it can also make use of the .NET APIs, it is particularly easy to argue that it’s better than PowerShell.)
nushell feels like a pretty good in between of the two. I’m still going to use fish tho.
I found that the tradeoff came in the form of being more explicit, thus requiring fewer comments and less explicit readmes. Developers who normally struggled with naming things well would do better in PowerShell since it kinda “forced” them into the habit and structure. I know fans of Go (myself included) generally like that it takes that concept to the extreme. It fit my needs well at a time when I had a team of juniors to manage and teach.
Overall though, nothing wrong hating that strictness or verbosity! Lots of good options that support the reverse extreme and more moderate ones.
Not hating, but you should really try it out before forming an opinion. PowerShell Core is multi platform and if you value readable scripts at all, PowerShell is heads and shoulders over bash. I know all of us admins are proud of our bash scripts, but bash reads like hieroglyphics to anyone who didn’t write it. PowerShell has noun verb syntax and just heaps of syntax sugar. Scripts, even more than code imo, needs that readability for fast debugging and maintenance.
But hey, opinions on languages and such are highly, highly subjective. No skin off my nose if you just don’t like it at all.
You’re completely right. The deeper I get into bash the more absurd it is. Trying to iterate through text delimited by line breaks is ridiculously complex. And the sheer number of options for find and replace style operations is confusing sed, awk, printf, why?!
Oh and that’s somewhere where PowerShell really shines! Check out the examples on the docs page for some examples and see how easy they are to read and write compared to sed/awk/etc.
I also think PowerShell being object-based instead of string-based gives it flexibility for those of us who have experience with object-oriented programming languages. Being able to ship around objects to functions, splatting, etc are huge value adds for me personally.
Again though, sooooo subjective! Some people will legit hate that it’s object-based and hate the syntax. The world supports all kinds of developers and we’re all making cool stuff, so it’s all good!
PowerShell is heads and shoulders over bash
Sure… but that’s a low bar. Bash is basically the worst shell of them all (if you exclude the ones that are so bad nobody uses them).
I’m a fan of
fishpersonally. It’s both concise and feature rich. The fish language isn’t something I’d want to write a complex shell script in, but it’s a thousand times better than bash and if you’re writing something complex then I’d argue any scripting language is the wrong tool for the job. Including Power Shell. You should be using a proper programming language (such as C#).PowerShell is innovative, for sure. But string output/input shells scripting wasn’t broken (unless you use bash) and I’m convinced trying to fix it by replacing simple string input/output with objects was a mistake.
I love OOP. However I also love using existing tools that work well, and none of those tools are designed to be OOP.
You’re right that Bash is among the worst options available, but it is common and what our friend above indicated he had experience with. I think your points are all valid, but I also find that most professional situations don’t offer much choice in the matter anyway. I used PowerShell because it was my company’s standard and there were 10 years of technical debt built around it. I got to know its ins and outs because of that and find some of them neat.
I don’t think anyone should take any of my messages as saying PowerShell is best in class for any particular use cases, but I do enjoy using it. I’m all Python and Golang now anyway 🙃
PowerShell 5 and up use BASH aliases out of the box so your hate makes less sense nowadays.
Oh I don’t think I made it clear enough. I know full well my opinion has no merit. I legit know nothing about Powershell, other than it has a uniquely blue background.
Yeah, you do have to set the opt out of telemetry for the runtime as the default is opt in…
Is it really unreasonable to gain insight in to how their tooling is used? If it were being used to sell to advertisers I’d agree with you
I personally mind because its microsoft. I don’t like them nor do i trust them. There is stuff i use where i don’t mind the telemetry and i leave it on to help developers. But microsoft is not one of them.
A company that insists on putting “edge” back on my toolbar no matter how many times I remove it is not trustworthy enough to get telemetry.
I prefer opt in, but I guess that’s a dream.
Some info for others: https://learn.microsoft.com/en-us/dotnet/core/tools/telemetry.
Seems odd that ‘dotnet run’ will collect, but ‘dotnet app.dll’ will not.
C# is used by every medium to large French company as an alternative to C++. How is it not popular?
OP didn’t ask for unpopular languages but for languages you want to be more popular.
I also want C# to be more popular, it’s a fantastic language.
I pretty much only code to mod games, which is 90% C# for the things I’ve modded. Everything about the language, I learned from a Neverwinter Nights guidebook lol
Move to NZ. It’s nearly all c# here.
Plus it has a decent web framework in Blazor. I’m not a developer by trade, but I’ve enjoyed it in the context of small, personal projects.
Kotlin. I know it’s becoming the thing for Android but I’d love to see it more on desktop and servers. It’s a fantastic language.
The fact that Kotlin doesn’t have an official open source LSP in this day and age, in addition to related tooling, forcing you into a single not particularly open IDE ecosystem, and the fact that the developer company straight up said its purpose is to drive up Intellij sales, makes me very apprehensive about it… good syntax or otherwise. Even Java doesn’t come with as much of a vendor lock-in, and I woudn’t wanna touch that either.
All fair points. I feel like they’re stuck in the Sun / Microsoft trap of trying to monetize a language and it holds them/it back.
And to add - Java has zero vendor lock-in these days. OpenJDK is the reference implementation and is open/free.
Programming languages shouldn’t be monetised
Yea I wasn’t a fan of it initially coming from C++ and C# but it is growing on me. There’s a lot of neat concepts. I just wish it’d allow me to put curly braces on the next line.
Lisp
It solves so many problems new languages have been invented to try and solve, while being simultaneously simpler than most
I love lisp. Well, scheme and less so clojure. I don’t know why. Is it macros? Is it the simplicity? Or is it just nostalgia from learning it during a time in my life.
But I just can’t find a place for it in my life.
It’s not job material, effectively nobody uses it. It doesn’t solve basic problems with ease like Python does.
And because of this, anything I do in it is nothing more than a toy. As soon as i put it down, I have no hope of picking it up or maintaining it in 6,12,24 months later.
A toy I spend 2 weeks in absolute joy, but as soon as life gets in the way it is dead.
I understand the general job market, but what about lisp prevents you from pursuing personal ventures with it?
I’m old, I have other shit to do, and I don’t have the time. If I’m writing code, I’m doing it because there is a problem that needs a solution. Either solving someone else’s ‘problems’ for $$$, or an actual problem at home.
If it’s a short term problem like “reorganising some folders” I’m not going to (re)learn another language. I’m going to smash it out in 30mins with whatever will get the job done the quickest, then get back to doing something more important.
If it’s an ongoing problem, I’m going to solve it in the most sustainable way possible. I might fix the problem now but 100% someone’s going to drop support or change an API in 2 years time and it’ll break. Sure, doing it in Chicken would be fun. But the odds are, I won’t remember half the shit I learned 2 years later. It’ll be unmaintainable. A forever grind of learning, fixing, forgetting.
So without a commercial driver to actively invest in Lisps, there’s no point. It’s not profitable and It doesn’t solve any problems other tools can. Without the freedom youth brings, I don’t have the time to do it “for fun”.
I really enjoy writing clojure lately. the only thing that annoys me is the whole “hosted” thing where you either get a bunch of good clojure-native libraries or all the JS’s npm mess (other clojure hosts are very much non-existent).
Yeah Clojure is like the monkey’s paw of Lisp weenies. It adds many modern day niceties that are lacking in standard Scheme or Common Lisp, but also changes enough things to make it feel very un-lispy. I go back and forth as to whether or not I even consider it Lisp (Richard Stallman doesn’t).
But I do know that I’d rather write Clojure than any other non-lisp language.
I’d also recommend people try ABCL, which is Common Lisp on the JVM , or Parenscript which is Common Lisp that compiles to Javascript.
I dabbled with CLisp a while back, and I loved it – but I’m not sure what problems it solves. Do you mind expanding on that?
Common Lisp “solves” most language-level problems by providing metaprogramming capabilities via lisp-style macros. (Almost) any language feature you would want can be implemented with lisp macros, and many such features already have been. So you don’t have to worry whether or not lisp has “for i in…” loops, or pattern matching, or generics, or virtually anything else, because if it doesn’t, you can write it! Plus if it’s really a good feature somebody has probably already made a library for it (if it’s not already part of the standard).
One of the most extensive examples of this is Coalton, which is an ML-style statically typed EDSL for Common Lisp.
There are metaprogramming features in a few other languages: template haskell, C pre-processors, even macros in Rust or Julia. But these all fall very short of lisp-style macros because those languages are not (truly) homoiconic, which makes the macros awkward to write and integrate into the language. This kind of metaprogramming is rarely employed, and when it is only for heavy duty tasks, and even then is generally discouraged as a last resort/special circumstance. But lisp macros are very easy to write because it’s the same as writing any other piece of lisp code. This results in macros being used often for smaller lightweight abstractions in the same way you write a small function.
The other big pro of lisp is image based development. But that’s not so much solving a problem in other languages as it is simply a feature that they don’t (and pretty much can’t) have.
And all of this is done in a language with less syntactic and semantic primitives than almost any other language, including the other “simple” ones like Python, Ruby, Elixir, etc.
I wish popularity wasn’t a factor when considering which language to use for a project. Just pick the language best suited for the job!
This is obviously unrealistic. Choosing a largely unknown language is a bad idea because it makes recruitment unnecessarily difficult - even if it’s the best language in the world for this particular task.
But imagine a world where we’re not stuck with Java, C++ and Python as the only viable options.
I wish popularity wasn’t a factor when considering which language to use for a project. Just pick the language best suited for the job!
“Best suited” doesn’t exist. There are several languages that are all capable of doing any job you want.
Popularity means you’ll have an easier time finding people who already know it. And that there will be tools and library support. You don’t want to spend 1.2 million on a s project to find out that your language or major libraries are no longer supported…
vietnamese
Ah I am not familiar with this language.
Is there iced coffee and noodle soup?
No one has said Ocaml yet, so I will. It’s not a perfect language, but it has a lot of cool ideas and concepts. It’s a functional language, but allows you to write imperative code when you want to. Algebraic data types and type matching are built natively into the language and work very nicely. It’s type inference capabilities are very powerful (though that can backfire at times), and the
|>operator is really, really fun to use. It also has very powerful module/functor capabilities, though they go a bit over my head since I haven’t had a chance to play with them. Also, Opam is a very powerful package manager and it’s pretty easy to wrap/bind external libraries with it.I’d love to see some improvements to the language - the syntax is a bit confusing and ugly at times (but this unfortunately can’t be fixed without breaking the language of course) - but overall I think I’d have a lot more fun programming in Ocaml than what I do in my day job.
I’ve been working on some OCaml code recently. It’s a quite elegant language but it has two or three big flaws that really make me not want to write it.
-
OPAM is buggy as hell. There’s one piece of OCaml software that we use at work and literally everyone that tried to build it had problems due to OPAM. One was that it couldn’t find
zipif you are in more than 32 groups!? I don’t even want to think about the kind of code that could lead to that bug. And this is on Linux! Have you tried installing OCaml on Windows? Yeesh. -
Global type inference means loads of types are inferred as generics, which means you give up a lot of the utility of static typing. Yes you can add explicit types, but the code I’m working on doesn’t have them. Rust was 100% right to require explicit types on functions.
-
The syntax is pretty awful in my opinion. Yeah I guess it looks elegant and I’m sure whoever came up with it was very proud, but honestly maybe 40% of my time fighting OCaml has been spent figuring out where to place the damn brackets and semicolons. It’s extremely unforgiving too. E.g. if you put an extra semicolon on a top level
letwhere you weren’t meant to it can sometimes be “valid” but it pulls the rest of the file into an inner scope, which means the compiler gives you a valid but wrong fix suggestion. Languages using curly brackets don’t have this issue at all.
The lack of brackets for function calls can also make it difficult to work out what’s going on because you have another operator precedence to remember. Have trouble remembering which is higher precedence out of
&and==? Well now we’ve thrown calling functions into the mix for you to forget too!Finally the functional focus can lead to mega-expressions that are very hard to follow, especially when combined with the lack of brackets it can end up looking like word soup.
OCaml has a ton of really nice ideas but I’m glad it’s just inspiration for better languages (e.g. Rust) rather than actually popular. I mean… it’s still a million miles better than Python… But that’s a low bar.
Agreed on all points. I think some of the issues that you’re facing are things that would be resolved if Ocaml were more popular. But some others would be harder to fix without making breaking changes to the language as I mentioned earlier. If I had to put it as succinctly as possible, I’d say that the language just needs a lot more polish which would probably happen if it were more mainstream. But not all languages have to be mainstream, and maybe Ocaml’s purpose in the world is, as you put it, to inspire other languages. It is definitely extremely good at that!
How the heck did you trace the problem down to the amount of groups the user was in?
Luckily I didn’t have to - I found a Github issue where someone else had. Don’t ask me how they figured it out!
Holy cow, lucky you! o.O
-
I got into ocaml recently. I love it. I honestly don’t see issues with the syntax, maybe because I haven’t used it enough.
Rust, so we could have a lemmy fork 🤡
Why is this downvoted? Forks are good, it shouldn’t even be a joke. As long as we keep network compatibility I’m all for it
Thank you for your reply and Beehaw for not having downvotes!
Shout-out to the Flutter-Dart stack that Google made. Neither are outstanding, but Flutter compiles to native code for every platform including mobile and web. This is way more convenient than React Native (which funny enough doesn’t really work on web). Dart is a much saner lang than JS and the UI framework is much saner than React. Dependency management is fast and easy without NPM and webpack trash. So for my recent project I embedded a flutter app inside a static website, and can also have it run native on desktop or wherever. The only real downsides are an extra 1.5mb load for the dart runtime stuff, and some need to fiddle with platform specific issues and configs. Upside is I need neither xcode nor node
Last I checked flutter struggled with SEO, how’s that looking now?
I’ve been really impressed by Dart as a programming language. I’ll admit I don’t have a breadth of knowledge, but coming from C# I feel right at home, and it has a few extra neat tricks that C# is picking up in return (like empty list syntax and the spread operator).
Haskell
Not really a language you would write in but WebAssembly. I have this dream of a single WASM runtime environment across web, desktop, mobile with devs writing apps once, compiling them down to WASM, distributing them over the Internet, and users running them on any platform they like.
A lot of new languages are going to support WASM now that garbage collection has been implemented into the language (Go, Python, Java possibly). Now if we could get the JS runtine to just use UTF-8 instead of the shitty archaec bad UTF-16, there would just be no reason to not use WASM
AKA Java
I wouldn’t trust the Java app sanbox at all. They basicslly abandoned it.
deleted by creator
I think you just described Blazor WebAssembly
Blazor and webassembly are different things. Webassembly is a runtime, blazor is a framework built for webassembly. They do not compare
Blazor WebAssembly ticks the boxes that @treechicken@lemmy.world described.
I have this dream of a single WASM runtime environment across web, desktop, mobile with devs writing apps once, compiling them down to WASM, distributing them over the Internet, and users running them on any platform they like.
You write the app once and it can be compiled to WebAssembly that works across web, desktop, and mobile.
In reality to take full advantage of Blazor you’re probably going to use Blazor Server/hybrid for desktop and mobile but the principle is the same, you’ve only written your app once but it works in every environment.
That only works with c# though. What they are suggesting is compiling any arbitrary language to wasm and run that anywhere. Which is technically already possible with WASI and any of its supported runtime.
Netscape should’ve stuck with their initial plan of putting Scheme or Python in the browser instead of hiring a dipshit to half-ass a shitty Java-coattail-riding monstrosity.
What? That’s not what happened at all.
JavaScript was built entirely by Netscape from the ground up with no external involvement, and that was totally their “initial plan”. It shipped in testing (under the name “LiveScript”) within months of Netscape 1.0.
And then Sun Microsystems paid Netscape a lot of money to rename it to JavaScript and pretend it was related to Java, even though it had nothing at all to do with Java.
From https://webdevelopmenthistory.com/1995-the-birth-of-javascript/ :
However, Eich didn’t think he’d have to write a new language from scratch. There were existing options available — such as the research language, Scheme, or a Unix-based language like Perl or Python. So when he joined, Eich “was expecting to implement Scheme in the browser.” But the increasingly fractious politics of the software companies of the day (it was, basically, everyone against Microsoft) soon saw the project take a more creative turn.
On 23 May 1995, Sun Microsystems launched a new programming language into the world: Java. As part of the launch, Netscape announced that it would license Java for use in the browser. This was all well and good, but Java didn’t really fit the bill for the web. Java is a general-purpose programming language that promised Write Once, Run Anywhere (WORA) functionality, but it was too complicated for web designers and other non-programmers to use. So Netscape decided it needed a scripting language, which was a trendy term at the time for a smaller, easier to learn programming language.
Netscape’s relationship with Sun soon influenced the scope for Brendan Eich’s project. The language he’d be developing now wouldn’t be based on Scheme; instead it would have to be somehow connected to Java. The idea was to have JavaScript and Java be the programming equivalent of Microsoft’s Visual BASIC (the easy one) and Visual C++ (the hard one).
The decision was made that JavaScript — or “Mocha” as it was originally code-named within Netscape — would “look like Java,” but be an object-based language rather than class-based like Java. Eich recalled later that “I was under marketing orders to make it look like Java but not make it too big for its britches … [it] needed to be a silly little brother language.”
QQ: What’s the difference between a “class-based language” and an “object -based language”?
In a class-based language, you declare the specification for a class and then (separately) instantiate members of it. You can also do inheritance and such.
In an object-based language, you instantiate an object by explicitly declaring and setting the values of all the properties inside and then its type is defined to be itself. You can then make more objects of the same type by instantiating them and passing in the first object as the prototype to use.
It’s weird that you are aware of this but still decided to prsent it as “hiring a dipshit to make a shitty java clone”. It pretty clearly says that Eich wasn’t the one that wanted to make it java-like.
I didn’t call it a “shitty java clone;” I called it a “shitty Java-coattail-riding monstrosity.” There’s a difference.
Specifically, I was referring to how the only reason it was created – the only reason using an existing language wasn’t good enough – was to capitalize on Java’s hype, not claiming that there was any sort of meaningful technical resemblance (because aside from both having vaguely Algol-style syntax, there isn’t).
Holy shit we almost had Python in our browsers instead of JavaScript‽ Please can I switch timelines!
Oh man, you would have loved a project I was working on ~15 years ago.
Clojure. Although it’s currently the most popular lisp but the ecosystem is not super lively and sometimes you need to rely on Java interop. This also severely limits the platform flexibility, if more things were written in pure Clojure or targeting BEAM or CLR it’d be nice. But luckily at least unless a library you use doesn’t rely on Java interop, the language is designed in a way that really reduces the bit rot.
Fun thing about it is that despite the S-expressions which you love to appreciate - I mean, it usually looks better than
})at the end of aPromise/ closure in js or super deep nesting which you’d easily resolve using a thread last macro in Clojure. Therefore I’m also really excited that the pipe operator is finally coming to JS soon. Just add colored delimiters to your IDE. The virtual lack of syntax makes it quite easy to pick up.With lisp semantics and minimal syntax that resemble the lambda calculus very closely, dynamic typing is rarely an issue (you can still specify types optionally), not to mention that pure functions are super easy to reliably test. Also, many things like DOM, nested data structures, b-trees (to a degree) or ASTs are actually structured like an S-expression tree, making Clojure good for such applications. All of this allows for clean code that does not feel like an assortment of free functions but is usually very loosely coupled yet everything seems to fit really neatly together like a coherent tree.
In general LISPs, as the name implies, are a superb tool for studying algorithms and DS in a way that allows you to focus on the problem itself more than the implementation, unlike in imperative languages where going into every little step in what feels like almost operating at individual CPU instructions at times can feel overwhelming and confuse the hell out of you.Realizing the open-closed principle with Clojure comes pretty naturally since you’d more likely use function composition or write new transformations than modify the existing functionality.
Since functions are the primary unit of abstraction, dependency inversion is also trivial to adhere to.
Also protocols, which are somewhat more powerful than interfaces in some OO languages. They offer multi-method dynamic dispatch, retroactive polymorphism (extending types defined outside the current codebase), are independent from class hierarchy and are generally somewhat more succinct as virtually everything in that language.First-class support for STM and immutability also make it good for concurrency like most functional PLs and make it a bit more intuitive than the actor model of Elixir/Akka.
Some Clojure frameworks do as well in certain benchmarks as those written in Rust.
Also compared to some other lisp dialects, the “primary” data structure is not a singly-linked list.It’s goto data representation format, EDN is also a really nice thing.
And you have a REPL and get to choose what should be compiled AOT and what JIT. It’s most popular build tool, Leiningen is quite neat and in my experience has been a little bit faster in terms of dependency retrieval than Mix used by Elixir.It can also transpile to js or dart. It generally is a quite flexible and extensible language where the said extensibility does not really make you feel the levels of inconsistency comparable only with PHP a couple years ago before they’ve decided to get it’s shit together as much as possible as can be the case with Haskell codebases that rely on a large number of language extensions.
And lastly, first-class documentation support but that should be a standard (looking at you JS and everything that still uses Doxygen)
Tbh Clojure’s greatest Achilles’ foot is the baggage of JVM with it’s lengthy stack traces, startup time, lack of tail call optimization, different paradigm and backwards compatibility issues. So if the question was which runtime you wish was more popular, I’d pick BEAM. But in it’s current state, whilst BEAM is more suited for functional programming, Clojerl doesn’t allow you to do much more than the standard library since many libraries wrap java, like web frameworks for example.
But on the other hand, JVM integration might make it easier for teams using Java or Scala to adopt Clojure.Also it might not do the best job of handling bugs gracefully. This is good in the sense of giving you those almost Rust-like levels of strictness but without the lengthy compilation time but if you are looking for a way to move fast and tolerate some breakage, Elixir could be a better pick.
Also currying is not automatic and you have to usepartialor macros.
But speaking of macros, they are almost as neat as in Rust and much more intuitive than in C or Scala.You know, Java interop is actually a good thing.
I’ve used a few dozen languages, and noticed that most modern languages lack libraries. Coming from Python and C++ I often feel it that way. Use whatever niche language and I’ll hit the lack of power options like Python’s pandas, databases, GUIs, etc.
Clojure’s a powerful language, but with the size if its community there’s no hope of getting many alternatives on doing SQLs, for example. But, Java interop assures me I can just keep going with clojure, because I can almost always work around library issues with Java. It doesn’t even matter if I’m on a mac or ARM or 64bit (looking at you, C#).
I mean, libraries access is good. But lack of tail call optimization support is not something you’d want in a functional programming language runtime. Luckily here Clojure somehow manages to fare better than Scala.
