Why are there so many programming languages? And why are there still being so many made? I would think you would try to perfect what you have instead of making new ones all the time. I understand you need new languages sometimes like quantumcomputing or some newer tech like that. But for pc you would think there would be some kind of universal language. I’m learning java btw. I like programming languages. But was just wondering.
You must log in or register to comment.
you would think there would be some kind of universal language
There is an xkcd for everything
You got to it before I did. Programming languages are like vehicles. You wouldn’t take a sports car off-roading, and you wouldn’t expect a tractor to win a drag race. There is a lot you can do with an all-purpose vehicle, but it’s not going to be as good as something that is purpose-built for a single task.
I actually don’t think that’s the case for languages. Most languages start out from a desire to do some specific thing better than other languages rather than do everything.
deleted by creator
If there was a single language, afterwards the same broken logic would be applied to frameworks and libraries, and we all know how many people bitch and whine over Java and it’s extensive standard library.
JavaScript (is the universal language) (is also the answer of why there are so many languages)
Why invent the screwdriver if you have a hammer
What kind of screwdriver though? Torx are superior.
Robertson would like a word.
No doubt they are probably better overall, especially when considering manufacturing. But I swear parts of my house where built with scraps (or the last guy was just a sociopath) and most of the time I encounter them it’s in some rare ass instance and it just pisses me off.
Last time was when servicing my AC I noticed the breaker was bad (ie wouldn’t reset ). So I had to swap it and by code I needed to swap the box it ran on since it was showing signs. Sure enough 1 of 4 screws holding it to the side of the house is a fuckin Robertson head. So I was neck deep in fixing shit and had to stop and go find my random cup of bit heads out in the shop.
Now I just carry a bit if I can remember it. But it’s hard to find screws sometimes so I just don’t use it to avoid exacerbating my own problems.
deleted by creator
In a lot of cases it feels a lot more like my mother in law buying me a new multi-tool every Christmas
Damn…
You can’t easily improve a language and stay compatible with the previous versions. C++ does it but they are crazy.
you would think there would be some kind of universal language
It does not exist, but anyone is free to try and invent it. It should be low-level like assembly and high-level like BASIC, functional, object-oriented, and have weird stuff like traits, concepts, and alien features from Haskell. It must also have both the pointers/references of C++, and the borrow checker of Rust. And don’t forget to make it as secure as Ada with pre and post conditions. But it must still be easy to use. Also you will have to write a compiler for every operating system ever (mainframe, server, desktop, iOS, Android, every phone, every tablet), and contain a universal GUI that pleases everyone. It’s literally impossible to do right now.
Such an abomination could be created. Just imagine all the over engineering that would be required.
It would run ANYTHING on ANY platform by incorporating every libc and assembler and VM and dynamic interpreter.
It runs on EVERY platform and thus it can be adequately tested on NO platform.
Also, by the time you’ve gotten it to compile, another two versions have come out.
There are no stable releases, just a continual rolling build from the single bespoke server farm that can create releases
I’d call it Paradox Lang, or PL for short. It even has features that are contradictory to each other, you just have to declare which mode you want at the top of every file. Can you imagine. :)
The only feature it doesn’t have is “lightweight and minimal language”.
It should be low-level like assembly and high-level like BASIC, functional, object-oriented, and have weird stuff like traits, concepts, and alien features from Haskell. It must also have both the pointers/references of C++, and the borrow checker of Rust.
Hang on a minute. Isn’t that literally just
RustCrabLang?Rust still lacks OOP (the inheritance/subtyping part of it) though. And some more advanced Haskell features too, like HKT.
I’ll take your word for it about the missing Haskell features, but with regards to inheritance, they deliberate chose to avoid it. They use an alternative model to achieve the same goals inheritance is meant for, but without the issues that come along with it. Their approach is basically a more advanced version of how Go uses interfaces to define shared behaviour.
Ooh rust just became more appealing to me.
It is pretty neat. They’ve made a lot of really interesting design decisions that make for a pretty unique language.
One of its main selling points is how it guarantees memory safety without using a garbage collector. That, plus the fact that it does a shit-ton of compile-time optimizations, actually makes it pretty fast. Like, 80%-90% as fast as C (which is much faster than all the other high-level languages like Java, Go, etc, partly because they do in fact use garbage collectors).
If you want to check it out, I recommend this playlist as a solid intro.
Here is an alternative Piped link(s): https://piped.video/playlist?list=PLai5B987bZ9CoVR-QEIN9foz4QCJ0H2Y8
Piped is a privacy-respecting open-source alternative frontend to YouTube.
I’m open-source, check me out at GitHub.
Oh yeah, I get all of those, because I am a Rust programmer myself who hates OOP. :D
I raised the topic up only because of how people were talking about “the ultimate language with everything”.
Sometimes it’s easier to try a new idea in a new language (e.g. the borrow checker in Rust) rather than trying to shoehorn it into an existing language.
Rust’s borrow checker is a bad example. There are already a few projects that target C++ and support both runtime and compile-time checks, not to mention static code analysis tools that can be added to any project.
Uh, they’re different, though. There is no C++ tool (AFAIK) providing an exhaustive check of ALL the data lifetimes. I even think it’s impossible, because their semantics are really different. Rust is move by default, C++ copy by default; Rust has no inheritance with its constructors, etc.
There is no C++ tool (AFAIK) providing an exhaustive check of ALL the data lifetimes.
Your reply reads like an attempt at moving the goal post.
The initial point was “Sometimes it’s easier to try a new idea in a new language (e.g. the borrow checker in Rust) rather than trying to shoehorn it into an existing language”, to which I pointed the fact that yes it’s indeed possible to “try a new idea” like borrow checking, and it only takes adding a tool that runs in a post-build/unit test step. It’s simpler, easier, and does not force anyone to rewrite projects from scratch.
Claiming “oh but it might not work as well” is not an answer or a refuttal.
Long has man wanted to experiment with as many partners as he can.
Some people consider working on programming languages fun, so they create new ones.
Different programming languages have different types of strengths. C is good for bare-metal performance and hardware interactions, Python is good at versatile interactions with all kinds of software and systems, Node.JS is good for asynchronous operations, and so on. Some esoteric languages aim to make things easy (or make them possible in the first place), or make things faster, or more secure, or etc. The things you can write in one language don’t always translate to another, and sometimes people create a new language that makes things possible that didn’t used to be possible. Machine learning wouldn’t be where it is if everyone who’s currently using Pytorch was still using C and doing all their own memory management. I’m currently working on a project in Node that would be much more difficult in Java, because Node’s approach to asynchronous operations matches this problem way better than do the primitives that Java’s runtime makes available. And so on.
Is any given language that gets created going to be the next Python? Probably not. But everyone who makes one has some kind of idea that there’s something unique and wonderful within it, and you can’t tell if they’re right unless you let it happen and see how it plays out.
Edit: Okay lemme clarify: Node.JS is good for a particular type of (generally I/O bound) asynchronous operations. It makes simple things easy and fast, at the cost of making some complex things pretty much impossible, so there are a bunch of problems it’s not good for. Better with the caveat maybe?
If you have time (and the inclination!), would you mind explaining why Java’s primitives aren’t as good as Node visa vie Async ops?
It’s not a matter of better or worse (in this particular case – there is such a thing as languages that are just plain bad). In my opinion, it’s just what you’re trying to do:
So Node uses a multiprocessing model where your program won’t be interrupted in unpredictable spots – there are very specific places where a function might pause waiting for something to happen, and give way to another function, but during ordinary (“synchronous”) operations you can be guaranteed that the program won’t be interrupted. That makes things hugely simpler because in general, you don’t have to mutex-protect your data structures, you don’t have as many weird subtle bugs that only crop up during certain thread interactions that are extremely difficult to debug. That’s the upside. The main downside is that because it’s a single-threaded model, which means (a) you can’t easily scale up your program to multiple CPUs and (b) if you have a long CPU-bound operation, it’ll happily block the whole rest of your program from executing no matter how many problems that causes. It’s excellent for network-I/O-bound workloads, because you’re probably not heavy on computation and it’s simpler to program and more robust than using multithreading in that case. Although, you do have to learn some new primitives and make sure to be careful with CPU-heavy operations. Then there are a lot of workloads where it’s awkward to try to use.
Java tried to do multithreading all the way from the ground up, to make everything thread-safe (which is actually pretty unusual for a full-featured runtime environment, because it’s a lot to take on). The upside is that if you need that, it’s gold; you can write your normal application and then run it on a 64-core processor and all of a sudden (relatively speaking) everything just works, which is great for massive-within-a-single-process scalability. The downside is that (a) you will get people who disagree vehemently with you on whether within-a-single-process scalability is worth the complexity cost you pay, and (b) if you’re just trying to write some code where you don’t care about threads, guess what? You have to care about threads. You need mutexes, you have subtle bugs and deadlocks, you have lots of extra testing headaches, or else: You can sort of close your eyes and run your Java application single-threaded, which defeats some of the purpose, and also God help you if later on you ever want to try to make it multi-threaded.
Neither one I would say is right or wrong. There’s a whole third way, which is actually what most environments do, which is that you say that a lot of things in the runtime aren’t thread-safe, and so if you want heavy scalability you do it with multiple processes, and if you need threads you need to take on the responsibility of tiptoeing around the non-thread-safe stuff. That’s sort of a mess, which is why both Java and Node take different more coherent approaches to it.
Tysm for your response! Really appreciate it (◍•ᴗ•◍)✧*。
No problem, glad it was helpful 👍
There isn’t one, java is excellent for async and multithreading and it does it properly unlike node that fakes it by running on a single clever event loop or stealthily launches a bunch of node instances in the background depending on implementation.
I talked up above about my feelings on it – I did Java and J2EE programming for years back in the day, so I’m well familiar with Java and its very real strengths and very real weaknesses. There’s good and bad to the many-threads-in-a-process approach, and to the one-process-per-task approach, and to the one-thread-with-async approach. If what you’re looking for is many-threads-in-a-process, then yes, Java does it right. But if you’re looking for something else, maybe it’s going to be wrong. It just depends.
Also can you explain a little more about the implementation that stealthily launches a bunch of node instances in the background?
My bad, I was mostly curious about how it matched OP’s project better and why.
When you say it does it properly, do you mean actually creating proper threads or something else?
Partly because sometimes a particular language suits a particular problem set.
Partly because people just like writing computer languages.
But mostly because people mistake the fundamental problem of programming, which is programming is really hard. So someone comes along and thinks “Programming is really hard, it must be a problem with the languages available” and sets out to write a computer language that makes programming easy.
But all that happens is they trade one set of difficulties for another set of difficulties. They might succeed in making writing the initial version easier, but make maintaining that code harder. Or they might solve some memory allocation problems, but create performance issues.
Either way, someone will write a language because they think they will help solve the issue of programming being hard, and fail. Because the really hard bit about programming is about understanding everything the program needs to do, in microscopic detail, and translating that into a structure that best fits the problem; not the actual coding itself.
This is why we need low code solutions /s
Think about this: Why are there so many automobiles? And why are so many new models still being made? I would think you would try to perfect what you have instead of making new ones all the time. I understand you need new automobiles sometimes, like construction equipment trucks or some treaded military tanks. But for average daily driver you would think there would be some kind of universal automobile. I drive a Corolla btw. I like automobiles. But was just wondering.
I’m not here to mock you, just providing an analogy. You can deliver just about anything in one language that you can with another. However, like the car, you might need a different type if you want more performance. Maybe you want a fast car. High performance cars often need a lot of attention, they need that premium gas, the mechanics demand higher pay! What if you only care about getting from point A to point B, and you’re more concerned with driving a car that’s cheaper to maintain, maybe there are just more car mechanics for that type of car, and the cost to pay them is cheaper.
A C application that is very well tuned to manage memory and threads in the name of perfect performance will require more time and computer science knowledge to create when compared to a Python script that does the same thing, but in the most basic possible way running on a single CPU, running hundreds of time slower.
Sometimes you need the performance, and often you don’t. Sometimes you need a treaded tank, sometimes you need a NASCAR, and most days the Corolla does just fine, it’ll even let you miss a few oil changes before things get bad.
As to why we don’t perfect what we have now instead of creating more: technology changes, easier to work with abstractions come about, some people enjoy the hobby of creating a language, or maybe a niche language comes about with very specific trade offs for a very specific purpose, no one wants to break backwards compatibility by adding new features and syntax to their language - I’m sure there’s tons more reasons to list.
well … we all know the perfect programming language was created way back in 1960
Ugh, for my work we maintain a software add-in written in Lisp and it’s a nightmare to work on
I thought that link was going to point to this other great programming language
And that link somehow doesn’t open well for me, something about a bracket I believe
And that link somehow doesn’t open well for me (something about a bracket I believe
https://en.wikipedia.org/wiki/Lisp_(programming_language)
(What do (you) mean? ( Lisp certainly has its (downsides) and (upsides)))
(do (What) (you mean))
(has Lisp (and (its downsides) (its upsides)))[Lisp would be a VSO language]
You’re wrong. COBOL is obviously the most perfect language since it can be easily written by managers and people who don’t know how to program, right?
Think of a programming language as a crutch for the human brain. Processors don’t need it: they don’t have to think about the code, they just execute it. Our mushy human brains need a lot of help, however.
We need to think about things on our own terms. Different programming languages, different APIs that do the same thing, different object models, these all help people tackle new problems, or even just implement solutions in new ways.
Some new languages have a completely different model of execution you may not be familiar with. Imperative languages are what we traditionally think of, because they work most similarly to how processors execute code: the major pattern used to make progress, do work, is to create variables and assign values to them. C, COBOL, BASIC, Pascal, C# (my personal favorite), Javascript, even Rust, are all imperative languages.
But there are also functional languages, like ML or F#. (The latter, I keep installing with Visual Studio but never ever use) The main pattern there is function application. Functions themselves are first order data, and not in a hacky implementation-specific way like you’re passing machine code around. (I’ve only ever used this for grad school homework, never professionally, sadly.)
And declarative languages like Prolog helped give IBM’s Watson its legendary open question answering ability on national TV. When you need a system to be really, actually smart, not just create smart-sounding text convincingly like a generative AI, why not use a language that lets you declare fact tables? (Again, only grad school homework use for me here)
Programming is all about solving problems, and there are so many kinds of problems and so many ways to think about them. I know my own personal pile of gray mush needs all the help it can get.
Well I guess I am part of “they” since I have my own programming language pet project. Why did I create it? Because I wanted to, mostly. Sure, there are also some finer language design choices I wanted to choose differently for my preference, but mainly I just wanted to learn how.
I would think you would try to perfect what you have instead of making new ones all the time.
Perfecting what you have often leads to a completely different language. See C vs C with classes which ended up being C++.
There is absolutely no problem with creating new languages. These are often designed with specific features in mind, and the success cases often offer features that are in high demand. Take for instance node.js, and how its event loop makes it a near ideal language for network-heavy applications that run on a single thread.
You can not perfect old languages, since there are a lot of features that you can not add on or change afterwards, OP. Not in a worthwile way. This is not a philosophical question, it wasn’t for a lack of trying. And since there aren’t enough skilled people in this niche, fashion driven field, expect history to repeat itself and some langs at best get 60 to 80% right.
You cannot perfect old languages. And you cannot write a new language without making architectural errors. And any new language that deviates significantly from what has gone before will only ever see niche success.
Thus what we have today is the best we can expect: gradual evolution of new languages, and gradual improvement of old languages. Neither has any particular advantage, but the industry as a whole keeps grasping at the eternal straw of the ‘silver bullet’ language that new languages promise.
I know a handful of languages and I think of them as tools. For example, a flathead screwdriver will work on a phillips screw head (In most cases with some outliers), but a phillips screwdriver might just be better for the job. Same with a wrench and a socket with a ratchet, etc.
When it comes to programming or scripting I approach it in the same way. If I am at work, and I need to automate something quick and dirty, no end user will need to use it, and it is just adjusting data or spitting data back at me, I am probably going to write it in Python.
Or, if I need to make something that an end user is going to interact with, I am probably going to spin up a web server and use the MERN stack to create that.
If I am working at home on a TUI for my favorite application, I am going to use Rust or Python
And if I working on a project that requires me to work with embedded systems, I am probably going to reach for C, maybe C++ depending on the support, and I have in a couple of instances needed to use Assembly.
All this to say, I think that if I had to use Python for all of these, I would be in trouble. Same as if I had to use C++ to accomplish all of the above. Could it be done? Sure. Do I want to do that? Not at all.
