Why do they keep making new languages

you would think there would be some kind of universal language

Why invent the screwdriver if you have a hammer

Some languages have a obligation to support older versions, provide upgrade guides. They have old baggage in the forms of old systems or processes that they can’t just abandon.

Sometimes it’s easier to just start over from a clean slate. Experimenting and seeing how it works. If it fails well you haven’t inconvenienced millions of users.

It’s all about experimenting, trying to see what works, what it’s good with and what it’s not good with. A language like Java can’t just change to experiment things. Some people are also fixed to the style and methodology that Java provides.

Aside from that, hobby languages are just hobbyist stuff.

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.

Last but not least, Java was supposed to be this universal language that you can run everywhere. It failed and it cannot be run everywhere. It also had to be improved a lot, and it's missing a fuckton of features from every other language.

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.

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?

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.

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.

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 … we all know the perfect programming language was created way back in 1960

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.

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.

No idea, HolyC is the only language we need.

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.

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.

For various reasons.

Different languages take different approaches and models to do stuff. Thus making each one better or worse for different challenges.

For example, python is easy and quick to get up and running. Bug it's slow and unsuited for low level programming (like OSes, drivers, and embedded stuff). On the other hand, C is very fast and very low level, allowing you to make both high performance programs and low level stuff, but it's a nightmare to use and you will run into all sorts of problems that an easier language, like python would avoid. All of this is mostly due to python being interpreted (instead of compiled) and c having manual memory management.

But they might also take a different approach at computation, like for functional languages (opposed to imperative languages) which try to solve problems in a more "mathematical" and declarative way, instead of defining a sequence of instructions. Or, even more, logic programming languages, in which you define a series of logical statements and the language tries to find solution and draw conclusions from them.

And some languages are designed around some particular concept that they think is beneficial and worth exploring, maybe taken from various other languages and put together, like rust which is designed around the RAII design pattern and takes large inspiration from functional languages, while still being and imperative procedural language (like C, so not object oriented). Or java which was designed to be a portanle but performante object oriented language, with support for low powered embedded system, full of features but simpler than c++, etc... all stuff that now is nothing special, but remember that java us very old. Or kotlin which tries to be java (they are interoperable), but modern and better and more "pure" or "consistent". Or c++ that started as an object oriented superset of c, but then started adding every single feature of every other imperative language, and never giving up on older stuff, to the point of becoming very hard to use correctly while making it very easy to screw yourself in the most intricate ways.

And of course there are domain specific languages (opposed to general purpose languages). Which aren't even necessarily Turing complete. They are designed for one purpose only, and they do that better than general purpose languages. For example AWK for text processing, or SQL for databases, or matlab for scientific calculations, or TeX for typesetting, or GLSL for shaders, or coq for theorem proving. And here imagination truly is the limit.

So, the point is, every language is more suited then other for some kind of work. And when people stumble across some problem that is hard to tackle and come up with some approach to solve it, or when they grow fed up with the issues of some older languages, they often like to make a new language around that. And some times this leads to entirely new paradigms which are worth exploring.

P.s.: I like languages:)

Why do we need Java AND JavaScript? \s

let hem keep at it. I haven't found an easy and verstile language as Python than can compile to byte code and be as fast a C ! I know it is coming anytime now despite having been waiting for over a decade.

New languages deal with challenges the old languages faced differently, with hindsight of how those languages dealt with those challenges and how they could have done things better.

We don't even have a universal language for communication. That may not be a bad thing, either. There's a theory that the language you speak changes the way you perceive the world - I believe that's true with programming as well. If we only had Java, we'd only get Java-style solutions.

Permanently Deleted

A given programming language often has limitations which are largely different than the limitations from others. This means that different languages are often used on different kinds of problems. Want something fast, use C. Want to write something quickly, use python. Want it to run on just about anything, use Java. And so on.

So why don't we make one ultimate one or a few that fulfill all needs? Well, partially because we haven't figured out how to do that, but also it's really easy to learn yet another language once your understand how they work. I can write in python, js, c, c++, c#, Java, kotlin, rust, perl, ruby, php, forth, lisp, and I could keep on going for quite a while. The underlying concepts are largely the same and so picking up a new language is no big deal (though being good at it is a bigger deal). We have so many because ultimately it just doesn't really matter that we have so many.

There is a time when you are solving/coding for a specific domain and you quickly start metaprogramming (coding a code generator). That's the moment when you write your own Domain Specific Language. They have a tendency to grow and evolve. In time some of them become full blown programming languages themselves.

My suggestion, learn a few from different paradigms. They are more than eye opening.

Why are there so many different stores? You have grocery stores and hardware stores and computer stores and bulk stores and electronics stores and fire work stores, there's even fast food businesses and strip clubs.

You can buy most of this as Walmart, so why isn't there just a universal store?

Technology advances. Both theory of programming languages as well as their practical implementations are large fields of research with many people working on it.

Software is so much at the core of everything today that making its development cheaper is extremely lucrative.

they should have stopped after x86 ASM 😔

There are a lot of people with a lot of opinions and preferences that are trying to do a lot of different things in a lot different ways. The same reason we have so many of anything.

Because people are afraid of C ;)

If any of you happen to still be on Reddit, I actually maintain a "catalog" of these newer languages, as they come across my radar. One of my more recent finds is MiniScript, which the author of that has been using to port a fair amount of classic BASIC games from that GitHub archive I posted about recently. I got sucked into Nim, which seems like a good synthesis of Python, Javascript, and C++; c/nim exists for anyone interested.

Without new programming languages we would still be using FORTRAN, AGOL and LISP.

https://fortran-lang.org/learn/quickstart/hello_world/

https://lisp-lang.org/learn/first-steps

https://www.computer.org/publications/tech-news/insider-membership-news/timeline-of-programming-languages

One reason why new languages are developed is the creation of a "Domain-specific language" or DSL. See Wikipedia for more information.

Programming languages are tools you pick the one for the job, there are situations where Java's garbage collection could be a problem so it would not the right tool to use.

There can be a universal language in theory, but it's borderline impossible to achieve. Every domain has a different set of problems that it needs to solve, and language design involves tradeoffs that may make sense for one domain but not another. That's why I think language wars are silly, without context it's impossible to say which language is "better", because you could have different answers depending on what you're trying to do.

In the end you shouldn't be too concerned with it. There are lots of languages, but all of them fall under two or three paradigms where if you learn one language from that paradigm, your skills are mostly transferable.

Aside from all the pragmatic reasons that were already listed, it's also just fun to write all the parts required to make a programming language.

That's why everyone actually codes in lisp.

Like human languages, you get different types of expressiveness in different ways. If you know multiple languages whether is python or Java, or English and French / Spanish / German, you'll see that there are positives and negatives to each language.

Lots of people want to design the best combination of them all, using the newest tools and newest tech to create something as useful as possible.

What might compel someone to make their own language? Typically, it's because they've already used some languages, they have some criticisms of it, and they want to make something better. Now, for languages that are open source and accept community contributions, that is an option. However, keep in mind that each language already has its own core maintainer(s), with their own vision, as well as a whole host of other people who would have to be convinced that your idea (whatever improvements you want to make) are a good fit for that language. Some changes can be quite drastic — especially if you want to improve one language by bringing in insights you've gained from another. So sometimes (not often, but sometimes), people say "fuck it, I'm making my own language, with blackjack and hookers".

The thing about software is, it's really easy to play around with. You don't need a workshop or parts or anything — you just need your computer. As a result, you have lots of people tinkering with stuff like making their own programming language, whether just for fun or more tangible reasons.

And we've been in this cycle of innovation for decades, and it's how we've gone from punch cards to assembly to C, Python, and all the rest.

But surely we don't need any more innovation? Like, why can't we all just use one language for everything?

Well, it's true that nowadays we have a whole bunch of general-purpose, multi-paradigm languages. The analogy people like to make is "different tools in your toolbox". But, to clarify, it's not that some of them are hammers and others are screwdrivers; they're all the same kind of tool ("programming language"), so really it's more like different screwdrivers, of varying sizes, with differently shaped bits at the end.

With screwdrivers it's clear why you might need one with this shape or the other: Otherwise it won't match the screw. With languages it's a little more subtle. You see, when you design a language (or almost anything else, ever), you inevitably make a series of tradeoffs. Is the language compiled or interpreted? Does it have a garbage collector? Does it have a strict type system? How does it do async? Does it support higher-order functions? There's a million questions, and you're going to get a different combination of answers for each language you look at. And that's before you evaluate other (potentially very important) things, like "is this language fast enough for my use case?", or "I need a library for such-and-such, has someone made that in this language?", or "does the language have a solid enough community that I can reliably search the answers to my questions?".

Technically, any of the major languages — Java, Python, C, C++, C#, Javascript, Go, Rust, etc etc — can be used as a one-size-fits-all, universal programming language. There's actually a joke "law" that goes "anything that can be written in Javascript, will eventually be written in Javascript". But they each have their own unique combination of design decisions, so in practice different ones will be easier to use for this kind of project or that (one major factor is third-party libraries, like python's numpy or pandas, that may not have equivalents in other languages). There are also situations where, for a given platform, you have to use that language. For example, for Microsoft's .NET stuff, I don't think you can substitute C# for something like C++ (someone correct me if I'm wrong please). Or, if you're working on the Linux kernel, you're pretty much just using C (I think they were considering adopting Rust, but idk if that's still going on). And, of course, the dominant programming language for anything on the internet is Javascript (although WebAssembly has made huge strides in roughly the past decade, so you can actually use other languages as long as they can compile to WebAssembly).

Finally, to wrap up this already way-too-long comment: a lot of these languages are very similar to one another. They're all procedural, heavily inspired by C, and for the most part they're either compiled and statically typed, or they're interpreted and dynamically typed. There are also a whole bunch of other languages, called functional languages, that are designed based on entirely different principles (the principles aren't harder to learn than what you're having to learn for Java, they're just different). But if you are looking for a universal programming language, I think the closest you're going to get is either C, C++, Python, or Javascript. In addition to Java, I would strongly recommend you learn C and Python (C has a bit more of a learning curve, but it teaches you a lot about memory management, which is a lesson you'll carry with you to any other language).

People need and want various levels of abstraction, type system control, and even just syntaxes. In these cases, it's easier to switch languages - or make one - than to implement a solution in a language that would fight against your needs.

Because people don't want to admit that JavaScript will be the only programming language in the future and that resistance is futile.

01001010 01110101 01110011 01110100 00100000 01100011 01101111 01100100 01100101 00100000 01101001 01101110 00100000 01100010 01101001 01101110 01100001 01110010 01111001 00100000

Permanently Deleted

Especially if one of them is based off the other.

Rust is based off of C/C++
Ruby is based off of Perl, Smalltalk, Eiffel, Ada, BASIC, Java, and Lisp

Just a couple of examples. Quite frankly, it's dependent on what system, what infrastructure .etc that'll be the call for a specific programming language. Nothing wrong with just picking one or two and sticking to them.

And I think that's what a lot of beginners in wanting to study programming languages can fall into, they want to be the jack of all trades in programming. But there's this problem of a new language coming in all of the time and it can get very wiry trying to remember them all.

Permanently Deleted

We don't/ None of them are a significant improvement on PL/1 other that having objects (which hadn't been invented.) I blogged on this recently. https://bobbrowning.wordpress.com/2023/07/02/typescript-i-quite-like-it-plus-bonus-rant-about-languages/

We should make one programming language to rule them all!

https://imgs.xkcd.com/comics/standards_2x.png

The same reason anyone creates a new product in an existing market - they want money.