I'm in the process of reviewing my year and planning what I want to build in 2025. A critical piece of that is what technologies / programming languages I choose.

In this post I'm going to share my tier list for select programming languages I've used in my career, some thoughts on them, and which I plan to use in 2025.

2025 Programming Language Tier List

Some notes about this tier list:

• Only includes languages I've spent a significant amount of time with over my career (like over 6 months working on a real world project)
• 6 months is not a lot of time to spend with a language so I am likely not an expert in many of these (nor is time a good measure of "expertise")

I will loosely be rating these languages based on a set of 3 categories I think are important in a language:

• Modern Types - Strong, statically declarable types with good tooling and capabilities like sum types, options / results, immutable first, and value equalities
• Solid Core - Good ergonomics, performance characteristics, and standard library
• Strong community ecosystem - Quality and quantity of libraries, userbase size, etc

These are all kind of loosely defined and subjective so bear with me as I try to explain my rankings and know that they are imprecise by design.

S Tier

S Tiers are superb languages. They are excellent in most scenarios. There's very little reason not to choose them as a first or second choice.

S tier languages are noticeably absent on my tier list. I've thought about this a lot and I do not think there's a language on the market today that excels in a majority of areas. I also think such a language is not only possible but readily achievable with today's knowledge and technology so I'm making it clear that there is a gap in the market to hopefully inspire someone to fill it.

As we walk through the lower tiers I'll give my opinion on why they do not meet the requirements for S Tier.

A Tier

A Tier languages are great in most scenarios and I would happily choose them for most future projects.

F#

• Modern Types - Yes
• Solid Core - Yes
• Strong Community Ecosystem - Meh

F# is the closest I've found to an S Tier language so far. It's got a great type system (though some fp purists say it's not enough), it's got a very solid core that is succinct, robust, and performant, and piggybacks off C#'s .NET getting all the performance, features, and libraries that exist over there.

But F# is not perfect which is why it's not in S Tier. The biggest issue with F# is it has a small (but mighty!) community. This means it just doesn't get the love of a top 10 language in terms of attention, funding, and updates.

All in all this probably won't impact your F# projects that much. It has a solid core, has access to all .NET libraries, and most F# libraries remain working even if they haven't been updated in a few years (we're not like those crazies in JS land who have to update every 12 months). In some ways this is the closest I've seen to an ecosystem with "finished" libraries that perhaps don't need changes but I'll cede the point - a small userbase is scary.

I think F# has the potential to be an S tier language. But to do so it will need more adoption from more people, at least bringing it into the top 25 (F# is currently the ~42nd most popular language). That would mean passing both Elixir and Haskell in usage and is a ranking I don't think F# has ever reached in its 20 year existence so I won't be holding my breath (but I will continue pitching it in these blogposts).

F# will remain my go-to language in 2025 for the simple reason that F# is fun and I've yet to find a better option.

TypeScript

• Modern Types - Yes
• Solid Core - Meh
• Strong Community Ecosystem - Yes

TypeScript has literally revolutionized the web dev industry. It brought types (and sanity) to whatever it was we were doing with JavaScript before and is now a top 5 language in its own right.

On top of that the types are pretty good! The syntax is pretty ergonomic and it can do nice things like union types which is unfortunately still a huge differentiator in type systems in 2024. The type declaration syntax looks very similar to F# (which I like) and that's because TS was partially inspired by F# according to F# BDFL Don Syme.

So TypeScript has a lot going for it. It's got nice modern types and access to the entire JavaScript ecosystem which remains the largest on the planet.

Why is TypeScript not S Tier? Because it's not super solid at its core. Yes it's used by a ton of people in production and works incredibly well. But largely it works well despite its messy core and really because so many people have spent so many hours working around it. TypeScript really is a set of tools that transpile themselves into JS so no matter how good TS gets it will always be JS at the end of the day - for better and for worse.

Overall I think TS has the potential to be an S tier language. But it has the same issue as a lot of these languages in that it may not be easy to go from where they are now to where they would have to go to be an S tier language. In particular JS and its ecosystem as a whole would need to close some gaps in terms of foot guns, stability, and ergonomics for TS to truly reach its potential.

I think it's always a bad idea to bet against JS / TS because this is the largest dev ecosystem on the planet. If it decides it's going to solve this problem it can. But it will take a lot of doing and some consensus on what this next step looks like, which JS-land has historically been bad at.

TS is still the king of the web bringing sanity to JS land. So if I've got to go web native or want to leverage the huge ecosystem I'll happily use TS (or at least JS with JSdocs) for that portion. It's still a little unstable for my tastes but the rewards are worth it and webassembly just isn't in a position to compete (yet).

B Tier

B Tier includes technologies that I think are fine choices but would probably prefer a different technology if I get the choice.

JavaScript

• Modern Types - No
• Solid Core - Meh
• Strong Community Ecosystem - Yes

JavaScript is ubiquitous - it's the language of the web. As such it's gotten a TON of support over the years which has led to a ton of improvements.

This has made JavaScript good not great. It's impressive what they've done despite all the issues it's had.

In particular JavaScript still suffers with a messy core - it's filled with footguns, lacks any kind of types which is just not acceptable in 2025, and is infamous for having a very unstable ecosystem (insert meme ab 3 month old app no longer working).

If you're building something for the web - JavaScript is probably the choice for that. You'll be fine, the thing will work, and you can go on with your life. But opt for TypeScript if possible as you'll probably have a better time.

Personally I'll probably use JS here and there when it makes sense, and prefer TS when it's not a super heavy lift. I've found a little bit of JS goes a long way when coupled with my no-build webdev tools of choice HTMX and Alpine and expect that trend to continue in 2025.

Python

• Modern Types - No
• Solid Core - Meh
• Strong Community Ecosystem - Yes

Python is also ubiquitous, just in different ways - from the classroom to big tech (Instagram runs on Python!) to most AI tools. Python's large userbase loves it for its ergonomics especially compared to its more "enterprisey" contemporaries.

But these ergonomics come at a price - a price you end up paying at scale. In particular Python's lack of modern types (yes it has "types" but they're not very good), meh package management, and hand-wavey nature have led to countless bugs / fires / sevs in code that could've been caught with better tools and a more solid core.

To put it simply, Python is fun at small scale but at large scale it starts to be a huge PITA (and yes I'm still writing Python professionally today).

Clearly Python is a fine choice given how many orgs use it successfully today. But I always wonder what the world would look like if we simply picked technologies with better bones - that fixed the common pits of failure so we stopped falling in them over and over and over again.

Python is likely a fine technology to choose for whatever you want to build - there's probably a library for that and someone's already written up documentation. But I don't think Python has much of a future. Its foundation can't support it at large scale and refactoring it to do so would basically require a ground up rewrite which is generally hard to do (plus w the Python version 2 -> 3 fiasco, I'm not sure they're excited to try a 4 anytime soon). The mass adoption by the community will likely keep pushing it forward for many years to come but ultimately I think that effort would be better spent on a better foundation.

I will probably not choose to work with Python in 2025. This doesn't mean I won't work with it (my past 3 jobs all used Python heavily) I just won't seek it out. It's very likely I will continue writing Python for years into the future.

C#

• Modern Types - Meh (probably a No today)
• Solid Core - Yes
• Strong Community Ecosystem - Yes

C# still has a reputation of being too "enterprisey" for people to dive into for startups and side projects but honestly it's improved a lot over the past decade and is a really good choice for most web app backends. It's great at backend, scales well, and has a huge library ecosystem built up over decades as a top 10 language. On top of that many of these libraries were created and maintained by orgs using them in the enterprise which had led to generally good stability in the ecosystem (if a bit slow moving and over engineered).

The only thing really holding C# back in my eyes is its legacy type system. It's got good types, just not great - no standard sum types, match patterns kind of with switch statements.

I'll note that this is pretty common among most popular languages so C# is not losing points here, just not gaining them (yet). I will note that C# has landed many features improving on this stuff from records to their pattern-matching-like switch statement and more improvements are supposedly on the horizon as C# looks towards sum types. So I think this could change and we get more modern types like F# but we're just not there yet.

Overall I think C# is a good choice. It's got everything you'd want to build a solid system. But it is still a little old school. That may change as it picks up more features from F# but it hasn't happened yet and may not for awhile.

C# isn't my first choice in 2025 but I could see myself using it at a job or if I want to dive back into game dev with Godot or Unity.

C Tier

Here are languages that I think can be fine in certain contexts but I personally would avoid picking them up unless I had a good reason to.

Golang

• Modern Types - No
• Solid Core - Yes
• Strong Community Ecosystem - Meh

Golang was majorly hyped along with Rust when it hit the scene. It was simple and good to Rust's great but complicated.

I think Golang is simple and deserves praise for this. But I also think simple is subjective so it may make sense in some contexts but maybe not all.

My experience writing Go is that it's unnecessarily tedious. Yes it's simple in that the tools themselves are simple but meshing it all together is a chore. You may write a lot of simple code in isolation, but is it still simple or even sound when you combine all of it together?

With Go's barebones type system it's easy to create stacks of simple things that lack any real structure overall.

A metaphor for this is like building a structure. Go has some rock solid primitives to build on top of that are very simple. This is kind of like building with cinder blocks - very strong, very easy to work with. So we can build structures in this manner very quickly.

But to what scale? If we're building a sky scraper this cinder block thing is going to get real tedious real fast. Moreover it's possible that this simple granularity starts to fall apart as we get too big - we need a way to reinforce these so there's overarching stability (like steel beams). But the type system is pretty rudimentary so we often can't do that very easily - we just kind of have to hope that each individual piece sticking together is enough for the whole to have stability.

I'm not sure if this metaphor is helping or hurting but my point is that I get why Go is popular and simple to write but this doesn't necessarily mean it's simple to build with at scale. If you like Go's syntax and performance characteristics then I think it can work fine but personally I think Go's type system doomed it from the start and it needs to fix it if it wants to persist into the next generation.

I will personally be avoiding Go in 2025 unless I have a good reason to use it.

D Tier

Probably avoid unless you have a very good reason to use it.

Hacklang

• Modern Types - No
• Solid Core - Yes
• Strong Community Ecosystem - No

I used Hacklang for a few years while working at Meta - it's a fork of PHP that runs a majority of www (Meta's central monolith). If you haven't heard of it you're not alone and that's one of the big reasons it's down here in D - I don't think it's advisable to pick up a fringe language that nobody uses if you don't have a good reason for it.

That said I think Hack turned out to be a better language than I expected with decent types, piping ergonomics, and pretty good performance characteristics. It reminded me a lot of a C# or Java just with syntax that looked more like PHP or Python.

I wouldn't recommend using Hack in the outside world unless you have a really good reason to. But if you do choose it, you can probably go reasonably far for a web app.

I think without Meta supporting Hack it would quickly go extinct. With PHP's recent overhauls, it's probably a much better choice overall.

If I go back to Meta I may end up using Hack again. But otherwise probably won't touch it.

Next

So that's my tier list going into 2025. I'm still looking for an S tier language but am pretty happy with my A tiers in the meantime. Ofc I'm sure I'll dip into the B tier for my job and maybe even a side project here or there.

LMK what your tier list looks like, what you agreed / disagreed with, and if you have any leads on an S tier I should try.

If you liked this post you might also like:

• A Brief Comparison of Modern Programming Languages - TypeScript vs Golang vs Elixir vs Rust vs F#
• 5 Reasons F# is a great Python alternative for scripting, side projects, and enterprise applications
• The HAM Stack - A Simple Scalable Tech Stack for building modern web apps fast and cheap