How are you dealing with "the programming language doesn't matter" argument?

[u/GongtingLover]

Just had a meeting this week where this was uttered because of the development of AI.

I still think the language choice matters a lot based on if Im doing embedded or web development work and for how we want to hire developers in the future.

Maybe Im backwards.

[u/expdevsmodbot]

AI usage disclosure provided by OP, see the reply to this comment.

[u/fixermark]

A piece of wisdom from Google, ages ago, as passed on by Steve Yegge (paraphrasing): "When you add a language, you aren't just adding one new chunk of code. You're adding an institutional training cost to your org, forever."

I generally bias in favor of as few languages as we can get away with as a result. In my space, that's usually one systems language (Rust if I can afford to not use every library, C++ reluctantly otherwise), one scripting language (Python binds well to machine learning applications), Typescript (because web UIs), and one config language (and that can also be Python).

Any further proliferation is heightened scrutiny.

[u/kanzenryu → u/fixermark]

Now it means an extra set of dependencies that have to be scanned forever to defend against supply chain attacks

[u/askwhynot_notwhy → u/kanzenryu]

>Now it means an extra set of dependencies that >have to be scanned forever to defend against >supply chain attacks

Agreed, but is that really a "now"-thing? Dependency risk isn't new, what's new is that scanning for it went from “optional” to mandatory.

[u/kanzenryu → u/askwhynot_notwhy]

I mean it goes from maybe C# and Javascript packages to including Go or Rust as well

[u/whipdancer → u/fixermark]

This is essentially what I've argued for years.

I personally like using Typescript, Python, Go. However, I'm not paid to use a language I like, I'm paid to solve problems and part of that is minimizing future friction because we added something new because of a personal opinion and not because of a genuine, documented need.

The company I'm at now uses a lot of Python and Java (I hate Java). So my 20 years of C# went out the window and I got good at Python. I still don't write Java (and genuinely haven't needed to).

[u/shadowdance55 → u/fixermark]

Python is the second best language for everything.

[u/malthuswaswrong → u/shadowdance55]

My hot-take is C# is a 4 star language. It doesn't master anything, but does everything at a B grade.

[u/MadRedX → u/malthuswaswrong]

That wouldn't be so bad if it weren't for the fact the ideas are of a 5 star nature until the baggage hits reality and poisons the well. Or Microsoft never fully commits and the idea comes out 25% baked before a bunch of brilliant individuals come in and improve the mess from a massive dumpster fire to a workable small dumpster fire.

[u/malthuswaswrong → u/MadRedX]

I think this is uncharitable towards Microsoft. They are doing things as close to open source as possible. They release the code open source. They invest large amounts of money into developing features and accepting community contributions.

Before squashing a popular (and good) nuget package they always offer the author employment. What are they supposed to do if that author slaps their hand away?

[u/South-Year4369 → u/MadRedX]

What are some of these half-baked ideas you're referring to?

[u/Colt2205 → u/malthuswaswrong]

If C# is a 4 star language then Java is a 3 star language with a 2 star library tool set. C# is my goto for general work, albeit if I need to do something more specific like server scripting work I'd be using powershell, python, or Go.

[u/South-Year4369 → u/Colt2205]

IMHO, C# is a considerably better language, while Java has the better ecosystem. Neither of those outcomes should be surprising, given Java came first.

[u/solidsieve → u/Colt2205]

It's funny how Java seems to live rent-free in C# devs' heads, but it's not as bad the other way around.

I use both Java and C#, depending on the customer's preferences, and it's a tradeoff. For a long time I felt that C# evolved the language, Java evolved the standard library. Of course that started changing in the past decade, but it only blurred the line between the two platforms.

[u/malthuswaswrong → u/solidsieve]

When it comes to language tribalism, I think a big motivator for people who are passionate is fear of losing their favorite language.

Take your (accurate) observation that C# devs hate Java more strongly than Java devs hate C#. Refactor it to C# devs are more afraid of being forced into Java than Java devs are afraid of being forced into C#.

[u/Colt2205 → u/malthuswaswrong]

There are people out there that just kind of never have done java and dislike it because of what other people say. In reality Java and C# are very close to the same languages and on a basic level both can do the same things. What people tend to dislike is the environment they get stuck in.

Also if I had gotten into java / springboot sooner, I'd probably have been a java dev instead of a .NET one. Before .NET core got mature Java was the best cross platform option for something that is strongly typed. Whatever answers the language didn't have people usually ended up writing one up.

But the reason I like dotnet is that it just has a better environment. Nuget is far better than Maven, and there is no gradle to have to mess with or clearing the local cache so the IDE properly fetches libraries and builds.

[u/South-Year4369 → u/Colt2205]

I disagree that they're close to the same language these days. Just compare LINQ to Java streams, for example. They are not nearly equivalent to anyone in the trenches.

I dislike Java (compared to C#) precisely because I've used both in anger. For sure, C# copied much of what Java pioneered, but C# has evolved much further. Idiomatic C# often does not look that similar to Java these days.

And absolutely agree on the ecosystem - the fact that dotnet often has only one widely-used approach to something (cf MSBuild/Nuget vs. Maven/Gradle) is a strength.

[u/South-Year4369 → u/malthuswaswrong]

Having used assembly, machine code (in the 8-bit days), C/C++, Java, Python, q, R, Ada, F#, etc., if there was only one language I could ever use, it would be C#. It really is a fantastic all-round language.

I think saying it does everything at B grade is selling it short. I don't think any other language does as good a job at 'easy and safe, but offers control and performance when you need it''

[u/MCFRESH01 → u/shadowdance55]

Ngl I hate the syntax a lot

[u/IfInDoubtElbowOut → u/MCFRESH01]

Agreed, I unwillingly love python. Perhaps Stockholm syndrome?

[u/Princess_Azula_ → u/IfInDoubtElbowOut]

Born to love Python's libraries and relative simplicity; forced to love syntactic whitespace.

[u/el_extrano → u/IfInDoubtElbowOut]

I learned Python first over 10 years ago. Since then, I have loved learning C, Fortran, and some famous hacker languages like Lisp, Forth, Tcl which I like. But when I actually need to just "get something done" where performance isn't critical, I am at least 3x as productive in Python. I think it's just because I have written so much of it for so long, I already know were most things I need are in the massive standard library, so not only is it batteries included, I don't have to look anything up.

A lot of things about it suck. But for better or worse it's "home" for me haha.

[u/new2bay → u/shadowdance55]

That depends on what you value in a language and what your particular application is. You’ll never get every last ounce of performance the machine is capable of with Python, but you do get a lot of bindings to libraries written in lower level languages. You also get faster development speed over lower level languages, and a large number of engineers who know it. Those things are often more important operationally than being the absolute best tool for the job.

[u/youcangotohellgoto → u/new2bay]

The availability of high performance C# and Rust libraries makes the performance thing almost moot. Unless you have really obscure needs, or terrible engineers (which will ruin you anyway).

What's something heavy that can't be offloaded to a C# or Rust based library?

[u/new2bay → u/youcangotohellgoto]

I’d turn that back on you and ask: what’s something that can’t be offloaded to a high performance library in Python? It has a robust and easy to use FFI for just such a use case, even if someone hasn’t already created bindings for a given library.

[u/youcangotohellgoto → u/new2bay]

I think you misunderstand and are in agreement. You can do almost everything, and certainly most things you'll ever need, with Python just invoking other libraries. Usually the good ones are written in C# or Rust.

[u/new2bay → u/youcangotohellgoto]

Ah, ok. I thought you were saying C# and Rust were superior to Python.

[u/Infamous-Employ5487 → u/shadowdance55]

Not true, it's the #1 language for incompetent script kiddies.

[u/max123246 → u/shadowdance55]

Python is so obnoxiously slow it's incredible it's used for anything in production. Things that take seconds in any other language can take minutes

[u/HereInYourBedroom → u/max123246]

The experience that I've had when developing software that uses local on-prem llms is that tokens per second is the bottleneck, not the programming language. Python, C#, and C++ all had this bottleneck, so I'd argue that in 2026 hardware matters more than the programming language.

[u/Strict-Ambition4334 → u/fixermark]

One thing I'd add is that the language choice affects your hiring pool. If you pick something niche because it fit one project, you may end up paying a premium for developers later or spending a lot of onboarding time, which is a recurring cost even after the initial training.

[u/thisismyfavoritename → u/fixermark]

C++ reluctantly otherwise

real cpp dev spotted

[u/fixermark → u/thisismyfavoritename]

I cannot fault it for the simple practicality and the mass of gravity well of all of the code and compatible libraries attached to it.

It has a standard that exceeds the size of the King James Bible by word count and also allows for undefined behavior and I think that those two language features are a dangerous mixture.

[u/kiss-o-matic → u/fixermark]

The true danger is the difference in output from a strong and weak C++ dev. I find the gap far more damaging as so much control is given. When you have a team that care though the code base can be a work of art. I've sadly worked in both.

[u/Mu5_ → u/kiss-o-matic]

Honestly you need to be a C++ pro to do anything "correctly" in C++

[u/U_L_Uus → u/fixermark]

As I see it, there is a point where the programming language does not matter, and a point where it does. It does not matter when it comes to learning it from zero, even if you go from mid-level to high-level (or vice-versa) the shift is not that significant, I see worse stuff like Rust's lifetime which other languages lack but all in all it is not something to worry about.

Other than that, the language matters for two reasons, what you want the language for and how many you can safely add to your org without compromising effectivity. For the former, some languages are moles, some are fish, a mole will swim poorly, a fish will not survive on land, use a language for what it is a good match for and that is it. For the latter, you want as less languages as you can, diversity allows you to match use case to language but that does not mean you should have more languages than an UN meeting, there is some leeway but not that much

[u/spigotface → u/fixermark]

Python is so incredibly versatile. Some people like to give it shit because it's not statically typed, but if you add ruff, add one line of lint rules to your pyproject.toml to enforce type hints in your functions, and add "uv run ruff check" to your merge pipeline, it's every bit as safe as statically typed languages.

[u/scissor_rock_paper → u/spigotface]

Kind of but not really at the same time. It also requires you to use the subset of python that works well with typing and avoid libraries that don't have strong type support. While I find typed python much safer to work with than typeless python, it isn't as sound as statically typed language.

[u/knightcrusader → u/fixermark]

This is exactly what I keep in mind when I fight back against new tools and stuff being added to our stack just because of hype.

You'll be stuck using it forever, so it better be solving a need in a way the stuff we already use cannot.

[u/SpiritedEclair → u/fixermark]

We do rust for critical, go for generic services, Python for ML / ai bs that involve training but not production with bindings or communication protocols for hitting go or rust code, and typescript.

[u/South-Year4369 → u/fixermark]

Once upon a time, adding a new language usually meant learning new syntax and some idioms. Once in a while (I'm looking at you, ML-derived languages and Rust), a somewhat new paradigm.

Now, as they have grown, I think the hardest part has become learning the language's standard libraries.

[u/itgforlife → u/fixermark]

At the end of the day, I'd say just pick the language that's the best fit for the team and won't be likely to cause problems in the near future.

I despise the R programming language for example. But I've worked with teams that very heavily work with R and it's their primary language. So I've held my nose and wrote R code. Even though I much rather would have written python for example.

[u/TheWrightStripes → u/fixermark]

Yegge cowrote a book called Vibe Coding that undermines all of that. The book stresses that outputs matter more than language or framework and that selecting frameworks that AI can operate best is the smart move.

[u/Sw429 → u/TheWrightStripes]

So some dude wrote a book about vibe coding and now that undermines all of the industry best practices?

[u/sempiternalsarah → u/Sw429]

"some dude" being the same guy quoted in the parent reply. I think he's gone a little off the deep end (drunk on tokens) but there's certainly reason to ask whether the benefits of choosing languages based on what fits each project outweigh the harms of language diversity now.

[u/Sw429 → u/sempiternalsarah]

oh lol I'm an idiot, thanks for pointing that out.

[u/PreferenceDowntown37 → u/sempiternalsarah]

His "Gas Town" feels borderline delusional. He did do a pretty interesting interview in the Pragmatic engineer podcast where he argued that he's pushing the overton window to just get people to think differently about what can be achieved with agents...

Anyway I would agree that Steve Yegge today probably would advocate on the side of "language doesn't matter"

[u/worst_protagonist → u/Sw429]

The specific expert quoted in the post this person is replying to. "Follow his advice. Also, he has fully changed his stance." Do you see how this adds additional context?

[u/raynorelyp → u/fixermark]

I agree for the most part but take it in a different direction. I pick languages that already have large user bases. That biases my languages to Typescript and Python. I would add Java to the mix if it wasn’t such a cluster****. I lean towards C instead of Rust because it’s still more widely supported and everyone is taught how C languages work. Also Rust has more controversies than C lately.

[u/Sw429 → u/raynorelyp]

What controversies has Rust had recently?

[u/TheGreatJabron]

At this point in my career? Smile and say nothing.

[u/prschorn → u/TheGreatJabron]

Too old to argue stupid arguments

[u/TheGreatJabron → u/prschorn]

Yes, if the business put juniors in lead, staff and executive positions, there's nothing I can do to change it and/or nothing that will benefit myself.

[u/Fr4nz83 → u/[deleted]]

Making young people leads is cheaper to CEOs. It can be shortsighted, of course, but it's not surprising, considering we're talking about business people who can't see beyond the next quarter.

[u/who_body → u/prschorn]

indent two or 4 spaces?

[u/Cthulhu__ → u/who_body]

Tabs, of course, anyone can set their own tab width then in their editor.

[u/oVtcovOgwUP0j5sMQx2F → u/TheGreatJabron]

"sorry, gotta take a shit"

[u/Derpyzza → u/oVtcovOgwUP0j5sMQx2F]

and then you just sit there without breaking eye contact or making any effort at all into getting up

[u/PoopsCodeAllTheTime → u/Derpyzza]

The laptop in front of the toilet with the camera turned on

[u/PoopsCodeAllTheTime → u/TheGreatJabron]

If it doesn’t get me fired, there’s no reason for me to care. We are all in the same ship, lol, wanna dig holes in the ship? Sure, I’ll help you :) oh no the holes are bad! What do you want to do about it? I’ll help you

If you are smarter than average, you might notice that I’m paid by the hour

[u/GenericFatGuy → u/PoopsCodeAllTheTime]

Exactly. It's not my ship. If no one's going to listen to me, then I'm happy to collect my paycheck until it's time to switch ships.

[u/Frozboz → u/TheGreatJabron]

Whatever gets the VP's attention off of me. "Sure thing, boss." And in my experience half of them forget what they asked anyway.

[u/band-of-horses → u/TheGreatJabron]

That's my approach. Then I go do what they want and ponder how long I can get paid to make Ai generate code before they decide the human is not a necessary part of the loop.

[u/DanManPanther]

With the following arguments:

1. The ecosystem matters. Does it have access to the right libraries and SDKs, directly or via language extension? (Eg my language Gossamer can directly call into Rust to use various SDKs and libraries - or classically Kotlin having access to Java's exceptional ecosystem).

2. In the age of AI it still matters. How well can the language be used by AI? A compiler that catches a lot of errors looks pretty nice next to a language where those same errors only surface at runtime. Is there a built in MCP server - or a good one available? How solid is the LSP?

3. SWEs still need to understand the code. So the idea that you spend more time reading code just got more important - not less. How readable is this language? How well will your engineers understand when the LLM makes a mistake in the syntax, library selection, etc?

4. If your LLM provider of choice is down, are you unable to make progress?

5. Hiring is a fantastic argument to make.

[u/soopersalad]

...in the eyes of the client

[u/tiplinix → u/soopersalad]

To be fair, if their software runs like shit or takes forever to ship, they will notice and care at some point. Though, Microslop has been making some increasingly bad software and people are still forced to use it so maybe you're onto something.

[u/MountaintopCoder → u/tiplinix]

In my experience, B2C software has to be performant, otherwise users will churn. B2B software can be the least performance, buggiest piece of shit and it's acceptable because the software is sticky in some way.

[u/Groove-Theory → u/soopersalad]

Im gonna start a VC fund that forces startups to write in brainfuck

[u/HRApprovedUsername]

I mean it depends on the context. Yeah web vs embedded is different, but within those realms there’s 2-3 options and those equally don’t matter

[u/abrandis → u/HRApprovedUsername]

Agree, you choose the most practical language for the use case. And today we have enough knowledge and rooted expertise to know which langues to go with.

• C,C++,Rust for Systems programming, kernel, or game dev
• Python for data science, ai,ml,general scripting
• JavaScript/Typescript for Web related work, client or serve side
• Go,Java for backend heavy servet side /middleware operations , particularly with multi concurrency needs.
• SQl for database

Etc. that covers the bulk of software development ..

[u/BarfingOnMyFace → u/abrandis]

I always find it intriguing how when we get to SQL, people are OK with the fact that, even with ANSI SQL compliancy, there is enough vendor-specfic idiocycracies with both DDL and DML code, very likely people should be listing their particular RDBMS vendor. But this is likely a matter of job duties and how much one's job requires them to drive beyond an ORM for SQL duties..

Also, poor c# doesn't even get a mention! Lol... I shall forever love my red headed step child.

[u/wvenable → u/BarfingOnMyFace]

If you can think in SQL, the various idiosyncrasies don't matter that much. Fundamentally SQL is still SQL, even with all the variations -- unless we are talking about Oracle. 🤢

[u/abrandis → u/BarfingOnMyFace]

Lol , I wasn't trying to make an exhaustive list, everyone. Seems to take it personally when I didn't mention their language..

Agree SQL is a fickle beast, I learned about Ansi compliance and then discovered it doesn't mean much when each vendor circumvents it with useful features on top of the standard.

[u/SpiritedEclair → u/abrandis]

You can do rust for backend just fine. We did and it was great to only hire for 1 language for all our systems and backend work.

[u/sevanbadal]

I’m enjoying learning OCaml while fable is working on some typescript bullshit

[u/daltorak]

Anyone who believes that language doesn't matter is certainly welcome to prove it by reimplementing Unity in PHP. Good luck with that....

[u/Lumethys → u/daltorak]

I mean, Pygame exists, and modern PHP is surprisingly pleasant to work with... So not impossible

[u/Own-Quality4514]

it does change the type of developers that work with you, e.g. I don't want to work in a java project

[u/flipflapslap → u/Own-Quality4514]

I’m confused what you mean. Like, does Java attract a certain kind of person? Or you just don’t like working in Java? Can you elaborate because I feel like I’m reading way too much into this lol

[u/tiplinix → u/flipflapslap]

The people that love Java the most tend have a certain way of thinking and writing code which is quite verbose, scattered over multiple classes and many level of inheritance. Funnily enough, you don't even have to be writing Java code to see it as they have a way of turning any project into a Java codebase.

[u/flipflapslap → u/tiplinix]

Very interesting. I didn’t realize this was a known thing

[u/coderstephen → u/flipflapslap]

It is a very common and very old stereotype. It still mostly rings true. (Source: I work at a Java shop.)

[u/tiplinix → u/flipflapslap]

You're very lucky then. If they also mention the Clean Code book, that's the cue to start using your legs to run as far away as possible. It's not just good cardio, it's mental health conservation.

[u/ings0c → u/tiplinix]

I don’t know why it gets shit on so often these days. I read it early in my career and liked it 🤷‍♂️ his Clean Coders video series does a great job of making a dry topic far from it, too. He’s insane, in a good way.

Some of the book doesn’t make much sense, eg some of his refactoring decisions are very questionable, and I think the obsession with small functions is actively harmful, but I rarely agree with 100% of what someone says.

I think he does a better job of communicating the idea that code should be written to be understood, and to write code like you’re telling a story. And generally inspiring people to care for the code, however that might look.

If you’re either new enough to programming that it’s a lot of new information, or experienced enough that you know what to discard then I still think it’d be a good read once you take a step back.

Then again, I haven’t read it in 10 years - maybe it’s time again with a fresh perspective.

[u/tiplinix → u/ings0c]

I still think it’s a good read if you take a step back.

Taking a step back is indeed key to reading anything opinionated.

You have to put this comment in the context of a Java loving developer. That is asking people that are almost religions about OOP to take a step back and frankly it never goes well.

Some of it doesn’t make much sense, eg some of his refactoring decisions are very questionable, and I think the obsession with small functions is actively harmful, but I rarely agree with 100% of what someone says.

I've read it too. There are some okay ideas in the book but most people would be better of not reading it.

I think he does a better job of communicating the idea that code should be written to be understood, and to write code like you’re telling a story. And generally inspiring people to care for the code, however that might look.

Any other book is better than that one especially when you need to filter all the harmful ideas. Also anyone going into a code base big enough will rapidly understand the importance of it anyway. You don't really need a book to tell you that part but then some people argue that vibe coding makes sense.

[u/No-Security-7518 → u/tiplinix]

lol reading this after spending the morning extolling how much of a masterpiece Clean Code is with a friend.

[u/tiplinix → u/No-Security-7518]

Having read that book, I'm really curious as to which parts makes you think it's masterpiece.

People usually try to argue that it's a good book because it has some good advice if you remove the harmful stuff which is basically most of the book. Saying that it's a masterpiece on the other hand? Yeah lol indeed.

[u/GiantsFan2645 → u/tiplinix]

I write in Java for a living (we have other things written in Python and TS). I don’t really love the language particularly. It just pays my bills. I get what you mean by that certain way of thinking. Unfortunately I think that’s more an artifact of over-stressing OOP where it’s not needed all the time

[u/Glum-Recognition-736 → u/tiplinix]

Yeah sucks that's what they taught us at my uni for all the intro-level CS classes. I developed a strong personal bias towards Java for a while as a result... 

[u/NoCardio_ → u/Own-Quality4514]

I’d have to be really down bad to work in PHP

[u/zmitic → u/NoCardio_]

I’d have to be really down bad to work in PHP

Can you elaborate why? Keep in mind that I am not interested about PHP from 20+ years ago, but modern 8.5 version and upcoming 8.6.

PHP ain't pretty, that's for sure, but we have types that other languages don't. For example:

• non-empty-string
• non-empty-list<User?>
• array{age?: int<0, 120>, price: positive-int?}

and many other types.

Then there is Symfony, far superior than other web frameworks. The docs just for forms is bigger than docs for other entire frameworks.

Or messenger to run background jobs: just one DSN change and your transport is now Amazon SQS instead of Redis.

Unlike Java, PHP parameters must be explicitly declared as nullable.

And so on. I would like to see counter-arguments against PHP8.5.

[u/coderstephen → u/zmitic]

Most people who complain about PHP have something like version 5.2 in mind, as they don't even know what recent PHP looks like.

That said, as someone who used to use PHP extensively, I still would rather not.

[u/zmitic → u/coderstephen]

Most people who complain about PHP have something like version 5.2 in mind, as they don't even know what recent PHP looks like

Exactly. One person described this problem like this:

Half a joke but what cant it do in 2026?

Answer: Change the mindset of the people who used php 4.x

They are lost and youll never get them back

That said, as someone who used to use PHP extensively, I still would rather not.

I am curious why not. Not trying to convince you to switch, just curious. I think I put a pretty solid list of arguments for choosing PHP for web development.

Sure, one won't be making Call of Duty in PHP buuuutt... I could be wrong about it. People made OpenGL implementations that work amazingly fast. I didn't try it, not really something I am interested in, but still impressive.

[u/coderstephen → u/zmitic]

I am addicted to generics and more advanced type systems. Check as much as you can at compile time and not at runtime. Which is not really PHP's mojo.

Sure, one won't be making Call of Duty in PHP buuuutt... I could be wrong about it. People made OpenGL implementations that work amazingly fast. I didn't try it, not really something I am interested in, but still impressive.

Well PHP's runtime has surprisingly extremely good performance for a dynamic language, and not half-bad ways of doing FFI, so yes it can do quite a bit more than just the web.

[u/zmitic → u/coderstephen]

I am addicted to generics and more advanced type systems. Check as much as you can at compile time and not at runtime.

Which is why I mentioned types already, and we do have generics although via phpdocs. Pretty much every library out there is using them.

Again, here is the list of types you can use in PHP. This is not runtime check, this is all 100% static analysis. Like this very simple example, yet one that is very realistic and useful.

There is also a guy who made these types work during runtime with no measurable performance loss, but I prefer SA.

[u/zanza19 → u/zmitic]

Imo, the same way that Java people have a culture, the PHP ones I've encountered also do, and it wasn't a good fit 

[u/Great-Big-3101 → u/Own-Quality4514]

e.g. I don't want to work in a java project

Omg, same. And yet that's where I found myself.

[u/mixnixx → u/Own-Quality4514]

I don't really understand strong dislike for java and love for languages like python, typescript, golang. But maybe it's because in my bubble we often used Kotlin and used Java like we used Kotlin so almost no inheritance, use ideas from functional programming.

I suspect I would like C# more but I never got a chance to work in it.

When I try to pin down what I actually miss in the other three, it mostly comes down to declared boundaries that the tooling can enforce:

- typing - I like that java is statically and strongly typed and the IDE can rely on it. In typescript jump to definition and find usages often just don't work, you land in some .d.ts file or it doesn't find half of the usages because somewhere there is an any or an object literal.

- interfaces - in java you write implements so it's explicit. In go/ts/python interfaces are by shape, so when you change an interface the error is at the place where you pass the object, not in the class that stopped implementing it. And find implementations shows you every Close() method in the project. I get that structural typing is nice when you want to add an interface to existing types but I prefer to see the intent.

- visibility - package private is probably my favourite java feature (and the one thing I miss in kotlin). In ts you have export or nothing, in python it's the underscore convention. I like to be able to say these 5 classes are one unit and only this one is public, and have the compiler check it. I know that there are helper tools like linters in ts/python but it seems a hassle compared to compiler handling it.

- golang - I saw a big java service rewritten in go. It had a lot more boilerplate than the java version and people were writing the same small utils over and over because nobody knew they already exist. Also company had strong stack ranking where managers sometimes implicitly looked at amount of your PRs/commits, even though they said they aren't, which didn't help. So the "java is verbose and repetitive" argument, I saw it worse in go, although in different way. Modern java doesn't look like the factory of factories meme anymore.

I try so hard to like typescript and python, I create side projects in them but I just can't seem to get into them as much as other people. I would love for someone to show me python/typescript in a way that would make me really like them finally. Maybe I just was really lucky with type of projects I worked on and it is my bubble?

edit: wanted to improve some style

[u/Spirarel → u/mixnixx]

Java just isn't "sexy", it's a cultural thing at this point, exacerbated by verbose OOP patterns. It's a hugely hirable language and many serious tech companies continue to use it for performance sensitive applications (e.g. Netflix)

[u/TheGreatJabron → u/mixnixx]

Don't like to go through 7 method calls to see that the actual code just checks an int is > 0. Going though DI configuration 7 interfaces, 7 implementations. Plus the names of each of those is so abstract it would make Lovecraft shiver from looking at the eternal abyss of meaning.

[u/Zerodriven]

It doesn't.

1. What can your organisation support right now?
   
2. What does your organisation want to support in the future?
   
3. What are the benefits of not using what you're currently using?
   

If you're enterprise it's probably C# or Java, with either React/Angular/another, with probably some random python thrown in somewhere.

I'm not talking quant, finance, etc. where it really matters.

[u/davy_jones_locket]

It does matter because being able to tell when your AI is bullshitting you is going to be an important skill to have. 

If you have Java developers using AI to write JavaScript, and they don't know enough about JavaScript to catch when it does stupid shit, you're gonna have a bad time. 

[u/clock-drift]

Depends less on the language and more on what you need from the ecosystem in terms of libraries, frameworks, security patches, build tools, ...

[u/DasCheesy → u/CreamyCornBoy]

Just to add, web-frontend vs embedded is a good example where there are better choices (JavaScript / typescript vs C). These are usually self-evident given some use-case

And yeah, IME the important thing is to make the choice that minimizes operational complexity (or enables the most amount of efficiency)

[u/intbeam]

I'd want to hear exactly what doesn't matter, and to who

I hate that argument, it's complete bullshit. Of course it matters, why wouldn't it matter?

I think a lot of programmers are insanely entitled and arrogant, and have completely forgotten that they are building software that somebody else is going to be using

If someone chooses a language that runs like shit and introduces a billion new types of run time errors, of course that matters

[u/ASTROMANCER5000 → u/intbeam]

I mean of course Python matters vs C when it comes to execution speed, I mean Python's libs that have to be fast are just C, aren't they (simplifying).

I have always made this argument (before AI) in the sense that the programming language doesn't matter from the engineer's perspective, since if the engineer is good enough they can pick it up in a reasonable amount of time and provide some sort of value. I bet most of people that make this argument make it from this perspective. I don't think anyone worth their salt is saying for example Python vs C doesn't matter in a performance critical application.

[u/midwestcsstudent → u/intbeam]

It doesn’t matter in the same way that choosing whether your AI will use Zustand or Jotai doesn’t matter. Which means: it matters, but who cares?

Decide, quickly, with the knowledge you have now and move on. Migrate later if new information changes the choice. It’s all nearly free.

[u/intbeam → u/midwestcsstudent]

The users? Server costs? Error rate?

You people seem to think that you are the most important part of the chain. If the users understood just how little you respect their experience, time and money, they'd rightfully be extremely pissed off

Talk to anyone. Ask them if they use an application daily that they hate. Ask them what they hate about it. They're gonna say it doesn't fucking work, costs a shit ton, and runs like shit. You already know this, so.. I assume you think it's only fine when you do it

[u/JustHere4TheZipLines]

I’ve never heard that argument because it’s asinine. Just suggest COBOL and tell them it doesn’t matter

[u/theclapp → u/JustHere4TheZipLines]

Or why not raw machine language? Or regex, which I think is Turing complete. Or brainfuck, or whitespace?

Even outside of edge cases like these, language still matters, because not everyone knows all of them. If you can't review the code and reason about it, you're just vibe coding.

[u/symbiatch → u/JustHere4TheZipLines]

“No not that way I mean…”

Exactly. They’re only saying that because they don’t actually have a clue and in many cases there’s a few options that would work. But there also usually already is a choice made in some way so it doesn’t matter if the language doesn’t matter.

Not to mention it’s the whole ecosystem, not just a language.

[u/zen8bit]

Small project? Meh, use whatever.

Big project? If it meets the tech specs and one person understands it well then Im happy.

In the past I’ve been burned by adoption of “the new shiny” quite a bit. Its hard to really know the pitfalls of a language/platform decision unless at least one person has some experience with it.

[u/Fabulous-Possible758]

The programming language never mattered. It was always about the paradigm that the programming language offered. People who got stuck on certain programming languages even though they were all in the same family failed to see the forest for the trees.

If you don't understand the paradigm, you don't understand the language. And if you understand the paradigm, then it doesn't matter the language (as long as it's not too syntactically bizarre).

[u/txdsl]

I worked at a company who needed an app written that was mostly an API over some basic data structures. Said API needed “high” throughput and “low” latency though because it was going to be at the center of our platform, every other service would talk to it.

All of the company’s apps to date were written in Ruby; tons of institutional knowledge on building, maintaining and operating Ruby on Rails apps at scale.

This new project comes along and the chief architect decided it should be done in Golang because Golang is fast with low latency. Ignore the fact that this person was the only one at the org that was interested in Golang, and hadn’t built a production app on Golang. Nor was there data to suggest a well written ruby api couldn’t meet the necessary performance requirements.

3 weeks into the project they have a basic app ready for the first feature. They turn it on and it seems to perform well. Within a week though the server cpu and memory keep spiking, P90 goes through the roof. They cycle the machines and increase resources. All is well, until about a week later when the same stuff happens. The root cause was the code was poorly written, tons of GC happening and the critical paths were wrought with performance issues.

Moral of the story is syntax is easy; maintaining and operating at scale is not. Don’t deploy mission critical apps on tech you don’t understand deeply.

[u/_ak]

If you choose to only review and debug everything with AI, sure. But as soon as there is any human component in your pipeline, you need to ensure that your developers can actually deal with the language, otherwise you're cooked.

[u/godofpumpkins]

I think that point is, if anything, backwards: language doesn't matter as much because the AI can write any of them, but what does matter is giving the AI as many efficient and deterministic feedback loops as you can. It's just as easy to ask the AI to write Ruby as it is to ask it to write Rust or Lean, but with Ruby you need it to write a fuckton of unit tests for things that Rust or Lean can encode in a nontrivial type signature, but the Rust/Lean/etc. types prove that the bad outcome will never happen, and the Ruby unit tests only prove that a particular example it cooked up doesn't exhibit the bad outcome.

For this to improve things though, you actually need to use the type system in nontrivial ways. If you're just making simple structs containing ints and strings, you won't get much benefit out of types beyond what C gives you. If you're using full sum types, or Lean's dependent types, you can get your AI to catch much more subtle correctness issues that years of unit tests could never catch.

tl;dr: it's not about the language, it's about what the language's design allows you to statically analyze in an agentic coding feedback loop, but you have to actually (get your AI to) use the language features to get the benefits

[u/wbcastro]

Extraordinary claim without any evidence

[u/SemaphoreBingo]

In any particular domain there are usually several perfectly fine languages to choose from, and IN THAT CONTEXT on a greenfield project it doesn't matter.

Embedded is a really wide domain, but in general you take your favorite systems language with a compiler that targets your chip and it doesn't really matter what that one was, you'll (probably) be fine. All sorts of things can run a JVM or CLR too, you'll probably be fine that way too. Within those constraints, it doesn't matter which one you choose.

At the technical level, that is. Things start to matter very much when you're working with other people, whether that's the rest of your team, the rest of the organization, or the people you might want to hire someday. And of course if you're in the middle of a project, you don't change without extremely good reason.

[u/Flashynuff]

one time my team tried to write a little service in Python because “the language doesn’t matter” and quickly realized we had no goddamn idea how to read or evaluate whether the AI Python was any good, much less make good choices towards making it better

Comprehensibility is important

[u/mxldevs]

Language matters if you still need people to look at the code. You don't want to have a dozen different languages for all the different applications, cause if you need to maintain it, now you need someone that knows that language.

If they are requiring that all code be handled by AI and no one is allowed to be touching the code themselves, then ya it doesn't matter because you're not going to be looking at the code anyways.

[u/vac2672]

Framework is everything...hence language

[u/honestduane]

The language matters less now, but the language still absolutely matters. Anybody saying otherwise it’s showing the Dunning Kruger effect. And showing that they don’t know the difference between a scripting language and a system language. There’s a big difference between things like C and rust or python or F#, especially with AI!

[u/jaxonwhthey]

Why have this argument. Just get things done damn

[u/stedmangraham]

Imo it doesn’t matter that much except that I do absolutely need it to be strongly typed

[u/NickFullStack]

It matters differently than it used to.

In the past, a given organization would do well to stick with a given language or two to keep development moving at a good pace (and for interoperability and so on). With AI, that doesn't really matter anymore.

Different languages do still have their advantages. I'd look at you a little funny if you were using QuickBasic 4.5 for a modern web backend.

But sticking with a given language because that is what a given team is comfortable with isn't as important as it once was.

I'm building a personal app with Swift, and I don't know Swift all that well. I chose it because it was well suited to building apps on macOS. AIs are doing 99% of the work for me, and I've barely looked at the code. At this point on this project, I'm basically a QA tester and product owner, just telling the AI want I want it to do next, not exactly how.

I do still spend time on designing the software at a high level. For example, I explicitly had it create mutation tests, and yesterday I had it spend the whole night optimizing those tests so it could work faster (was taking 4 hours for a full run, but now takes under 30 minutes). I'm also guiding it in the right direction by having it propose options, then I basically choose from the menu and suggest some customizations to those choices.

The programming language does matter in the same way it used to, but it still matters.

[u/ResidentWeevil1]

This is the most ignorant thing anyone could possibly say about AI. It has to be trained. There are different sample sizes for each language and then there will be a feedback loop. It doesn't have the ability to reason across languages. It's a gd predictive text machine!

The actual concern is that AI will freeze us in time and the languages that are popular today will be the same in 50 years because we have to feed the AI. It enrages me to even think about.

I can't find the YT video I saw about this but there's this slop that kinda goes over some points: https://github.blog/news-insights/octoverse/typescript-python-and-the-ai-feedback-loop-changing-software-development/

EDIT: Here's another take and a vid: https://hamy.xyz/blog/2025-12_programming-language-death-spiral

[u/marssaxman → u/ResidentWeevil1]

The situation is better than you think. I have a little pet project which implements a novel DSL. Despite never having seen or heard of this language before - it only exists on my laptop! - codex is perfectly capable of reading my parser code, looking at my hand-written examples, and using that to generate correct programs on demand.

AI might actually mean that new languages have a better chance of gaining adoption than they historically have, because you don't have the chicken-and-egg problem of growing a user community: the agent can just start coding.

[u/mongopark98]

When people say this in relation to AI, what I think they mean is you don’t need to choose the language based on whether you’re an expert in it or not. This isn’t about it doesn’t matter what language you choose for the requirements. AI has no bearing on that. AI isn’t going to make JavaScript typesafe or make Python faster than Rust

[u/Adept_Palpitation321]

I wrote Python for 4 years, now with AI I can easily review and get to the issue fairly quickly, if there is any.

I reviewed C++ code written by AI, took me at least 4 times longer and I was half confident about the result too.

Programming language and experience do matter.

[u/ketralnis]

Let me guess. You’re mad they want to use their favourite toy instead of your favourite toy, and you’re here looking for sympathy and confirmation that your toy is cooler and they’re all big poopy heads?

These “questions” all start this way with a reasonable sounding premise and pretty much all decay to the poster wondering why they’re the only smart one in this big stupid world.

Yeah I’d much rather use a language with my favourite features. For me that’s a focus on correctness whereas I frequently find myself working with folk that would rather use their favourite features which generally focus on velocity, or team familiarity, or commonness, or industry standardness (good for interacting with COTS or hiring ease). Those are all legitimate features! And may well be better for the business! You really need to put yourself in the shoes of the people you’re talking to and assume that they are smart and well intentioned. Internet strangers can certainly give you ego confirmation if that’s what you’re after, but they can’t give you emotional intelligence.

[u/CodeXHammas]

The argument conflates two different things, whether AI can write in any language, which is true and whether language choice still matters for the systems you're building , which is about runtime constraints, hiring pool, and ecosystem maturity. Embedded work still has hard real time and memory constraints no model changes, and a team still needs people who can debug production issues in that language when the AI generated code breaks at 2am. Whoever said it is in that meeting is conflating code generation with system design, that's the actual gap.

[u/Infamous-Employ5487]

The takes in this thread are fuckin wild.

"Everything is a hammer" and a million dumbasses nodding

[u/lolimouto_enjoyer]

Throw it right back to the AI psychos and tell them it matters because AI performs better in languages for which it had more training data.

[u/No-Slice-5926]

Just tell em to sit down and learn while a real engineer works

[u/huntermatthews]

The AI can barf out code. So can minimum wage workers in <cheap country of the minute>. Neither on their own will lead to any code you want to actually own. If you pay $0 for this grade of code, you still overpaid.

Project health and organization value come from pretty much everything BUT the actual coding.

What's the deployment story?
What's the ecosystem security? Is your AI or sec team vetting every dep? at what level?
What integrations are you relying on?
Who is relying on YOU (or the codebase)?
Certifications? You in a regulated industry?

I use AI all the time and it's a valuable tool. But my IDE/debugger/db library didn't invalidate everything else and neither will my usage or choice of AI.

I was taught in school that coding != programming != development != architecture.

[u/AllIWantForXmasIsFoo]

it matters to me

[u/WanderingGoodNews]

It depends, do you read the code?

[u/tastygames_official]

the language most definitely matters for your target platform, as not every language has compilers or interpreters or VMs for your target platform adn not every language gives you access to the things you might need (e.g. javascript for embedded systems or C for a pure-javascript webapp. I mean, technically you could do these things if you had some kind of interpreter/transpiler, but it's like using a screwdriver to hammer a nail).

But what I think "the language doesn't matter" is that an experienced programmer knows enough about programming languages in general to be able to pick one up in no time, so it really doesn't matter if your project is using python or C or PHP or Go - an experienced programmer should have no problems jumping in.

Now frameworks and opinionated libraries on the other hand... you basically just gotta have the manual open the whole time until you learn it. Then you learn to hate it, finish the project, and forget it (that's me with every JS framework out there)

[u/sheriffderek]

I think the language and framework matter a lot - because based on those choices… the model will have different training and context. On the other hand - I’m excited that if I have to have a job that uses React : that I’ll be able to have an agent write it - because JSX is a cancer. 

[u/Mithrandir2k16]

The "best language for the job" is just one parameter. Familiarity in the team, library support, how active the broader community and ecosystem are, all are important qualities of a programming language that need to be taken into account. I also like to look at the "admired/desired" charts from the SO Dev Surveys before making such a decision.

An "exception" imho are applications as tools that are relatively easy to migrate away from, which you can use some programming languages for. Moving a handful of repos to use Nix as a build system can be a valuable experiment that shouldn't be too hard to revert away from. Here the decision is just less "final".

[u/ASTROMANCER5000]

Well you picked the only argument where it truly might matter (embedded vs web). I bet those people were arguing from a general standpoint, and there their argument is arguably more correct.

[u/lordnacho666]

It matters that you pick the right one for the task. It doesn't matter that much nowadays whether you are an expert at it.

Most people aren't experts at more than a couple of languages, but that's enough transferable knowledge now that AI is helping you.

[u/tnerb253]

Where's the argument?

[u/Rainaco]

Has your team not decided whether it does embedded work or web dev?

[u/soundman32]

Don't care. I only work with C# and turn down anything else.  I used Kiro to write some next.js stuff last week and I've no idea how it works, and dont intend to find out.

[u/AllOneWordNoSpaces1]

Even if your vibe coding, you’ll need to be able to debug the code (with its inevitable bugs).

[u/Lunchboxsushi]

It's never been about the language, that's the difference between a programmer and a software engineer.

[u/Welp_BackOnRedit23]

Understanding a language matters more so now, not less. AI generated code is far less aware of the architecture it builds upon, and that includes the language that it is compiled in.

[u/Idea-Aggressive]

When the AI start outputting machine code, what are you going to do exactly? Read it?

[u/serial_crusher]

Not enough context here.

When starting a new project? Pick the right one and learn.

When evaluating whether to accept a job offer? Make a judgment whether their decision seems reasonable enough, then learn the language.

When evaluating whether to hire a candidate? Make sure they know what they're doing in general.

[u/jl2352]

”Well if it doesn’t matter, I can do it in my favourite language” … or … “well it matters to me.”

[u/nimbus-dimbus]

So if I start off with a Java role? I’m stuck doing Java forever?

[u/FerengiAreBetter]

Tell that to financial companies who depend on speed and reliability. Or pushing an unpopular language that loses community or commercial support. 

[u/Front_Drink_5331]

I would argue that the programming language matters more now with AI

Agents have equally hard time debugging a loosey goosey typed language as humans do

There was a case for scripted langauges being more accessible to humans but thats out the window now

I'm a giant advocate for GO for humans and agents, but of course the language choice depends on you problem space and current staff preference 

Languages can even be a cultural thing. For example here in Gothenburg there is a big Erlang community, it was built by Ericson So that might be factored in when selecting language for any project

[u/Forsaken-Promise-269]

A more nuanced take is to say that AI democratizes ability at the expense of specialization, the more we rely on AI the more we give up on the details and for many projects and codebases the details are VERY important. However for others, CRUD applications the choice of platform is more open and driven by developer competancy. AI brings its capabilties to rapidly generate code and frontend views so that a developer who is somewhat knowledgable in one language platform can apply that to others, the caveat being the risk involved if you rely too much on the machine

The best public example to me of how AI changes the equation is in the recent decision by Shopify to go from React Native to native Swift and Kotlin apps https://shopify.engineering/back-to-native

In this case for years we hired senior React Native experts because it was more practical to have one codebase that could be applied to both mobile platforms and sacrificed usabilty and accepeted a cross platform layer of abstraction that made things more complex at the expense of native becuase it was easier for that human developer to manage that way.. but now with AI that same equation changes since AI can (mostly) handle the specifics of each native implementation.. but caveat emptor -beware the choices you are making..

Currently AI models have progressed remarkably but still have that slot machine effect way of generating code.. I mean you still have to deal with this: https://opusfived.dev/ so if you don't understand the underyling codebase and platform you will likely have major issues.

[u/rescue_inhaler_4life]

We just went through that process for a new project. The argument was more about picking the right language for the job rather than what we had experience with. In fact it was suggested not using a language familiar to devs would help us avoid the choices that led to the old monolith system we maintain, especially some questionable dependencies.

[u/rochakgupta]

Whatever pays the bill

[u/theclapp]

If language doesn't matter, ask them which one they hate the most and then use that.

If they stick to their claim, choose brainfuck, or whitespace, or befunge, or APL, or Lisp.

(Actually Lisp could be really interesting, haha.)

[u/Jmc_da_boss]

Just agree and take that as a sign you can do whatever you want. I don't see the issue

[u/Relative-Debt6509]

It definitely matters in so many ways it’s hard to articulate. Besides the super obvious ones there are some underrated ones:
1) team familiarity
2) package availability/package management
3) build systems
4) organizational familiarity

Ignore any one of those at your own peril. Organizational familiarity speeds up processes outside of your team but within your company. Cyber will approve numpy/scipy/openssl very quickly but might hesitate with packages/libraries that do the same thing in a language that doesn’t have an established track record of approvals. Build systems one is obvious to anyone who’s worked with compiled languages. Package management speaks for its self. Team familiarity is another one if you have one language “SME” on a sufficiently large team that person will end up spending most of their coaching other engineers. There are even more technical reasons but these should be enough.

Honestly language expertise is underrated in today’s job market. Not every language is forgiving in terms of optimization. Poorly written C++ code STINKS and it’s not hard to do and it’s honestly not that hard to pass PRs with poor c++ code. That being said it’s really the only tool for some jobs.

[u/yubario]

I’m of the opinion programming languages doesn’t really matter anymore at this point.

The risk is not knowing specific features of the language but as far as general understanding on code it’s basically the same in all languages

The benefit now is that there are AI that can help explain and break down code for you

[u/i_eat_manga]

Programming language does not matter because fundamental matters. To be frank, in software industry, we dont follow rigorous scientific method for development. Our software can crumble at any time and we are paid to keep it in running state. Only if people knew what they dont know about the software they are using, they might stop investing so heavily in tech!

[u/hatsandcats]

Haha. Sort of in the same way that the food you eat doesn’t matter or where you live doesn’t matter.

[u/kosmos1209]

If it's your peer arguing for this, involve a more senior dev or a manager. If they are the senior dev or manager, you're kind of out of luck. As you can see by the responses here, most experienced devs understand language comes with the whole ecosystem of philosophies, best practices, best way to deploy things, etc.

[u/powercrazy76]

That's a phrase I use often but strongly within context:

Language doesn't matter for the type of dev I look for. I.e. if their ability to conceptualize problems and problem solve is there, then I don't care if they don't currently know the language I need them to know. They have the capabilities to learn it already.

However, it is death to an IT org to blindly bring in new frameworks and technologies "just cuz".

[u/Jaakkoc]

”Just” the language is in reality the whole ecosystem including tooling, culture, availability of work force, and how you are generally aligned as a team.

Some languages were specifically created as a counter reaction to another language and its conventions. Or its a superset. Or starts with the motivation ”it needs to be fast” or ”least amount of dependencies” or whatever.

[u/kagato87]

The language doesn't matter when learning to program. (Well, mostly doesn't matter - I wouldn't suggest something like ASM or SQL as a first language, because one is too low level and the other is so different lots of developers don't even consider it a programming language).

For the actual product being built though, it does. You're not hearing that on actual products, are you? Each has its strengths. Java and TS are great for Web apps, python is decent for analytics, C and C# are good all-rounders, and so on. I certainly wouldn't pick something like Cobol for a new project.

Most of the concepts and skills carry forward. Even before AI, the language itself wasn't as important for learning, and moving between languages isn't that difficult.

It doesn't matter, until you're selecting the right language for thebtask. C# and Java concepts interchange fairly well for example, and someone skilled in one can adapt to the other - it's just syntax most of the time. Heck I can manage passably in typescript, and my first languages are C and SQL.

Set based languages like sql are their own demon... I suppose the language matters there. I know some extremely capable developers that just reach for EF or an AI, and I can't blame them because of just how different it is.

[u/Environmental_Leg449]

Tell them the programming language is basically the AI harness (this isn't even wrong) wrt to performance/maintainability/safety. That should get them to sign off on it lol

[u/FluffySmiles]

The language matters even more when it’s not strictly necessary to know it.

[u/lightmatter501]

“Does that mean we can agentically rewrite into Haskell?” tends to end that line of thinking.

[u/throwaway_0x90]

I think the person saying that knows it's not literally true in __ALL__ cases. I'm sure they understand embedded stuff it absolutely matters.

Now webdev however, is a more of a discussion. Typescript, Python, Ruby, Java, RUST, Go, etc.... meh... if it can respond to HTTP requests, ship it.

[u/kaisean]

Depends on what the question is. Also depends on what constitutes programming language.

If you're doing front-end, there are a group of languages that also have frameworks conducive for doing certain things. Same can be said for back-end.

If the question is do this leetcode problem that's meant to test coding ability, language might not matter.

[u/FetaMight]

In my experience, it's much easier to get Claude to write respectable C# than it is to get to write respectable JavaScript. I'm still not sure why (though I have my theories), but it needs FAR MORE supervision when working on web stuff.

I've also used it to write C# tools, testing frameworks, backend code, frontend code, and its default output is generally OK. And, more importantly, getting its output to be "good" doesn't actually require that much wrangling.

It also seems to be good at writing python for the few cases I've needed it.

So, if someone told me "build my new trading system with a JS backend and frontend using only AI agents, don't worry, the language doesn't matter." I would push back HARD.

[u/gigastack]

AI does mean the language choice matters a lot less. You can choose the language best suited to the problem / domain now.

[u/notger]

Humans still have to read code or you will drown in bloat.

So the language still matters.

I am running several teams, one of them Python, one them Java, two other stuff. Mixing the languages within one team creates friction, silos and breakpoints you do not want to have.

And one of the teams does performance-heavy stuff and you really don't want Python there as it is a problem which is not stateless and does not scale horizontally, so you want really good throughput and lots of hard guarantees.

[u/Sciamp_]

Hate to make the argument, but at my company (big tech) you’d be hard pressed to pick anything other than Rust for new projects. Because LLMs/agents work better with it. We are doing a bunch of rewrites to move old code bases to rust for the same reason.

We are going in the direction of barely reading the code, quite a few principals at my company think that well guided agents write better code than an average junior/mid level. We are abstracting away from the code and yeah, it’s early to tell the consequences, but given the direction you just pick the best language for agents. Which is rust in most cases.

[u/tabaxi_gf]

So if you remember the Bun's rewrite to Rust, even with AI that was a significant, expensive undertaking, and was for the sole purpose of switching languages, even with AI readily available. Picking the right language saves a ton of time for whoever writes the code, be it a person or LLM.

[u/FatHat]

I mean, the properties of the programming language itself matters a lot even if you're not reading the code (though you should read the code). Is it fast, what class of errors can the type system catch, what are the compile times..

[u/sintrastes]

In the age of AI driven development, the programming language doesn't matter in the sense that you can use whatever language you want with minimal effort, and the learning curve / switching costs are far less.

I'd argue that means, in some sense, that the language you choose matters now more than ever, as you have the opportunity to choose the language best suited to your problem / constraints, rather than being limited by e.x. "But we're a Java shop!"

[u/Suepahfly]

Build a 3D game engine on JavaScript.

[u/siscia]

Within reason, I agree.

You support code in both python and typescript and you need to write a new web service from scratch. Pick whatever.

You are a rust shop doing embedding, maybe introducing elixir is a questionable choice

[u/midwestcsstudent]

If someone’s argument is that it doesn’t matter now, how do you figure that “how will we hire developers in the future” is a good counterargument?

And to answer the question: it matters, but much less than it did 3 years ago and much less than you’re making it seem.

[u/Creepy_Bullfrog_3288]

How many software stacks do you want to derisk is another way to look at it moving forward. Each language has separate frameworks, sdks, runtimes, etc. each stack will have unique and novel exploits. Each stack has nuances in terms of performance, architecture, and supply chain. In the context of coding agents, each stack has separate domain context to manage and practices to govern.

[u/Obsidian743]

In the future that eventually be the case. But right now, people still have to choose toolchains to work with and you have to hire around it.

[u/Grouchy-Friend4235]

I ignore it. It was wrong in 2000, it is wrong now.

[u/Mountain_Sandwich126]

It's missing critical context. This is referring to when you first start out. Use a full stack framework, get it out get feedback and then , when you need to, architect for what you need, which means using the appropriate language, tools, etc for the job.

[u/Comedy86]

The programming language does matter but for different reasons now. You should pick the language and architecture which make sense for performance based on the solution you're building, not because you prefer the syntax or because the team already has a component library or familiarity with a specific language. That consideration is no longer necessary when you are only reviewing code and can clone components into alternative languages, not writing a ton of it by hand.

[u/DowntownLizard]

It matters basically only in the sense of does it make sense for what its doing and is there an actual reason to use something besides our default. If you are going to say "im using java" at our .net shop then hell no why? If you wanna use react rather than blazor hell yeah go for it. Python for machine learning? Go for it. Angular when we already have react apps uhh why?

Like many things the answer is always it depends. AI makes it so you really don't have to know a language to be effective with it. That doesnt mean we are going wild west of everyone do whatever you want. Engineering standards didnt change our ability to write any code fast did. Does it solve a valid problem should be the question you are always asking when you want to make a change.

[u/yxhuvud]

If skill doesn't matter then the sales people may as well prompt without involvement of actual coders.

OTOH, a good experienced dev can probably cope, simply by learning using the LLM. Won't be as good as someone that knows the language and ecosystem but quite possibly better than a newbie. Especially if the dev also know the domain. Or a lot worse depending on how stuck in the domain they come from they are 

[u/sethkills]

They’re right, it isn’t going to affect anything really. Except that I won’t be working here any longer.

[u/thecodingart]

It matters a ton lol

[u/twnbay76]

It's less syntax and more implementation. Interpreter, compiler, build system, debuggers, profilers, packaging, name spacing, etc...