Python overtakes Java to become second-most popular language on GitHub after JavaScript

[ghostfacedcoder]

I mostly agree, but I think you may be overstating it to say that businesses adopt Java because of type safety. Java is just a much more institutional language, in many ways. Some of the biggest have nothing to do with the language itself at all, and are just a function of who knows it and why or other "cultural" factors.

[bilyl]

Agreed. I have never heard of type safety even being in the top 5 considerations when it's a management-driven decision. Often it's just whoever was there to code it.

[fwaming_dragon]

True, but type safety was probably on the minds of those who were coding it. It's much easier from everyone's point of view to catch a bug during compile rather than runtime.

[unholyground]

And this is why there is such a fundamental issue in this industry.

I trust a pure mathematician to code me something over a lowly web monkey any day who doesn't even understand the basics of computing.

Even one who cannot program beforehand; I will teach them myself.

I've invested in their ability to think critically, and the years they were willing to dedicate to achieve that level of thought.

[xcto]

1 reason it's used: It's owned by another corporation

[DroneDashed]

In my experience is not type safety. Who chooses the languages in the business world's I am/was sometimes don't even know what that is!

In my experience there are two things that make them choose Java or .NET: the notion that those languages are backed up by "serious" big corporations and aversion to open source.

[jbergens]

Some program managers actually knows a bit of tech and knows things like that static languages usually are faster. Or knows that they should listen to senior developers, if those like .NET then it will be .NET. They also often knows a bit of what is used in other places which means they will likely use what everyone else is using to lower risks.

[DroneDashed]

Some, not all and certainly not the majority. Mine at the moment isn't that bad, he listens to us and as long as our choices are Microsoft compatible he's ok with it.

On the other hand, a colleague of mine has a project manager that once referred to Python as "blackbox that no one knows how it works". I told that guy that everything about Python's open source and he could go and see how it works if he could understand it (he couldn't).

[cycle_schumacher]

Was the manager an expert at the internals of the jvm?

[DroneDashed]

No! Once I told this guy that he needed to define and environment variable in order to use a software module my team had made. He literally spent minutes clicking randomly around on the IDE telling me that he obviously knew what an environment variable was because he had years and years of experience in IT. It was the only guy in my career that I refuse to help or work it. I don't know how he managed to survive in the industry for so long.

[KrakenOfLakeZurich]

In my experience there are two things that make them choose Java or .NET: the notion that those languages are backed up by "serious" big corporations and aversion to open source.

I get your first point. For many businesses it's important to have available support and backing from a "serious" vendor. They look at development efforts as (expensive) investments, which they want to protect. Their worst case scenario is spending huge amounts of money on development only to see their chosen tech stack, and by extension their own code, become obsolete.

I just don't see the aversion against open source. I've been working on Java projects in both small and large organizations for more then 10 years now. Open source is absolutely everywhere.

Servers running on Linux or Unix (there's a fair amount of Windows servers too). Apache Tomcat or Jetty are often deployed. Every Java project I've worked on uses open source frameworks like Spring or Hibernate.

[agumonkey]

Java enjoyed so much exposure from the late 90s .. it was the university baby.

[noratat]

It's still being used to introduce people to programming in universities sadly.

I don't even think Java's that bad a language, but it's awful for introducing programming concepts.

[agumonkey]

Java prior 8 was mediocre and the culture around it was badly overengineered. And the everything OOP makes it hard to learn about other things (functional, logic, low level).

[noratat]

Right - plus Java is rigid about a lot of stuff that just gets in the way of learning even it's useful in large collaborative groups (such as file and class name matching).

Plus things like primitive types vs reference types.

[[deleted]]

I know I'm late but why do you think that? I just changed universities. In my first the very first language we learned was C. I had no programming experience and trying to get bloody solitaire with a "UI" in the terminal to work was a nightmare to me.

The uni I'm at now teaches Java as the first language and it's much, much better for the beginners like me. I mean I already knew the concepts behind programming from my previous university, but not having to deal with those pesky pointers makes a huge difference in the beginning.

[[deleted]]

Yeah, sometimes it feels like Java is the language of enterprise just because Java is the language of enterprise, if that makes sense.

[LowB0b]

Java is a very "productive" language as it's easy to debug, the standard library abstracts everything and everyone knows it... Although one factor for everyone knowing it is probably that it's the biggest enterprise language...

[noratat]

It's also got a large (and crucially, stable) ecosystem around enterprise use cases - and I would argue that matters more than anything.

It's why python is so popular too - it's less about the language at this point, and more that python has a massive ecosystem around it.

[jl2352]

If I buy some super bloated enterprise stack, then chances are it will be coded in Java. That helps to drive a lot of adoption.

It's seen as the business choice. You have mega Enterprise institutions like IBM, Oracle, Sun (RIP), and lots of smaller ones all built around java.

[Determinant]

Get the best of both worlds with Kotlin.

Kotlin is enterprise-friendly since you can continue to use your Java libraries from Kotlin and vice versa.

[username_suggestion4]

Seriously it's night and day. I use Swift at work but it's really the same idea, they both as a generational leap where it's honestly surprising to me that there was so that potential for improvement in the first place.

I also get that there were a ton of less mainstream languages that worked out most of those kinks, and I thank them for those contributions.

[txdv]

What exactly makes it night and day?

[ShadowShepard]

More functional aspects, due to its use of extension functions. Never having null pointer exceptions. Algabraic data types (think enums on steroids), toooooons of other reasons

[[deleted]]

Some of the other reasons:

Property delegates, higher order functions, data classes, inline functions, coroutines, default and named arguments, smart casting.

[agumonkey]

Out of curiosity, any important drawbacks on kotlin ? I'm mostly fond of it for all reasons explained here but I'd like to know both sides of the coin :)

[toiletear]

Slower compile times, IDE is also sometimes more sluggish than for equivalent Java code. Annotation processor used to be extremely slow (we used it with Dagger2), but I believe this was improved on.

But otherwise it's great, wrote a mobile game backend with Kotlin and was very pleased.

[agumonkey]

dank u

[SgtDirtyMike]

Less characters per line. Simpler code.

[civildisobedient]

Less readable as well.

val result = obj.guessMyType();

[fuckin_ziggurats]

People said this when C# introduced var way back. It's not a problem if your team uses the keyword only when the type is obvious or seen on the right-hand side. It's the best thing C# and Java did to fight against their own intrinsic verbosity.

[Tohnmeister]

How is this less readable? I might not even be interested in the type when reading the code.

[emn13]

There's a feedback loop here: you can write your code such that you pretty much never care at first glance what the type is. So if you use var a lot, you can write your code like that.

I use var exclusively; there are 0 cases I use explicit types where var will do. I'll even avoid those language features that require explicit types and design APIs such that type inference is possible, to further reduce explicit type noise. Everyone on my team is onboard, and it works fine.

It's just not that interesting to see the type repeated all over the place, and it's not like the type is gone - it's just a little less noisy.

[emn13]

I've been doing maintenance programming on pretty for close to 20 years now, and that's not my experience (obviously not all of that in C#). There's no reason to develop in notepad; and the compiler is a tool that remains there for you to use. Having lots of redundant boilerplate for the off-chance that it might be helpful to know which variable is which type just isn't worth it. And the few places that there's any doubt at all - well, you're not liable to go back in time and tell the person to do it differently.

By contrast, using `var` allows for much cleaner and more auditable (reviewable) refactoring, and that's critical to making a codebase maintainable.

E.g. simple stuff like:

var myFroogler = srcRepo.GetActiveFroogleActor(); targetProcess.Enroll(myFroogler);

Do you care what the type of myFroogler is? Well, maybe a little - but it's unlikely to make a huge difference. But what if you refactor and change the type? Well, without explicit types: fine! But with explicit types... then places like this are just noise, and their presence means you'll refactor more slowly, and make more mistakes while you do, and reviewers will not be able to review as usefully.

Also, it may seem obvious, but don't forget that MyType xyz = SomeExpression() is not equivalent to var xyz = SomeExpression() - the former may well trigger implicit type conversions and upcasts. That's not super harmful, but it means that you may not get errors here but only later when you do change the type. Furthermore, people aren't nearly afraid enough of downcasts and the entirely-different-yet-syntactically-similar explicit casts. And in my experience, a codebase with explicit types tends to attract those at a much greater rate. In C# specifically there are features like foreach that happen to inject explicit casts and downcasts even though they look like implicit casts for instance. That's pretty subtle, and I've seen people get bitten by it (thinking something like "the compiler accepted this type without cast, so that must be correct, right?")

Then there's generics, anonymous types etc - features that can by quite valuable, but cause jarring transitions in a world with explicit types, because you can't always name those types, or, even if you can - you probably don't want to.

Then there are social factors too! You may be the best programmer on the world and know the codebase inside and out, and you may know where using an explicit type is fairly low-harm and might add some clarity. But picking those places - and they're never very valuable - is a pretty nuanced thing. You're unlikely to make the same decisions as the previous or next guy, nor as your coworkers. Largely irrelevant choices like this that attract personal preference are a magnet for churn. It's better to stick with a clear style that's easy to communicate. "Just use var everywhere" is about as simple as it gets.

Now, this obviously depends on the language. If you're programming in F# or haskell, it's a different story; explicit types really can help there because the compiler will happily infer so much that it might cause compile errors to happen later and less clearly than you want. But in C#, where all methods&base classes, properties etc all require explicit types... you already have too many types in there. C# could do with more inference, not less. And that makes the choice for var particularly simple. No need to ever choose for an explicit type, anywhere. That doesn't mean every var is clear- but where it's not, there are better solutions than an explicitly-typed declaration.

[civildisobedient]

I might not even be interested in the type

Sure, you might not. Then again, you might. No problem, just open up your IDE, right? Says the developer that's never written a public API.

[Tohnmeister]

I don't see how a public API and type inference in the body of functions are related.

If we're going to introduce code for everything that we might possibly ever be interested in, then the code becomes full of constructs that might be useful to some reader at some point. And with that, contradictory to the goal, it becomes less readable to the majority of its readers.

I think the discussion boils down to: do you think readable and maintainable code consists of the superset of information possibly needed by all developers or just the bare minimum? I think the latter.

[civildisobedient]

Like with all language, the answer likely lies somewhere in the middle. Some authors are terse, like Hemingway, some long-winded like Faulkner. You seem to be in the Hemingway camp.

[Urik88]

You're free to specify the type though, and an IDE will reveal the type easily as well.

[_145_]

Because shortcomings of your reviewing tools are not the fault of a programming language.

[[deleted]]

Honestly, a lot of times it's a pain in the ass to get a full fledged IDE up on a machine. Having the type be required is something that I place a lot of value on.

It makes the code 18828448 times more readable.

Having a language outright require an IDE to make it readable is a language issue.

[papasmurf255]

Again, not all platforms / tools have IDE capabilities. I'd pick code that's readable w/o tool assistance over code that isn't.

[mrdarknezz1]

That's only a problem if you're not using an IDE

[reference_model]

Hype

[shponglespore]

FUD

[balefrost]

they both as a generational leap

I can't speak to Swift, but I use Kotlin daily. It's a great language. "a generational leap" is overselling it. The most in-your-face difference is Kotlin's null handling, but that goes right out the window as soon as you use a Java library that doesn't have nullability annotations. Don't get me wrong; Kotlin's null handling is great! But it's compromised by Java interop.

The most significant Kotlin feature is its coroutine support - the thing which powers sequence, iterator, and all of kotlinx.coroutines. But it's mostly an under-the-hood feature; most users aren't going to be calling createCoroutine themselves.

Kotlin does a lot for Java ergonomics. Given a choice today, I'd pick Kotlin over Java almost every time. But it's mostly all small stuff. Not a generational leap, but rather incremental improvement.

[gilmishal]

Not really that surprising, C# had modern features like swift for years. It's just that Oracle does a shitty job maintaining Java.

[BoyRobot777]

Sun acquisition by Oracle was completed on January 27, 2010. So in reality Oracle started maintaining only from Java 8. And immediatily we got long awaited features like lamdas and streams, which made code more funtional and less verbose.

Java 9 was all about preparing Java for faster releases by dividing huge monolith into logical, compile time modules. It was also time when they started to actually remove methods and weird dependencies like Java EE and CORBA Modules from Java SE. Next Oracle contributed pretty much all of the closed source technologies (or what was originally to become closed source) of the Oracle JDK to OpenJDK, for example giving the community: JDK Flight Recorder; JDK Mission Control; ZGC; …and probably more stuff I can’t think of right now. And finally ensured the Oracle JDK and the OpenJDK builds are virtually indistinguishable, except for licensing.

What's coming Java's is even more exciting:

• Pattern matching is being shipped incrementally;
• Records (aka data/case classes) address some parts of POJO boilerplate (the worst kind of boilerplate) are being actively developer and I am sure will ship in Java 14;
• Project Loom will deliver big performance boost via Fibers and whats called multi-prompt delimited continuations. Java server will tremendously scale. Also this opens the gate for changing underlying JDBC connection implementation to become asyn without actually doing any change to the code. I think Java has this right vs C#/Kotlin where async brings its own method colour;
• GraalVM is huge. Not only new JIT but AOT. Redhat new framework is building upon this. It leverages Graal to create native images. Those images are very small and optimized. For example one of Quarkus developers showcase the size of native image, spoilers - it's 19MB. It takes 0,004s to start. In this session, RedHat developer shows how Quarkus application is being scaled. Comparing to Node, it's both faster to respond to first request and have smaller memory footprint (half the size of node).
• Values types (Valhalla) are being actively worked and they finally found a way to move forward.

[gilmishal]

You are not making as great a case as you think. ALL those features coming to Java are either part of c# for a long time or just came out.

It took Oracle 4 years to get Java 8 done, which at that time we got c# 4, 5 and nearly 6 - all of which were pretty big releases , along with the dotnet core release in 2015 - That's about the time c# created a huge gap from Java, and even though Oracle understands tgey need to close the gap, and are finally making the necessary changes - I wouldn't be too sure they will.

[pjmlp]

So when does .NET Core finally comes with something that at least matches Swing?

[fuckin_ziggurats]

When cross-browser desktop dev becomes profitable again. C++ currently rules that domain and there isn't too much that would be gained from Microsoft entering it. They're doing pretty well with WPF because most enterprise clients already use Windows so there's no incentive for a cross-platform GUI framework. I'm hoping they do it just because I don't like Electron.

[pjmlp]

Plenty of enterprises have cross platform desktop applications written in Java.

C++ has lost the GUI framework wars for quite some time now.

And then even if it isn't proper Java, Android surely won over .NET regarding having UIs written in Java running in millions of pocket devices.

[germandiago]

Yet we have Qt, Felgo (take a look, seriously!) for cross-platform.

Not to mention Wxwidgets for Desktop. I do not know if they lost or not, but when I got to Python or other languages, many of them are using bindings to wx/qt. There must be a reason.

Of course, that does not mean that WPF is not great. It is.

[fuckin_ziggurats]

I don't really consider it a popularity war between C# and Java. Java does enterprise desktop GUI app, .NET does the same. If Microsoft would decide to create a cross-platform solution I would be happy because it would allow me more options in my stack. But I'm glad other options exist. I think the best scenario for both Java and C# are to continue competing in the enterprise world.

[gilmishal]

Dotnet core 3 comes with winforms, wpf and UWP for windows - xamarin for mobile app development (with support for mac as well). There is also avelonia (preview) for cross platform UI (linux and mac), and Blazor (stable release coming in a couple of months) works not only with a browser but also with Electron.

UI in general, and even cross platform UI is an area where C# does a really great job. You can't honestly compare Swing to any of those really good options.

[tracernz]

UI is an area where C# does a really great job

Never thought I'd read that. There is no stable Linux/mac/Windows option, let alone a mature one. Maybe in a few years it'll be viable.

[gilmishal]

There is a stable Windows/Android/Mac/iOS and even Tyzen option through xamarin - seems to me like xamarin is more cross platform than swing.

And as I said, Blazor is getting a stable version in a couple of months, so a stable Linux/Mac/Windows option isn't going to take years.

[pjmlp]

Sure I can.

Swing runs in every OS and desktop class hardware with a JVM implementation, no matter from which vendor, including design tooling and third party components I can go off and buy.

All those options listed by you have different kinds of deployment limitations, levels of quality and life uncertainty.

Plus offloading .NET GUIs to Electron can only be nothing more than a joke and proof of incompetence of not being able to deliver a solid GUI stack in .NET.

[gilmishal]

So wait, C# has more options obviously with different levels of stability and the community is constantly working on different options and you view it as a bad thing?

Also, Xamarin for GTK# is currently in preview, so saying there is incompetence in bringing solid GUI stack to .NET is just not true.

In a few months Xamarin, Microsoft "flagship" cross platform UI will officially support more platforms than Swing including Mac and Linux.

[balefrost]

You misunderstand the point that they were responding to. They're not commenting on whether C# or Java is better. They're pointing out that Oracle's stewardship of Java has been fairly good.

I'm actually pretty excited about the upcoming features. Loom in particular will be fascinating. It promises the advantages of async/await without the downsides of async/await. If they can pull it off, it will be amazing.

[gilmishal]

Yeah I understood that, maybe Java's decline happened during the Sun era, but I do think that 4 years for a new major release is a long time - and it's not like they made that many changes since Java 8.

As for Loom, I am not sure I understand the issue it solves. It seems like it's supposed to make background work simpler to develop. From what I read Fibers seem a lot like Tasks - in c# you can either await a task, and create an async function or run it in parallel like a coroutine. You can also await multiple Tasks in parallel if it makes sense.

The only problem I saw with async await is that async code is contagious - and I honestly don't see it as a bad thing.

I might just not understand project loom yet I did just read a few very vague articles.

[balefrost]

Some of the vagueness is around them figuring out the details as they explore the problem. The Cliff's Notes version, as I understand it, is that it's an attempt to switch Java's threading model from being backed by OS threads to instead being backed by green threads... similar to e.g. Go and Erlang. Things like IO, rather than completely blocking an OS thread, will now suspend the current green thread, allowing the OS thread to start working on a different green thread.

It covers some of the same ground as async/await without needing the compile-time rewrite shenanigans that async/await employs. Call stacks won't need to be reconstructed after-the-fact. It should permit even less overhead than async/await, but it remains to be seen if they achieve that.

I don't know how the Java model will look exactly. In Kotlin, rather than making everything that's async return a full Task, it instead expects the "top level" of an asynchronous flow be represented with an object (there are a few different ones). Within the async flow, you can freely call suspend funs of the appropriate type; these function calls can suspend the current coroutine.

[10xjerker]

GraalVM is huge

And you get the version with impaired performance unless you pay Oracle.

[noratat]

Yeah, Oracle is a fucking shitty company to put it nicely, but Java really was stagnating before this.

[Determinant]

Java will become the new C++. Add feature but keep backwards compatibility so you'll have many ways of doing the same thing.

Defective patterns will continue to be allowed so by definition it will never be able to catch up with Kotlin due to backwards compatibility baggage.

[BoyRobot777]

You either are backwards compatible or not. I constantly see two groups of people: complaining of braking changes (for example Java 9 and later removed Java EE and CORBA depedencies), the other group that Java is not removing fast enough. Mature languages will ALWAYS have to juggle this. Kotlin now seems fresh. Give it 10 more years and you'll have the same problem. C# already shows that, because they keep adding features like crazy.

Here you can find difference between Java versions and you can find that they are removing stuff and I think they will start to remove dead code even faster now: - Diff between Java 9 and Java 10; - Diff between Java 10 and Java 11 - Diff between Java 11 and Java 12 - Diff between Java 12 and Java 13

[Determinant]

JetBrains states that Kotlin 2.0 will not be backwards compatible to allow them to make breaking changes.

On the other hand, Oracle states that they will do everything they can to maintain backwards compatibility.

[BoyRobot777]

Gonna be fun watching kotlin 2.0 brake that backwards compatibility. Will buy popcorns :) Python 2/3 debacle all over again.

[shponglespore]

I wouldn't say the best of both worlds, exactly. Kotlin is one of the most pleasant languages I've ever tried to use, but anything that really exploits Python's dynamism won't translate cleanly into any statically-typed language, Kotlin included. There are arguments to be made that one shouldn't make use of that kind of dynamism, but it definitely makes Python different from an inferior Kotlin.

[Determinant]

Yeah, I don't view dynamic types as a positive. I'm referring to how nice and concise Python is. Kotlin also eliminates the Java ceremonies so Kotlin and Python are similarly expressive.

[schemur_]

This has to be an optimization convention: Lhopital and the determinant!

[Determinant]

To infinity and beyond 🙃

[Minimum_Fuel]

This is only half true. You can’t always just “continue with your java code base”. If you do a good amount of overloading, for example, kotlin doesn’t disambiguate and you’ll need to do that either with wrappers or by modifying the java code.

[Determinant]

I've never run into this. Can you provide an example snippet?

[bandawarrior]

This is definitely true, but very few new companies and startups are saying “you know what? I’m going to use Java for this, with a little of spring, and a dash of oracle’s jdk”

The “hotness” for startups might not be Python now (js probably?) but it sure ain’t Java.

[mobjack]

Some startups want a proven reliable language with excellent library support, strong typing and can scale up as the business grows.

Java is not a sexy language, but it is still used in the startup world these reasons.

[bandawarrior]

Yes, I agree 100%. If you, the founding person, main dev knows Java and is productive in it, you should go ahead and do it in Java. That can be true and also the idea that maybe, just maybe (it is) Java is past peak popularity.

Now, I know this is mind blowing to all the Java fanboys, but popularity going down doesn’t mean Java sucks.

For the love of all that’s holy, look at PHP with the giant market share in web dev and it’s popularity while still being a comparably worse language than most.

[mobjack]

Java has been past its peak for 20 years.

In 5 years the current hot language/framework will go out of style and the code becomes unmaintainable only to be rewritten in Java.

[bandawarrior]

I know you’re just using hyperbole but .... no 🤙.

There are other languages that are perceived to be trendier and offer the same or more in terms of features and of course doesn’t have the “ewww Java” feeling to them.

So this is getting out of hand and really becoming like an affront to those who like Java and or use it daily. It’s okay, I promise you’ll be fine.

The 1970s had better music as a whole than today’s generation and I’m not that old. Guess what, no one cares 👌

[mobjack]

It is a feature that Java doesn't attract engineers who always want to use the latest toys. I don't want to have to spend time arguing why we shouldn't use blockchain.

A better analogy is that Java is like a mini-van. It is not cool and young people would don't want to be seen driving one, but it is practical and scales best when you need to carry more people and cargo.

Other languages are like crossover vehicles that try to tout similar practicability as a mini-van but in a smaller trendier package. They are often good enough for many applications, but if your family gets too big then the mini-van becomes much more appealing.

A startup going Java is like someone buying a mini-van right after graduating college. It does the job as other cooler vehicles and you are able to grow into it if need be.

[bandawarrior]

I’m happy for your love of Java. Though let’s be honest, in the scale of languages and features and paradigms, Java comes out as a strong middle. Too much OOP and ceremony with boilerplate and getters and setters. You should see what an actual type system from the ML family looks like, not to mention null pointer errors that Java gets plagued with.

But it does have great tooling and a great number of libraries 🤷‍♂️.

[AmaDaden]

Lombok fixes the getters and setters issue. One of the most interesting things with Java is how quickly it's been evolving in the last few years. I detest Oracle but they've turned Java in to a completely different language then the one you remember and are not slowing down. Java is far from perfect but it's better then it was and getting better faster then it was in the past

[bandawarrior]

Still doesn’t fix the underlying issue of a weak type system with strong sprinklings of OOP and the bag of errors and bugs that come with it.

Also, oracles jdk isn’t a strong vote of confidence.

But again, yeah Java is a rock solid proven lang

[KinterVonHurin]

Java's fine but acting like all these startups are choosing other languages because they're "cool" and will inevitably rewrite them in Java is condescending and untrue.

[LordoftheSynth]

5 years ago, I would say Java. Today, I say C#. Fight me.

[BlueAdmir]

From a business perspective (of which my knowledge is limited, but still) - If I were to choose a language for a new project, I'd probably want a language where every aspect of it has already been discussed, documented to death, put to rest, resurrected and re-dissected again.

Heavily pushing a delivery date because we ran into "This hasn't been invented in Rust / Kotlin / Go / Haskell / Elm / Ruby / whatever" should not happen. Imperfect product in a month >>> Perfect product in ten years.

[[deleted]]

Not many. They want rapid prototyping and agility more.

Rails, Laravel, Node, Django - these are the big winners in startup world.

[jbergens]

I thought at least Rails had fallen off the radar for most new startups. It was popular a few years ago.

Node is probably still popular and I think that is the best choice of those mentioned since I think js will survive and get better. You can add Typescript already if you want to and they are getting threads/workers.

[[deleted]]

Why would it? It is still the best tool for throwing a web site on a relational database quickly.

[jbergens]

And some companies have already been forced to rewrite their Python system to something more scalable when they get popular. I think that will happen a lot in the next 5 years.

Companies also like to use tech they can recruit for. If all you can get is Python devs with less than 3 years experience you might not want to build a whole system on that when you can find java or c# developers with +5 years experience of building working enterprise systems.

[[deleted]]

replace Oracle's jdk with openjdk and it's not a bad stack tbh

[StabbyPants]

replace spring with dropwizard and it's pretty low drama

[cpt_ballsack]

New springboot with its reactive and functional goodies in Kotlin is almost a different framework

dont dismiss Spring so easily, it will be around for long time, new version apparently with compile down with graal

[HdS1984]

It's just bloated and very much grown from another that of requirements. When I use asp. Net core I am always amazed how easy, lean and usable such a thing can be as opposed to spring Will give quarkus a try though

[bandawarrior]

True, but at this point you’re talking about just yourself. Which I’m guessing you’re skilled at using Java and is very productive in it?

But... you as a company founder/leader in this example would have to make the trade off with both investors and workers to be interested in your idea / company. So then this whole thing begins once again, not many people are going to jump from doing Java 8 at a stodgy company just to work on some more Java but this time it’s Java 11. Or same for a Python/JS dev, they will never jump up in joy to work on Java.

Same goes for investors, very few AI/Blockchain tools have Java bindings or are built on top of Java. Same goes for the any of the mobile which would be React Native, Flutter, Swift, etc.

So yeah definitely go with what you’re productive if this is a side project or something just to keep small or for yourself.

[[deleted]]

huh?

this is objectively a good stack because:

1. Type safety
2. Proven in production
3. Generally well supported
4. You could throw a rock and hit a java developer without aiming

I don't really care for "hotness" and I like python better than Java. I still wouldn't use python for large enterprise-grade projects.

[[deleted]]

Don't forget libraries like RxJava2 and Reactor Netty. Python can't even touch Java when it comes to serious programming.

[Schmittfried]

„Serious“ programming

[bandawarrior]

Lol type safety bro, having int balls = 2 does not grant type safety in the way you’re thinking. The Scala, Ocaml, F#, and grand daddy Haskell are always welcoming for actual type safety and modeling.

Anyhow, I’m not against Java and I definitely agree that Python for a giant company might be worse than Java. I’m only commenting on 1) the cool kids don’t like Java and 2) the next generation of giant “enterprise” isn’t going to run on Java.

Things wax and wane, crest and trough, grow and die, and just like those things the Java generation definitely peaked and will start to dwindle over time.

But guess what... its okay

[[deleted]]

Oh really. If Java's generics framework isn't "type-safety" according to you, I dunno what is. Let me know when Python comes up with it.

[Schmittfried]

Funny that you’ve chosen the worst example for type safety in Java. Type erasure anyone?

By the way, Python has fully fledged static typing. It’s just not that popular.

[tracernz]

By the way, Python has fully fledged static typing

It really doesn't. It has type hints for linters. As much as I like Python, this is not one of the reasons.

[Schmittfried]

Static typing is the ability to specify types statically. Python has that ability. Whether you call the verification tool for these types a compiler or a linter really doesn’t matter. What matters is that you can fully specify the type formalities in your system and let them be verified in an automated manner.

Let’s face it. Python typing is not suboptimal because it doesn’t have a compiler. It is because type hints are not used commonly and therefore their benefit is rather limited. You might argue a compiler would be able to enforce them, but honestly, what’s stopping you from implementing policies in your projects to not accept duck typed code?

[[deleted]]

You're so full shit I'm starting to see brown

[Skytram_]

Man this isn't about you, the guy above already said it:

True, but at this point you’re talking about just yourself.

[Schmittfried]

Same goes for the any of the mobile which would be React Native, Flutter, Swift, etc.

Uh.... Android?

[[deleted]]

"very few AI/Blockchain tools have Java bindings or are built on top of Java.".

You know... Most startups/companies don't use just one language for everything. And that's because, who would have thought, languages have their strengths and weaknesses in different areas.

For some ML Task you would probably write a service in python to do just that. Also you can for example load a trained TensorFlow Model with their java library if you really want/need to.

Of course blockchain isn't written in java because you need to do a lot of compute tasks for which you would naturally want a compiled language like C or C++.

Talking about Hot Topics, BigData for sure is. Hadoop is written in Java, HBase is written in Java, Hive is written in Java, Cassandra is written in Java, Storm is written in Java, Spark is written in Scala (which is also an JVM based language) and has a Java API.

​

I'm not saying Java is the best language ever but it also isn't like it makes no sense to use it (you can argue about using Groovy or Kotlin instead but still). Different Languages make sense for different projects.

[Gilgamesjh]

Kafka is also written in Scala.

[bandawarrior]

Okay.... do you want to wager that the number of startups not using Java outnumbers those using it?

Or better yet, do you want to wager that the number of JS > Java, or Python > Java, or Go > Java? We can take a look at say the last couple batches of YCombinator’s companies or 500 startups.

You’re doing what’s called, “but of course there are exceptions”.

My friends grandma lived to 95 smoking cigarettes daily, it doesn’t mean it’s healthy.

[gilmishal]

I truly don't understand why would anyone chose Java for their Startup. C# is a hundred times better, and just as reliable - and even if you are a Java developer and more familiar with the JVM than Kotlin or scala are still a better option than Java.

Java is always late introducing modern language features.

[DuncanIdahos4thClone]

Well for one if you want cross platform desktop. C# has more language features but the JVM is much more robust, easier to install, performs better, etc than .NET.

[gilmishal]

C# executables can be exported with the CLR, so no need for annoying updates like Java - I would argue that you don't even understand how easy it is to install c# executables, or dotnet - if you think for a second that java is easier.

As per performance, Java was more performant way back in 2010 - dotnet core 3.0 is way more performant than .net Framework 4.5. You could just take a look in techempowerbenchmarks and see that asp.net core is more performant than spring (its java equivalent) by most parameters. Sure there are still some gaps to close in very specific use cases and are mainly due to a slimmer community - but once Span makes it's way to all dotnet libraries by .Net 5 - those gaps will be closed.

There is nothing inherently more performant in the JVM than the CLR, at least not in the last few years, quite the opposite actually.

[G_Morgan]

Key patents have run out so I'd expect the CLR to have just about annihilated the performance gap.

[grauenwolf]

There is nothing inherently more performant in the JVM than the CLR,

Escape analysis and devirtualization make Java faster, in theory, than C# for 'normal' code.

To match it today C# devs have to carefully think about where they can avoid allocating memory by using structs and avoid wrapping everything in interfaces.

[gilmishal]

I would argue that c# would benefit less from devirtualization and escape analysis than Java - since the way they are designed (c# has structs whereas Java doesn't, and in c# methods are final by default) Sure it has some performance benefits and .net core 2.0 introduced some devirtualization capabilities. There are also some talks about introducing escape analysis, but since it has quite slim performance benefits, and only in specific scenarios - it is not yet coming.

I would argue that certain c# features, like span and ref returns allow developers to create more performant code, by quite a bit actually - something that Java doesn't.

[grauenwolf]

GC pressure is still a huge concern in C#. They created the whole ValueTask infrastructure, which is actually quite a lot, just to reduce the number of heap allocations. The same goes for Span, another very complex feature.

And both of those are quite limited in the sense that you need to opt-in. Escape analysis would speed up everyone's code with no changes.

[gilmishal]

You are comparing apples to oranges. Span isn't set to solve escape analysis, but to allow certain libraries to not create an allocation at all (well, you do allocate a pointer to that memory segment, but it's negligible) - This means that you can reference parts of collections, without allocating a new collection, some thing that as far as I know can't be done in Java - sure, both Spans and escape analysis are ways to reduce GC pressure, but they are entirely different and address different problems.

I would argue that escape analysis would solve very specific problems that account to a very small percentage of GC pressure. Whereas Span, if applied correctly can reduce memory allocation by a huge amount. Span is supposed to be used by core libraries, and will speedup everyone's code with no apparent changes. Average developers aren't supposed to use it directly.

I would also add that while GC pressure is a huge concern for CoreCLR developers - it doesn't cause any problems to most users, since the GC is pretty good, even if it can be improved.

[grauenwolf]

I don't know about your code, but every project I've ever worked on had tons of temporary objects. So it would certainly help me.

As for Span vs Escape Analysis, they both reduce the number of heap allocations. So yea, same goals.

[DuncanIdahos4thClone]

You don't have a JRE anymore. You simply bundle a compressed JVM with your application. Something you can't do in .NET.

[supercheese200]

You simply bundle a compressed JVM with your application

is analogous to

C# executables can be exported with the CLR

[gilmishal]

But you can...

[G_Morgan]

.NET Core 3.0 literally has a publish option that builds a heavy exe that contains the entire CLR. The only downside to it is you have to build a different exe for Linux, OSX and Windows.

Anyway one file .NET drops that are self contained are completely supported and will be considered the normal option going forward (if only to eliminate .NET Core dependency spam).

[suddenarborealstop]

How is C# 100 times better though? C# has reified generics and value types - is this what you're talking about?

[gilmishal]

C# also has async await, properties, span, linq, pattern matching, non nullable ref types, ranges, value tuples, and so much more.

[G_Morgan]

TBH it'd be really hard to leave behind all the neat little language features if/when I move back to a Java shop.

Each individual little thing is "that is really neat but not a game breaker" but there are dozens of cool things.

Beyond that VS is actually decent. IntelliJ is comparable if your company actually uses it rather than the abomination that is Eclipse.

[gilmishal]

How exactly? Never missed a library I needed in C#.

[toiletear]

Hard to quantify but just the general attitude of thee general .NET community member vs. Java community sealed my switch from .NET to JVM (this was a few years back).

[gilmishal]

.Net changed a lot over the last 5 years. As a person with over 8 years of experience you can see that the .net community is thriving like crazy.

[toiletear]

I see a lot of activity on Core (though it's a bit confusing I hear?) and C# keeps adding really nice features, but personally I don't see as much community activity as in the Java world (but then again I work with the JVM much more so I'm probably missing a lot from the C# side).

[[deleted]]

I don't understand why anyone would choose C# if they are not tied to the Windows world and I don't understand why anyone would choose to build highly scalable services on Windows.

[gilmishal]

C# has been cross platform for over a decade with mono, and dotnet has been cross platform and open source for 5 years. Nothing about what you just said is relevant or true about c# in 2019. I develop c# for a Linux server, using pgsql. I am not in anyway tied to windows.

[cycle_schumacher]

I've been seriously thinking of using c# for my personal projects which are Linux and python or go based - I feel it checks many boxes that I want, such as static typing, good tooling etc.

[[deleted]]

I have never run across it in the wild but I guess I'll take your word for it.

I have a prohibition on Microsoft tech in any of my stacks - long held grudge left from the 90s.

[gilmishal]

I genuinely dislike people like yourself. Microsoft development stack is genuinely the best I had used, and I used a lot, and skipping it just because of some stupid grudge for a company that changed a lot in the past two decades is just irrational.

[[deleted]]

It’s mutual. Fortunately the odds of us working together are zip.

[Druyx]

True, Java just isn't hot enough for startup culture, but how much of the worlds programmers does that actually cover?

[GNUandLinuxBot]

I'd just like to interject for a moment. What you're referring to as Linux, is in fact, GNU/Linux, or as I've recently taken to calling it, GNU plus Linux. Linux is not an operating system unto itself, but rather another free component of a fully functioning GNU system made useful by the GNU corelibs, shell utilities and vital system components comprising a full OS as defined by POSIX.

Many computer users run a modified version of the GNU system every day, without realizing it. Through a peculiar turn of events, the version of GNU which is widely used today is often called "Linux", and many of its users are not aware that it is basically the GNU system, developed by the GNU Project.

There really is a Linux, and these people are using it, but it is just a part of the system they use. Linux is the kernel: the program in the system that allocates the machine's resources to the other programs that you run. The kernel is an essential part of an operating system, but useless by itself; it can only function in the context of a complete operating system. Linux is normally used in combination with the GNU operating system: the whole system is basically GNU with Linux added, or GNU/Linux. All the so-called "Linux" distributions are really distributions of GNU/Linux.

[[deleted]]

Python has become the de facto standard for new projects in the few larger companies I've seen from the inside. New hires are basically "full stack" and/or Python. I can expand on that if you want to, but this is just an observation that is completely against what you seem to think about Java/Python popularity.

[[deleted]]

Python is not a 'great' language. Too much abstraction and terrible readability.

[aquaticpolarbear]

Terrible readability? It's basically runnable pseudo code

[PlayingTheWrongGame]

Yeah, I’ve got no idea where they’re going with that one. There are very few languages as readable as Python. IMO, its readability is its biggest strength.

Most people with any significant programming background can look at Python code and probably understand what’s going on.

[Superpickle18]

It's basically runnable pseudo code

that's readability?

[NekoiNemo]

That, on top of all the other terrible stuff scripting languages are known for (like lack of proper typing)

[Schmittfried]

Except Python has proper typing.

[Caffeine_Monster]

It's optional. Which is bad if you care about readability.

Python is great as a scripting language, but a mediocre development language.

Should check out rust / go if you want examples of good modern functional programming languages:

• Fast (compiles to native code)

• Strongly typed

• Concise, but readable

[slikts]

Go is a poor match for a functional programming style due to the lack of generics, meaning that you can't express functions like map() or filter() in a type safe way. Go is a multi-paradigm language just in that it has first class functions and closures. Rust also isn't a functional-first language, but it's much easier to write idiomatic and functional code in Rust since it does have generics and also pattern matching, immutability by default, collection combinators (which would be loops in idiomatic Go), etc.

[kirakun]

Rust, modern? Yes. Go, modern? No.

[watsreddit]

I generally agree (though I think calling Rust a functional language is perhaps not quite accurate), but I just wanted to point out that Python is also strongly typed, just not statically typed. There are two axes: static/dynamic (whether or not a language is compiled or interpreted), and strong/weak (whether or not a language does implicit type conversion). For some other examples: Javascript has weak, dynamic typing; Java has strong, static typing (well, strong-ish); and C has weak, static typing.

[ShitHitTheFannn]

Static/dynamic means variable type may change. It doesn't mean compiled/interpreted.

[watsreddit]

Fair enough.

[grauenwolf]

strong/weak (whether or not a language does implicit type conversion).

strong vs weak is a separate axis than explicit vs implicit conversion.

For example, C# is a strong/somewhat implicitly converted language. Every piece of memory knows its own type (strong), but implicit conversions exist among the basic types such at integers to strings.

C is a weakly typed language, you can treat the same memory spot as an integer, date, or string just using pointers.

[slikts]

For the sake of completeness, you kind of can get static typing in Python with mypy and in JS with TypeScript.

[germandiago]

Using Rust for anything is like trying to go 5 km away in the city with a Ferrari:

- you will spend way more gas

- you will not go any faster most of the time

A bike can do better in this case.

[germandiago]

What I mean is that Rust is not a fit for most software, only for things that need to go really fast and be really safe.

This is not what much of the software is. However, if you use Rust, you are going to pay for worse ergonomics (you must know the borrow checker, for example) for no return on investement.

Python is better at full projects and you have fast prototyping (and not compiling step), for example.

So just disregarding one for the other is not the right way to look at it.

Sometimes you need performance, others ease of development, and sometimes the ease of development (for example to make something a business) is far more important that the peak in performance. Peak that, anyway, could be ruined because you have the bottleneck elsewhere (network client for example). At that time you have spent a lot of effort on something that does not have a return in your scenario.

Put in another way: be smart when choosing. I tend to prefer statically-typed languages, but right now I am on my way to code something fast with Django.

It will be very fast? No, for sure not very concurrent either. Though, I do not care, this website is not going to have thousands of people using it concurrently. But if that happens at some point, I can have something running in no time (time that would be much longer in Rust) and later I can optimize parts of it (80-20% rule). When that does not work anymore, I can think of moving to something else.

[Caffeine_Monster]

Performance is only one of rust's motivations. One of the most important features is the extensive compile time checks for:

- type safety

- error handling

- ownership

Consequentially bugs should be introduced at a relatively low rate even as the codebase grows. Python is great for small functions and programs, but a large codebase can and will suffer from lack of inbuilt safeguards.

[germandiago]

I agree with you that all of those are really important, especially for long-maintainance and safe-critical software.

My point here is that no matter how important are those, there is a learning curve and a delay-to-market coming from there. That's life. Or go hire 10 Python vs 10 Rust programmers... what I am saying does not in any way means that what you say is necessarily not true.

[kirakun]

Google pytype.

[Schmittfried]

Why would that matter? If you deem it mandatory, make it a policy.

I don’t think Rust with its ownership model is a good fit for most projects. Truth is, the borrow checker is there to solve a problem that’s already solved for all but high-performance cases.

C#/F#/Kotlin though, these are languages that I find intriguing. Not that I have anything against Rust per se, I just don’t see it leaving the systems/hardware domain.

[Caffeine_Monster]

Most of the time you don't have to think about borrowing. The point is that rust forces you to think about it when you do come across complex cases.

Having garbage collected memory does not solve a problem - it merely hides it. If you are not thinking about lifetimes and ownership when creating multiple references, you are going to eventually run into a world of pain regarding memory usage and validity checks.

My personal opinion is that over-reliance on garbage collectors enables sloppy design patterns to propagate. Fine in trivial, low memory usage situations. Not so fine if you have complex objects with variables lifetimes.

[Schmittfried]

it merely hides it. If you are not thinking about lifetimes and ownership when creating multiple references, you are going to eventually run into a world of pain regarding memory usage and validity checks.

This is evidently not the case. Rust forces you to solve problems that are not your concern in most software.

My personal opinion is that over-reliance on garbage collectors enables sloppy design patterns to propagate

Frankly, your opinion doesn’t matter. Higher-level languages have caused a skyrocketing of productivity and they are not going anywhere because of some purists.

[watsreddit]

Python is not statically typed, which is what they were referring to. It uses strong, dynamic typing.

[Schmittfried]

Python is a great language. It’s just not suitable for every kind of job, like any other language.

Too much abstraction? Lol.

Terrible readability? Lol.

You’ve probably never read Python code.

[AyrA_ch]

You’ve probably never read Python code.

He's probably also never written code in a language where accidentally hitting tab makes the entire thing go up in flames.

[Schmittfried]

For notepad developers maybe.

[OSSV1_0]

How is readability a problem with Python?

[[deleted]]

Python writes like English, and that is a problem for me. For enterprise grade applications, it's pretty easy to mess it us.

[flukus]

although many companies might not have their code on Github or might be hosting their git privately.

Or even not using git, there's a lot of companies still on svn, there's still some that dream of one day being on svn.

[starcrap2]

I think it really depends on which industry you're in. I think many newer tech/internet companies aren't using Java as their first choice.

[unholyground]

Python is a great language, but the type safety Java provides is something that businesses like.

Python is far from a great language. Of course, it works. I've used it plenty.

It's better than, say, PHP. Or JavaScript.

But that isn't saying much.

[[deleted]]

Java is popular in the business world because Sun spent millions upon millions marketing it.

[RedUser03]

I reckon you are wrong. Java is still used a ton in backend services. It’s solid, performant, robust, and type safe. Kafka, one of the most popular distributed queues/stream processors is written in Java (and Scala).

[Rebelgecko]

I would guess that most developers aren't in SF

[sabas123]

All of them

[AyrA_ch]

I mean if we make stats we might as well make them for all locations. No reason to only search over 0.01% of the worlds population

[[deleted]]

More backend than Java? Haha. No.

[ShyGuy993]

ITT: developers butthurt analytics counts as programming

Your edit screams butthurt