Programming languages in 2025: what we have now and future predictions

So What Languages Do We Have: Backend

Right off the bat:

• I am coming at this with an extreme bias for web development.
• Many people may disagree with my assessments, particularly if not focusing on web development.

Java

• I won’t dig into this too much.
• Java was a great language up to mid 2010’s.
• Now there are many more objectively better alternatives, when it comes to anything web related at least.
• For many modern web services, the Java Virtual Machine (JVM) feels like an unnecessary abstraction and overkill. It consumes a lot of memory, has higher startup times, and is generally a bit inefficient.
• Other languages such as Golang could replace this easily, with easier syntax and better performance.
• Usage is in decline, but Java still has a huge market and foothold however (it’s used lot in enterprise, high-performance computing, financial services).

C, C++

• C is the current standard for low-level performant critical code.
• It can run anywhere: embedded systems, backend web API, etc.
• It’s also dominant in systems programming, embedded development, and OS kernels.
• We can also bind to C from any other language easily, making it a great candidate for low-level ‘write-once, bind-many’ libraries.
• C++ is an extension of C with other advanced features and more capabilities like an Object-Oriented model, templates, and RAII.
• Many low-level libraries are written in C++, for example the excellent GEOS library for processing geospatial vector data.

Rust

• Rust is a C and C++ replacement, with key advantages being memory safety, no garbage collector, better concurrency, enforced type safety, and no runtime requirement (C++ needs a runtime, while Rust is entirely compiled to native machine code).
• While we have a huge amount of performance critical libs written in C and C++, any future libraries should probably be written in Rust.
• While it’s possible to bind to C/C++ libs from Rust, ideally existing libraries will be ported to Rust into the future.
  • The georust community is hard at work replacing many low level geospatial libraries in Rust, such as GEOS.
  • Maybe osgeo/GDAL one day?
  • Replacing SQLite C library with Limbo

Golang

• Rust is a “better” language when it comes to performance and code quality.
• The key tradeoff here is simplicity: Golang goes most of the way to being an excellent performant modern programming language, while keeping concepts reasonably simple and syntax easy to read / write.
• Go has a very good standard library built in, and is excellent at networking.
• Huge tools like Kubernetes and the ecosystem around containers are all written in Go, so it’s no going anywhere soon!
• If I had to write a small microservice / web API quickly and easily maintainable, I would use Golang. I did just that in a recent project.

Python

• Python is a fantastic high-level language with a huge community.
• It was the first language that I learned.
• It’s continually evolving and improving, moving from its status as a simple scripting language, to running many much more serious applications these days:
  • Web APIs with acceptable performance for most.
  • The machine learning community has consolidated around Python.
  • Anything else you can think of!
• The introduction of type hinting and other improvements from other languages have ensured Pythons spot at the top of the easy-to-use / modern and maintainable tradeoff list.
• For writing actual applications that leverage low-level languages underneath, or require building a community around them, Python is still my go-to language (for now).

Where Does Frontend Fit In?

There are two programming languages available in web browsers:

• JavaScript / TypeScript: what the web is made of currently (alongside HTML/CSS).
• WebAssembly: this is pretty much ‘backend code, in frontend’!

JavaScript… On The Backend??

• NodeJS introduced JavaScript for backend programming.
• We have seen the rise of many full integrated libraries covering both backend and frontend for web development, such as SvelteKit, Nest, Nuxt, etc.
• We have also seen new JS engines, such as Deno and Bun, to fix some of the underlying issues with NodeJS.
• But without going too deep, JavaScript just isn’t a great backend language. It’s single-threaded (aside from worker threads), uses prototype-based inheritance, and leans heavily on callbacks - all of which can complicate large codebases.
• TypeScript solves the weak typing problem, but that only goes so far.
• As an alternative, I would advocate for:
  • Simple web apps: use Python or Golang to write a simple HTMX server.
  • More complex web apps, requiring real-time or instant responsiveness / reactivity: use a local-first web development approach (future blog about this!), for offline-ready apps that sync directly with a database.

WebAssembly

• Typically WebAssembly isn’t written directly, but instead one of the backend languages listed above are compiled into WebAssembly.
• Out of all the awesome backend languages I listed above, these are the primary candidates:
  • C/C++: emscripten can do this, but we introduce two problems:
    1. Interfacing directly with the library from JavaScript means handling memory usage carefully and is not very user friendly.
    2. We write a user-friendly wrapper for the low-level API, that has to be maintained into the future.
  • Rust: was early to adopt WebAssembly as a first-class target and provides excellent tooling for compiling to it. It handles the issues around memory safety, meaning we can write our library in Rust, compile to WebAssembly, and essentially start using it directly in the web.
  • Golang: can also compile to WebAssembly and is a pretty decent, but less performant than Rust. The main problem is that it’s a garbage-collected language, meaning lots of superfluous code also needs to be compiled alongside your code (wasm_exec.js adds ~300kb). If doing this, I would recommend TinyGo

Summary

What to write (or learn) in 2025 and going forward:

• Rust: low level systems programming, or performant library to bind from higher level languages, including WebAssembly to run in the web. Complex & requires skill to use.
• Golang: willing to sacrifice some of the benefits of Rust for speed and ease of development. Ideal for small projects, startups, demos, microservices, etc.
• Python: if writing simple websites (most of the web!) that could use the simplicity of HTMX. Or if working with machine learning / modelling. Or for writing scripts, where Python really shines.
• JavaScript: if you are writing user-facing application, this is the language to learn. Particularly if you wish to make a web app that has a very modern feel and leverages the advantages of local-first web development.

As Promised, Some Prediction

• C & C++ usage will eventually decline in favour of Rust, for low-level performant libraries. A good example could be the migration of GEOS © to GeoRust (Rust). I’m far from the first to point this out - it’s a growing trend (even the Linux kernel may have some Rust modules…).
• The web ecosystem is diverging from the traditional ‘backend’ API-driven model toward local-first JavaScript approaches (compute and data in the browser).
• Python usage will remain high, but JavaScript will dominate further in the web domain, as backend APIs (± ML / LLM) are swapped in favour of WASM compiled libraries directly in the frontend (Postgres in the browser anyone?).
• Personally, I think a safe bet would be to double down on the JS / Rust combo.