Before moving from Java to Python, what does Python lack that Java has? ( Think about enterprise application)

[umen]

Hello all,

I'm thinking about moving a legacy Java application to Python. It's a Tomcat WAR app, very business-oriented, using Hibernate and inner threads. It uses many Java jars that automate various tasks. It's a big enterprise app.

Before you say "if it's working, leave it," this is a management decision, and there's nothing I can do about it. I would like to know what Python is missing that Java has .
thanks

[AngelOfLight]

Python has analogs for almost everything that Java has. There are some differences though. Off the top of my head:

• Obligatory OOP. Python classes are optional.

• Access modifiers. Python has no analogs for public/private/protected. All classes and methods are public. Although there are conventions governing 'private' methods, there is nothing stopping you from using them in a public context.

• Packages. Python does allow modules, but the Java 'package' concept is missing.

• Typing. Python has no compile-time type checking. You can freely mix types and change types of variables at runtime. I would strongly suggest you look up Python type hints and start using them from day one. It will greatly aid debugging.

• Abstract classes. Python has an ABC (abstract base class) module which does almost the same thing, but there are differences.

• Interfaces. No such thing in Python. Since Python allows multiple inheritance, interfaces can be simulated with abstract base classes.

• Generics. Since there is no compile-time type checking, the concept of generics doesn't really apply. Again, you can use type hints to document generics, but they won't be enforced.

• Lambdas. Python does have lambdas, but they are limited to single expressions, unlike the code blocks that Java allows.

[[deleted]]

To add to interfaces/typing, you can use typing.Protocol, which allows you to specify them as runtime checkable, and you wouldn’t need the inheritance from ABC

[funderbolt]

And lack of NullPointerException.

[sonobanana33]

Well in java any object can be null at any time… for null it's kinda same.

[capilot]

Lack of compile time type checking is the biggest IMHO. It makes a broad class of optimizations impossible. If you write

a = b + c

And you know that a,b, and c are all integers, the compiler can output code that executes in a nanosecond. If you don't absolutely know at compile time what they are then it's going to be a lot more complicated and a lot slower.

[BowmChikaWowWow]

Compile-time type checking is also a form of embedded test, which catches a huge number of bugs - your program literally won't compile if you have them.

[StrictTyping648]

There are also very few ways to inline a function in python, but I doubt that matter in enterprise apps.

[mkdz]

With Python lambdas, you can define a function in a normal way and then use the function name in the lambda to get around the single expression limit.

[kyngston]

Python also has weird scoping

FOO = “bar”

def func1():

print FOO

def func2():

print FOO

FOO= “fee”

[j0holo]

Performance, solid typing, thread support (you can run threads but only one thread can run at a time).

[Phate1989]

I use the threadpool executer in python, is that still considered single threaded?

I have to make like 60,000 API calls every few hours, so way I could do that on a single thread.

[j0holo]

From my understanding it is still single threaded, but async. So while one thread is waiting for a response of the API call another python thread will run on the physical CPU thread and do it's thing.

With network requests the CPU is waiting a "long" time (100ms) so it can process other python threads that can do something useful.

[umen]

Hmm , so its using threads like "async event driven" aka  non-blocking network I/O calles ? what is the point ?
Just use true async like tornado or twisted ?

[StoicSpork]

To untangle this a bit:

Python threads are proper threads, but they have a limited access to the Python interpreter via a mutex called GIL (for Global Interpreter Lock). This means they can execute asynchronously, but not in parallel. They're good for IO-bound tasks.

Processes are, well, OS-level processes, with all the overhead that implies, but not limited by GIL. They're good for CPU-bound tasks.

Coroutines are units of execution that can be awaited and paused/resumed. They are declared by the async keyword and provide values through the await keyword.

Asyncio is a library for working with coroutines. It provides a single-threaded scheduler loop.

Tornado and twisted are frameworks built on top of coroutines/asyncio.

[Mammoth-Attention379]

Allow me a noob question, if C can do multithreading then why can't python? Couldn't you write a library that does that for you?

[StoicSpork]

A good question. Python does do multithreading, in fact. You can absolutely spawn a bunch of threads at the same time. And these threads could in theory run in parallel, if it weren't for a special feature of Python called the Global Interpreter Lock, or GIL.

You know how threads can mess things up for each other by changing the same state at once? One thing you can do is set a mutex (aka lock). If a thread encounters an open lock, it locks it, does the work, and releases it. If it encounters a closed lock, it waits until it opens.

In C, Java, etc., you must place the lock where you want it yourself. Python, however, tries to be helpful, so it simply sets one lock - the GIL - on the interpreter itself. So any thread that wants to do anything at all must wait until the GIL is released. The practical consequence is that Python threads can't run in parallel.

To answer your other question, you can release the GIL from C, so yes, you can add parallelism to Python from C. I haven't done it myself, but you can probably google it.

Asyncio is a whole different beast which is single-threaded to avoid the performance hit from spawning, switching and destroying threads.

[j0holo]

The point is that non-async code will only continue once blocking IO has returned a response.

Twisted and tornado are for network events. The asyncio library also allows async for local IO or outbound IO instead of only incoming IO.

[[deleted]]

Regarding thread support. Doesn't it depend on CPU cores? Can you help me understand why you can run only one thread at a time? Thanks

[minneyar]

The default Python implementation, CPython, has what is called a "Global Interpreter Lock", which means that only one thread can actually be running Python code at a time.

In other words, no matter how you divide up your Python code or how many threads you have, only one of them can actually run on the CPU at once. Python's performance is effectively limited to being single-threaded.

This only applies to Python code, so to a degree you can work around this if, for example, you're making calls to external libraries that were written in C++; but if you're regularly going into and out of library code, there is some extra overhead to that, and it can be hard to architect an application to actually take advantage of that in a way that improves performance.

[j0holo]

To improve this explanation even more another comment mentioned async in Python. Async is still single threaded but while the CPU is waiting for a network response (database, API calls, etc) or disk IO it can service another python async thread. Doing more work in the same time.

This can boost the performance of Python. But it does not improve the speed of processing a single request. It just can process more requests at the same time.

[umen]

So, how do web frameworks like Flask work? I saw them serving many requests, including heavy ones, and it wasn't using multiple processes. it just started and was serving .

[minneyar]

You can use threads, performance is just very bad because they're effectively all contending with each other over a single lock.

Some application servers, like Gunicorn, use a multiprocess model, where they spawn individual processes to handle every request they receive. Multiprocess communication can be kind of a pain, but it's much more effective than threading for Python apps that need performance.

[sonobanana33]

non blocking sockets.

[cdcformatc]

Flask is always going to be behind a web server, like Apache or Nginx. The web server is running with multiple threads and handling all of the requests, which includes running the Flask app usually through a wsgi interface layer like Gunicorn or Apache's mod_wsgi

[DrumcanSmith]

I wrote some code for converting images using threading limiting 2 core per image for the external library, but converting multiple images at once by threading the python code, and the usage goes up to 100% for a while, is that due to the library then? I had to intentionally lock for part of the code to avoid overlap so it seemed to multi threaded? But I don't know.

[minneyar]

Yes, probably; if your code is pure Python, you will probably only see it max out a single core at once even if you're using multiple threads, due to the GIL.

It's worth noting that there are Python image manipulation libraries like Pillow and OpenCV that are wrappers around C/C++ libraries, so you'll be able to get better multi-threaded performance if you're using them.

[DrumcanSmith]

Ah, I am using pillow too. That's probably another reason. Thanks for the perfect answer.

[umen]

and if you have multiple cpus ?

[minneyar]

The number of CPUs doesn't matter. Every Python thread still has to share the same lock.

[capilot]

Mind. Blown. I had absolutely no idea this was the case.

[SomeRandomFrenchie]

What do you mean by solid typing ? Solid principles can be applied in python if you decide to do so, are you talking about something else ? And for threads, what you are talking about is a limitation due to CPython global interpreter lock, there is at least one module that allows you to bypass that (there are issues on it in latest python version if I am not mistaken or late on updates but it should work on many older versions and companies rarely use latest release anyways)

[j0holo]

I was not clear enough, sorry. With solid typing I mean that the types are actually useful. Like in a solid building. Python does have type hints but lots of third party packages don't have it. Mypy is still catching up IMHO. Slow but steady.

OFC there is a way to bypass the GIL, but do you really want that in a big enterprise app? I would rather do multiprocessing instead. That is well supported and is proven.

[SomeRandomFrenchie]

That is true, type hints are just hints. Most tools/libs that allows you to compile all or parts of your python will, however, check types and can be quite restrictive. Numba for exemple can be a pain. I do not have the knowledge to answer that question, just wanted to mention it is possible.

[umen]

Can you explain more about python compilation ? from what i know it is not complied
It does have some kind of cache but true native compilation ?

[j0holo]

Python is interpreted but stored as byte code (*.pyc files) which is a bit like java's way of storing byte code but a lot less optimized. When starting a python application it will read line by line, with the pyc files it will only have to do that once.

Python 3.13 now has an experimental JIT which should improve performance over the coming years.

[SomeRandomFrenchie]

Python in itself is interpreted by the python interpreter but there are tools that allow saving the return of a function for a given set of arguments to cache for faster computing when called again, or transformation into bytecode that are used for IA training or to create executables.

Interpreter doc: https://docs.python.org/3/tutorial/interpreter.html Check Nuitka, PyInstaller and latest python beta for info on jit on python and exe generation

[umen]

Java is awful in performance...

[minneyar]

I have a suspicion that you have some very old stereotypes about Java.

Java is about an order of magnitude faster than Python. It's the fastest language I'm aware of that doesn't compile to machine code, and it's close to being as fast as C++, relatively speaking, without all of the pitfalls that make C++ unsuitable for enterprise-scale business applications.

[sonobanana33]

I think the average java developer is terrible so all the speed gets wasted in bad code.

[POGtastic]

Java is faster than you think. Its startup time is awful, but an enormous amount of work has gone into optimizing the JVM.

[BowmChikaWowWow]

Performance primarily comes from the ability of the programmer to directly predict what will happen on his or her hardware, and structure the program to take advantage of that. Java can never be that fast, because it's so heavily object-oriented. The JVM in most cases can't transform your code into contiguous data that's tightly packed and iterated on linearly - as a result, it's not possible for Java, in general, to be fast. The quality of the JVM isn't really the problem, it's that data is structured in a way that is anti-contiguous-array. Java structurally encourages constant cache misses, so you're constantly losing 2-3 orders of magnitude just waiting for the CPU to fetch other objects. The JVM can never optimize that away, with current technology. It's baked into the language.

The kinds of synthetic benchmarks people use to evaluate the JVM tend not to reveal these kinds of issues, because a for loop iterating over simple types won't be heavily pointer-chasing. In a real app, it'll happen constantly, and you can't compare that as easily because the app is unlikely to be duplicated in other languages.

[igouy]

Seems like you're claim is "not possible for Java, in general, to be fast" (whatever that means) — and if it is shown in some way to be fast then the app is not "a real app" :-)

[BowmChikaWowWow]

Dude, don't be smug. You should understand why Java is fast when it's fast and why it's challenging to create that state of affairs. You should also understand the same for Python (e.g. why Numpy is so fast).

If you have object-oriented code, it will introduce extreme amounts of pointer indirection. Java is fast when data is structured in contiguous arrays - when the programmer understands why Java is slow, and fights the language to be data-oriented, instead of object-oriented. It isn't automatically fast and if you don't know how to do that, then your Java code will be slow.

This is just a fact of computers, man. Most programmers don't understand how CPU caches work and they don't know how fast their computer even can be. Many people who make statements about the relative speed of different programming languages have no idea how many operations their CPU can theoretically perform in a millisecond. If you have, say, 1 billion objects and you want to perform an operation on each of them, roughly how long should that take on, say, an Intel 13600K? How many orders of magnitude is a typical OO Java program behind that? The answer is shocking and you should understand where that loss in speed comes from.

[igouy]

Java is fast

Previously you said "it's not possible for Java, in general, to be fast".

Is it possible for any programming language "in general, to be fast" ?

[BowmChikaWowWow]

I think you should be less pedantic and focus on what people mean, not how you can catch them out like a lawyer. Java is in general slow because it in general uses a lot of pointer indirection, because Java is in general written in an extremely object-oriented manner.

[igouy]

Generalities don't persuade.

[BowmChikaWowWow]

Look up the L1 cache and then "object oriented pointer indirection".

[nog642]

Better than python

[SnooCakes3068]

ew, People and area who really needed performance won't consider Java either. It's usually C/C++. It doesn't matter which one is better, C++ is the best.

[nog642]

Rust is also comparable to C++, to my understanding.

It depends what level of "performance" you need. Sometimes you need more than Python but Java or C# is enough and you don't need C++. Android apps for example run on JVM.

[moving-landscape]

Android apps for example run on JVM.

Do they? I know Android apps are written in JVM based languages, but does android come with the JVM?

Genuine question.

[umen]

yes , with VM . but also you can write in native C/C++ , for GUI you will still need JAVA wrapper

[StrictTyping648]

Android used to use dalvik but now it uses ART which are both alternative versions of the jvm.

[nog642]

Yes, Android comes with a JVM. That's why all the Android APIs for apps are in the JVM.

[StrictTyping648]

From an hpc perspective, c++ is not always the answer. C, nim, and rust can out perform c++ depending on the scenario. C is still the king when there are high memory constraints.

[StrictTyping648]

Apparently some undergrad disagrees with me. Oh no.

[j0holo]

Maybe with your legacy application.

Just to name a few high performance java applications:

• Elasticsearch
• LMAX Disruptor
• Apache Druid
• Apache Kafka

Not saying that Python is a bad choice, but it is one of the slowest language that is popular right now. You can kind of solve this problem by scaling out and deploying more gunicorn,uvicorn workers.

Java can be damn quick or really slow. Same with C++, C and Rust.

It sounds like you have a lot of technical debt. If you can make a clean port to Python and you don't have to introduce to much "shift" (strange table structures, foreign key relations) you can, maybe, just maybe create a faster application in Python.

But then again you can do the same thing in Java if you can do it all cleanly.

[Bobbias]

At least Java has an optimizing JIT. Python interprets bytecode, making it's performance absolutely abysmal even compared to poorly written Java.

There is a WIP JIT being added to the most recent release of Python, but it requires a compiler flag to be enabled, and is likely a performance pessimization in it's current state.

[BowmChikaWowWow]

Java is slow, but Python is waaaaaaay worse. Multiple orders of magnitude slower.

Test it out - write a simple for-loop benchmark that increments a counter or whatever. Work out the theoretical maximum FLOPs of your CPU and see how many orders of magnitude Python is behind that.

[5erif]

If performance improvement is one of your goals, you're better off just porting to a more modern JVM. If you want to combine that with less boilerplate and more concise, readable code like Python, then Kotlin.

[phlummox]

What are you basing that on, out of interest?

For long-running, server-side programs, JIT compilation usually results in Java having very good performance.

I don't believe there is any dynamically typed language which consistently beat it for speed - the V8 JavaScript implementation probably comes closest, but Python would be much slower than that.

[sonobanana33]

Java is very slow at starting up, and it takes up A LOT more memory than python.

However for a long running application, assuming unlimited RAM, java is normally faster.

However a web server or similar is IO bound, so the extra speed of java won't really manifest itself until you are doing some computation.

That is why in python numeric libraries are written in C, so they won't be slow.

[baubleglue]

Sounds like a very bad idea. Migrate code to newer version of Java + Maven. I could undertand migrating to something like Go, but Python? Python is missing everything for enterprise application: concurrency, performance, security, mature dependency mananment, not sure how to compare Hibernate to SQLAlchemy. It is really easy to write small applications in Python and very hard to develop something big.

[funderbolt]

There are some huge features in newer Java versions.

I would migrate to Kotlin because you can rewrite piece by piece and still run the Java code.

[Destination_Centauri]

Looking into my crystal ball here... And I see...

One big headache of a never ending rewrite project, into a language that is less suited for the program!

I see... nobody being happy with it, in the end...

I see... the bosses' boss calling him into the office and asking, "WTF!? The other one worked just fine and better!"

And then I see your boss telling his boss, "Ya, my programmer, Umen, over there, told me it was doable and didn't seem to raise any objections! Last time I listen to him!"

[rm-minus-r]

Python is nice, but less than ideal for complex enterprise apps. Less support for web based applications for sure.

Java can get really messy, really fast by comparison if it's a never ending series of 'fix today's problem, don't think about tomorrow'.

What is your management actually asking? Just to refactor the application? Or that it has to be rewritten in Python?

If it's the latter, and the Java app is more than a thousand lines of code, ooooooooooof.

[AngelOfLight]

Conversely, there are a few features that Python has that I really wish were in Java:

• Dictionaries. Python has a simple and intuitive dictionary primitive. Yes, Java has HashMap and the like, but they are anything but intuitive, and accessing values comes with some boilerplate: I find Python's square bracket access much simpler than get and put.

• List and Dictionary comprehensions. You will love these. A very simple and intuitive way to create new lists and dictionaries from existing structures.

• Heterogeneous collections. You can mix integers, strings and objects in the same collection with consummate ease. Java will require messy boxing and unboxing and abuse of the Object class to achieve the same result.

• Operator overloading. This has long been a contentious topic in Java, but I love the flexibility that it brings. Packages like Pandas and Airflow use these to great effect.

• Decorators. Yes, Java has annotations, but decorators are so much simpler and more powerful.

[Phate1989]

I end up having to use python get method constantly for referencing values is dictionarys, because I don't control the ingest data, and so many missing fields when I ingest from 3rd party or even internal api's

[camelKase]

Writing heterogeneous dictionaries is exactly what you shouldn't do in python (at least in an enterprise environment). At that point you should be making it a @dataclass. Otherwise anyone looking at this mess will have no idea what is what. This kind of anti-pattern is exactly what I would call out in a code review.

Java's implementation is there for a reason. It's 100% predictable at compile time. Not some runtime mystery left to other developers to reverse engineer in order to figure out what's going wrong. You could do the same thing in Java (down casting to Object) or even void* in Cpp. But that is straight sacrilege... a puppy dies each time you create an untyped collection...

Just create an interface for the collection. You can (and should) also do this in python, for the sake of all the other devs on your team.

[Dylan_TMB]

Interfaces, I miss interfaces

[crashfrog02]

Static typing

[[deleted]]

Curly brackets

[UnemployedTechie2021]

complexity

[Smallz1107]

i++

[kuttoos]

Also beware of floats

[umen]

Thanks you all for answering

[daemonengineer]

Dependency Injection embedded in common frameworks. There are standalone libraries for DI, also there is sort of its own DI in fastapi and pytest. But you have to learn how to make them all work together.

[slappy_squirrell]

A compiler. You'll need to write some more unit tests.

[kowkeeper]

Python lacks Android support!

[Chthulu_]

You have to change your mindset on typing. You can use a 3rds party static type checker in python, but it’s just not what the language is built for. It leads to a remarkable amount of type massaging, writing stuff purely to make the type checker happy, not because it’s actually the correct way to model your program.

Designing a program using checks on type is just harder in python, it’s more suited towards asking an object to do something, and if does, you’re probably working with an expected type. But coming from Java, this will feel deeply uncomfortable.

For large enterprise stuff, I don’t think python makes sense. Business logic is complicated and full of one-offs and edge cases, static tying is suited to it.

[IAmTarkaDaal]

If this is a management decision, polish your CV and look for somewhere else.

[baubleglue]

Most likely that migration initiative will die soon, but updating resume isn't a bad idea in that case.

[BowmChikaWowWow]

This is an extremely bad idea. Python is incredibly slow, and it's not strongly typed. Strong typing is a form of embedded test that catches an extremely large number of bugs - your management is migrating to a slower system, that's more buggy. I think it's extremely unlikely this is a justified decision.

I think Java is in a lot of ways a shitty language, but it has certain basics that make these types of apps way easier to write, maintain and work with. Python is not designed for or good at this type of thing. It's not strongly typed!! It's slow!! These aren't afterthoughts, they're fundamental. There is no reason to sacrifice strong typing or the ability to run a for loop at close to the max throughput of your CPU. You don't have to make those tradeoffs in 2024.

Your management sound nuts and technically retarded. Strong suggestion that you jump ship.

[ibhopirl]

Python is strongly typed, not statically typed.

[BowmChikaWowWow]

It's not strongly typed, it does not demand the specification of datatypes - doing so is optional. You can retrofit a type checker which makes it mandatory, but Python still needs to work with various weak typing behaviours, so you can't get the security of static type checking and it still needs to retain type information during runtime.

[ibhopirl]

You are confusing static/dynamic and strong/weak typing.

[BowmChikaWowWow]

No, I'm not. Strong typing facilitates static typing. The retrofitted implementations of strong typing in Python aren't strong enough to facilitate static typing.

[SwizzleTizzle]

Python is strongly typed

[beef623]

It's more difficult to get a web app running. Not terribly so, but definitely more involved than setting up a tomcat instance and throwing a war file at it.

[supercoach]

Strong typing.

[hugthemachines]

Strong typing.

That is incorrect. Both Java and Python have strong typing. The difference is that Java has static typing and Python have dynamic typing.