Man, I cannot imagine writing let alone maintaining a large software stack in Python. We use C++, Go, and Java for production software systems, with Python employed for scripting, testing, and tooling.

There are a bunch of reasons for the primacy of C++ and Java:

• Familiarity. Early Googlers were well-versed in C++.
• Performance. Java can be faster than Python; C++ can be faster than Java.
• Tooling. Tools for debugging, profiling, and so on are significantly better for Java than Python. Even C++ is easier to debug and understand in large systems.
• Concurrency. As you can imagine, Google systems are highly parallelized and many are highly threaded. Threading in Python is an unmitigated disaster. The global interpreter lock (GIL) is a giant pain in the ass.
• Lack of need for the prototyping prowess of Python. One commonly-cited strength of Python is that it is easier to rapidly prototype small systems in Python than Java and (to an even greater extent) C++. At Google, however, this benefit isn't all that appealing: We have a lot of powerful frameworks that make prototyping or extending existing systems easy. Folks tend to prototype by gluing a hack into an existing server rather than build an entirely new distributed system.

Don't get me wrong, in the war of Perl versus Python, I come down on the side of Python. But I would never use it to build a production, scalable, mission critical, performant system—particularly one someone else may need to understand some day long in the future.

Alex Martelli, a senior Google engineer's motto is, “Python where I can, C++ where I must” This may be because Python and Java had some different design goals.

Python is a language that is optimized for readability and rapid development. It's very well suited to the more entrepreneurial groups that are looking for product/market fit because iteration is quicker with a less verbose, less restrictive languages.

In my startup, we use both Python and Java. Python for most of the product both front end and back end but C++ and/or Java where there is a performance bottleneck. This lets us benefit from the speed of development with Python and speed of execution of code with Java. Google seems to use them in similar capacities.

Python's a great language, but I'm going to mention a few reasons why you might choose Java:

* It's fast, handles multithreaded well, and scales.

* It's built for security.

* It has a great ecosystem. (Which includes a deep learning library I work on.)

* Many companies have bet their stack on Java, so there's demand for Java programmers.

* The JVM is cross-platform, and uses run-time information to manage itself.

* It takes care of memory management.

* Java 8 has lambda expressions, and includes an impl of Javascript called Nashorn that runs on the JVM.

* Static typing: Java is typesafe, and its static typing is essentially a form of self-documenting code.

* Java is mature: It's been around for 20 years, it's fully backward compatible, and code written decades ago still works.

* Android: Java 7 works on the world's largest mobile OS.

* For those and other reasons, Java is one of the world's most widely used languages. Oracle says there are 10 million Java programmers worldwide. The Github stats from Eduardo Bonet speak volumes.

Why I sometimes choose Java over Python: Static Typing. Static Typing. Let me repeat: Static Typing.

When it comes to servers or large applications I fell more comfortable with typing, it's easier to catch bugs early on and sometimes faster to develop (smart complete usually works better). I think more constraints usually means the code is more standardized and maintainable. Compiled languages usually handle threading better too.

I still use Python a lot though: for instance, to write data scrapping script and data analysis. Every tool has its use case.

Just as curiosity, Java is an "old" language but is actually gaining popularity in the last few years, at least on the open source scenario. I believe much of it comes from Android and the Apache Foundation.

(Language Trends on GitHub)

I would bet that Google sees itself as a mature organization that needs to innovate on a more incremental than disruptive way. Java and C++ are great choices for making something you know how to make and make it performant. Python is amazing when you don't know exactly what you are making but need to deliver it quickly. It's also worth mentioning Google operates on a scale that magnifies even the tiniest difference in operational cost. I may get away with a 10% overhead on my servers but 10% of Google's server expenses is more than the GDP of most countries.

I emphatically disagree about a large Python-based application being unreadable or unmaintainable. Python's strengths in rapid prototyping and development can be used to refactor more quickly and to prevent the complexity buildup that happens to long-lived systems. I'd much rather maintain a 1 MLoC Pyrthon codebase than the 10 MLoC Java equivalent.

Python is a great language, but it makes some serious (albeit intentional) trade-offs by placing programmer productivity as one of it's primary (if not first) priority.

Things like dynamic typing and the Global Interpreter Lock are just a few examples of these language design choices which make trade-offs with performance and maintainability in favor of individual programmer productivity.

Moral of the story: every language has its strengths and weaknesses and therefore no language is the best at solving every problem.

I think Python is a great first language. If you already have a statically typed language under your belt, then Python is the direction I would recommend. Python is also a great language to learn if you are just starting out in the web-space.

If you are looking for a new language that provides some specific benefits and can expand your programming solutions horizon, I would look at: Scala, Go, Haskell, or JavaScript.

If you don't already have a statically typed, large architecture type language in your tool-kit, then Java would be a good choice, but there are others I would personally lean towards before diving into Java.

Google is likely still using Java for the same reason a ton of other companies are still using Java and will do so in the foreseeable future: cost!

Google has probably so many systems and applications written in Java that it would likely have to spend a multitude of its cash in its war chest to replace it with anything else.

Even if they decide to stop using Java for new things, the old stuff will continue to be around for years if not decades to come and will have to be maintained and sometimes extended since replacing it with something new may not be an option - remember the cost thing …?

Finally, Google seems to employ a pattern to use the best tool for a given job. And lets be honest, for some jobs, Java is simply one of the better tools (aka programming language) to use.

Oh, and I am not going to answer the question “which language is better…” - no, I am just not going there since ‘nuff has been said already.

Disclaimer: I don't actually hate Java. I think it's a perfectly serviceable language. Nowhere near the top of my list but people obviously find it useful for their own highly subjective reasons that are at odds with mine typically. It's the Java devs that I hate (kidding, mostly, well except for the guys who never learn anything but - they're terrible).

Why is Google still using Java?

Because they started with Java. As a result, they have an awful lot of Java code an awful lot of Java needs and an awful lot of Java devs. So they tend to be Java-centric in terms of culture, choices and writing spectacularly lame JavaScript libraries (in less recent years at least).

Contrary to what many here have said, I think it's very clear that Google, while home to many, many polyglots, and the best talent money can buy and then bore to tears, is clearly a Java-centric place to work. And by that I mean a Java pro with some Python knowledge is likely to be more useful for a wider variety of programming jobs at Google than a Python or any other language expert with some Java knowledge. Of course they write in more than just Java but they like Java, they made android about Java, they keep trying to replace JavaScript with something that's more like Java or at least a lot less like JavaScript which is pretty much Java's exact opposite in terms of design philosophy and the adventurous possibly reckless developer personalities it attracts.

Which language is better, Java or Python?

What a ridiculously broad question. I love those. Here we go.

* Brevity of code? Python.

* Legibility? Depends on whether you find highly explicit more legible than brevity of code. To me it's similar to whether you prefer legalese to plain english. So this particular subjective opinion favors Python on that count. There's a difference between explicit and verbose by design, which is a mistake, not a feature.

* Keeping your butt covered in scenarios where you're working with 20-1000 developers with no guarantees as to dev quality? Java. Hands down. If you don't want people messing with your freaking stuff, because they'll just break it, forcing them to duplicate what your code already did so they can then solve the same problem a second time, Java is definitely ideal for that.

* Never needing 20-1000 developers to all work in the same overlapping sections of code in the first place? Python.

* Median-level dev quality? Python. It's true that you have to think a little bit harder about what you're doing without the static types keeping you covered. IMO dynamic language background devs tend to have a much stronger understanding of the value of OOP than devs that primarily code in C#/Java where the illusion is that it's all OOP by default. Once you've gotten into the habit of following DRY religiously and actually thinking about cost/benefits of various types of architecture however, that stuff sticks with you and will help you in any language you write code in. And it really doesn't take very long when you faceplant and get back up and keep writing and executing code as quickly as you do in a language like Python.

* Performance? Python. I could care less what looping performance tests indicate. Python has much higher-quality libraries written by an exceedingly anal community that actively polices its core libs. People don't bother reinventing those wheels because they're typically too well-done to bother trying. That means fewer crap-fest libraries to trip on. I don't care if some algorithm loops 20% or 200% more efficiently in the JVM. It's all the amazing crap that gets wrapped around that one call in a typical Java app that sucks the air out of any tires the JVM still has and it's not faster enough than any other mainstream option to make up for typical shortcomings of a Java codebase that have nothing to do with the core platform performance. See also, brevity of code and median-level dev quality. The performance of the app that actually ships isn't a contest Java is known for winning most of the time. Yes, anecdotal again but I've noticed a lot more slow-as-dirt Java apps in my career than I have any other development solution and I've worked with most of the popular options in web development.

* Security? Lol. I haven't seen Ziff Davis editors advising people uninstall a version of Python any time recently. To be fair, JVM stuff doesn't really compare directly to Python interpreter stuff since most non-trivial Python apps will pack their own interpreter but let's think about that. Why is the JVM so freaking huge as to make that unfeasible for Java apps? Too much weight and bloat that you're never gonna need are a recipe for exploits long-discovered by unscrupulous people long before the white hats give them the zero day treatment.

* Job market? Python. You might see 10,000 Java listings for every 5 Python listings but you're also typically looking at being one in 10,000 applying for the job with Java. That means you spam resumes and they look for reasons not to talk to you in the first five rounds of culling before you get to the grilling committee. The difference between that and being one of a handful of competent developers available for jobs that are less common but still not insanely hard to find is massive. As far as personal career satisfaction is concerned it's the difference between a 1 hour driving commute and being able to teleport to work.

* Cross-platform desktop? Python. Even Java devs make fun of Java devs for never testing on more than one platform. Python devs are anal and core libs are quite thoroughly dedicated to cross-platform support as are a lot of apps written with them as a matter of pride as much as practicality.

* Mobile development? Java. Python has been surprisingly weak on cross-platform mobile solution for some reason. For Android alone Java has Python beat, IMO.

* Web development? Python. Largely owing to that median dev quality thing but the frameworks are cleaner, simpler and more focused on the actual typical web app problems that need to be solved. If Spring is good, I've never seen it implemented properly and the docs weren't good enough to help me tell whether it was or wasn't.

* Massively mega apps like the Google search engine itself? I have no idea. Never worked on something with that much legacy code or that is used by that much of the planet. Java might win here but so many of the reasons Java devs give for other Java superiority factors are silly and tend to demonstrate a lack of experience with languages like Python that I'm not sure I'm ready to give that one away. I personally suspect a two-layer approach with something like C or C++ closer to the chrome where bugs get weird and fine-grained performance tuning capability is likely to have the most impact wrapped in a less verbose higher-level general purpose language like Python might actually be the way to go if you actually have the luxury of designing such an app of such scale up front before you're forced to wrap layers around what was intended to be a prototype as more typically seems to happen.

* Community? Python. Java is massive. It's corporate. It's academic. It has an awful lot of thought leadership that unlike Python isn't built on contribution to open source libs and frameworks. Stewardship is by Oracle which at the very best of times is a big fat 'meh. And Java has a lot of followers who repeat a lot of things they've never properly vetted. Python's whole "pythonic" thing gets a little culty for my taste sometimes too but at the very least is built on general principles rather than overly specific Kool Aid d'jour of some blogger whose success is more about learning how to say things that excite IT leadership or business concerns than writing apps. And they are prolific and focused. If beings from another galaxy landed on Earth for the first time tomorrow afternoon some Python dev would have a working wrapper for the alien programming language that let them author stuff with it in every major desktop OS the following morning. You don't see as much of that with a language that tends to make a mess by trying way too hard to protect you from your own mistakes and the mistakes of mediocre teammates. I'm more of a JavaScript dev in terms of heavy expertise and proudly identify as such but I've always been very impressed with the focus and the level of talent in the Python community. We don't have as much of that. Neither does Java.

I am planning to learn a new language. For which should I go for, Java or Python?

Remember this?

"...which requires legitimate interest in writing code. That's a recipe for a stronger developer in any language."

That's all that really matters. The sum of everything else I wrote holds less value than that, unless like me you're also really sick of Java devs saying really dumb things about languages they obviously know nothing about. Mess around with both. Pick the one that you want to keep coming back to more. Interest keeps you learning more and trying new stuff. Disinterest is career suicide in programming.

If it's your first or first "career" language, start with Python. IMO, it's better to rapidly unlearn the bad habits a lot of static-only developers never bother to by face-planting in a language that prefers rapid development and powerful expressive code over protectionism. And it's easier to learn when you're spending less time dealing with all the configuration details and boilerplate that Java is notorious for.

If not, start with the one that's least similar to what you already know. Both are used by enough developers to warrant attention from any would-be polyglot and the less similar it is to the language you know best, the better you'll understand both languages as you learn more about the new one.

Google did use Python for many mission critical services: first Google's web server was written in Python, and the whole fleet of machines was serviced by Python (a prototype code that went live and took years to replace with something written in C++). Every single commit was reviewed through a Python dashboard. Google's build system was (or might still be) orchestrated with Python (BUILD files consist of Python classes).

A lot of Python code still keeps Google running.

Things look much different today. Google has slowed down, has well defined and stable infrastructure that had been rewritten many times from Python to something more stable. It also has more engineers, and well documented internal libraries for other languages.

The main driver for Google to use C++ and Java can be found in savings on machines and electricity. Existing machines can serve much more customers, and even if there is a penalty paid in development time it still makes sense considering the traffic Google receives. At that scale it doesn't make sense to stay with scripting languages. This is one of the lessons Facebook learned, stuck with PHP it had to resort to writing a PHP compiler which made things twice as fast (even though still slow if you compared them with C++/Java code) and enabled them to run on 50% less machines.

However, for startups or smaller companies, Python is still a very attractive option, even with all the mentioned deficiencies in terms of speed, parallelization and compile time checks.

Is everyone kidding themselves? you don't write large enterprise software in anything but C#, Java or C++.

Google develops some of the biggest most complex applications around.

You just can't do what Google does with PHP, Ruby, or Python. The fact that Facebook did what it does with PHP was a miracle, and a mistake. They got locked into it, and would surely do it differently if they could go back.

Dynamic languages are great for relatively small applications and for the web because you don't have to recompile/rebuild. Other than that, they are bullshit.

Furthermore, Google is pushing two new languages - Golang and Dart. Those languages have no real advantages over Java or Scala except that they are "proprietary" to Google. Google will use Java for a long time to come.

Speed is one major factor, I'd think. Refer the attachment.

Because Java is the best choice for most of big, long living and complicated projects:

1)The engineers are leaving the project and even the company and you have to find the replacement. Quickly and lots of them. And it should be a good replacement. These new comers should start quickly. They should be experienced enough. Java jobs are probably the most popular and good paid one on the market. So there are aways lots of choices.

2)The verbosity and simplicity of Java which are hated by lots of people is really crucial for maintenance. It’s easy to learn the code. It’s clear even without the fancy IDE. It’s much harder to write fancy, overcomplicated code even if you beginner or some kind of code hacker.
So even poorly designed code remains relatively clear for people who see it first time.

3)Regardless of popular stereotype, the Java apps are really very fast now days. For some cases it could even outperform the C++ code.

4)No one language has such a rich infrastructure as Java. IDEs, libraries (including very mature and free ones), tools, documentation and learning materials availability, ready for use patterns and good practices, support on the market etc

5)Extremely mature and very conservative evolution. Backward compatibility is the priority. You can still run the apps written 15 years ago with no changes and no problems.

6)Java is evolved by the open process called JCP and open sourced. It is backed by the companies which are the leaders of industry (Oracle, IBM, Red Hat and even Google itself). So company could be sure it will not be closed because some company decide it is not interested for their business anymore. Or turn somewhere wrong at some point with a language developmet.
It is very important that even 10 years after you will be able to maintain your software well.

7)Money invested into this technology. Research, development, marketing, other products based on Java. All that makes you sure this technology is one of the best.

There is no a definitive answer - you should focus your question more, maybe on a certain product of Google. Google is pretty much a big company, has many projects which employs many technologies:

• In fact Google is heavy in Python usage, and is contributing some functionality back to the community.
• some portions of Google core products,as the search engine and Chrome browser are developed in C++. for delivering better performance.
• In that sense Google promotes the Google Go, programming language that has been described as Python meets C++ (can be arguable)

Indeed Google is also using java heavily as well. as I see it for few reasons:

• many developers at Google are well familiar with Java technology. Java is very much common around the world, and hiring excellent developers who are Java savvy.
• Java is an excellent technology, superior with libraries that can boost development and provide state of the art frameworks for networking, security, performance and more.
• Google has acquired some companies and technologies which were developed in Java originally. consider the android mobile o/s platform that is actually developed and running some flavor of Java engine (Dalvic VM)
• There are many Java developers in the world. The company cannot ignore this huge community and as such also take active role in setting up open Java frameworks (see Google Guice)

We can all debate why Java was chosen as language of programming for Android, but it will be all our interpretation. The case finally rests with Andy Rubin and he is the best person to answer this question and he has actually answered this.

Read this article.

Trial: Android chief on why Java was picked for Android | ZDNet

I will just reproduce some of the highlights of his responses. Let’s hear it from horse’s mouth.

When prompted by Google counsel Robert Van Nest if there were other programming languages that could have worked for Android, Rubin affirmed there could have been. Some of the other languages considered for Android were Javascript, Python and Lua.

the benefits of using Java for a smartphone -- primarily the well-known brand name as well as compatibility being that it is a common language taught at universities worldwide.

"We saw this as an opportunity to open up Java, and we asked Sun to contribute to the open source community," Rubin said.

The article has lot of other relevant information on how and why Andy Rubin collaborated with Sun (before Oracle acquired Sun) also how Google wanted different licencing to be done for Java so that it can be taken up for Android development. This is a very interesting article, I would suggest to read it.

Based on this all I can say is - Java was chosen because it was popular, widely known programming language. In 2005, when Android was in it’s nascent stages, Java programmers were probably the easier and largest available talent pool.

I wonder why developer community would have found it interesting to learn a not-so-commonly-used or completely new programming language (in case Android actually did come up with one) for then upcoming unknown mobile platform.

I am sure there were lot of technical reason (which some of the other answers have tried to point out) for choosing Java for Android development but one of the main reason was, they(Android Inc) wanted a quick adoption by the programmer community to help Android grow quickly.

In hindsight I can say that it has worked out well for them.

Edit 1:

It looks like this is very commonly searched question. That’s why I have created more detailed video on my YouTube Channel CodeTutor on this subject.

Remember Eric Schmidt the google ceo from year 2001 to 2011. He has worked with Sun Microsystems where he supervised a project called oak which later was released as java in the programming world. He left Sun Microsystems after in year 1997 as he got job of a ceo postion as Novell after java became a hit. Eric Schmidt was also google board member till year 2017. He had good relations with java team at sun microsystems. He promoted idea of building android entirely on java as he said Sun didn’t had problems with what google intended to do with android. So if your ceo is found of one language would the company not consider to use it.

Python is an official language at Google. Alongside two other prominent languages Java and C++. Google even supports the development of Python programming language and sponsors various Pyhon conferences like PyCon. Until 2012, the designer and creator of Python, Guido van Rossum was employed by Google when left to work for DropBox.

Well, coming to the question, Python is used at Google for its countless internal systems as well as:

1. Most of the core search algorithms at Google are written in Python and C++.
2. Various build systems, log analysis, code review tools etc are written in Python by Googlers.
3. Lots of Open Source libraries .
4. Various Data and API libraries like Google Data Python Client Library, Google APIs Client Library for Python and Google AdWords API Python Client Library.
5. YouTube : Previously it was written in PHP but eventually it was replaced by Python and the site uses Python heavily for various purposes like view video etc.
6. One of the main website for hosting for Google developers code.google.com as well.
7. And currently, most of the Machine Learning, AI as well as robotics projects at Google are implemented using Python and lots of C++.

Python, being non-compiled, is far too slow. Java turned out to be a little too slow too, and Android already has problems with Java's garbage collection, which is why Android phones stutter and have stability problems when iPhones do not. This, despite having 3x the RAM in most cases.

I'm guessing they wanted something compiled and "easy" enough for broad development, which doesn't leave a lot of choices. Objective-C has been far better performance-wise for Apple, but Obj-C is also harder to learn than Java. Today, Google would have gone with Go, and Apple would have gone with (and has already started to switch to) Swift.

To answer the specific question first: No, Python is not going to replace Java, any more than the screwdriver is going to replace the hammer. They are different tools for different purposes.

There are lots of answers defending Java that basically boil down to something like ‘the Hammer is the One Tool to Rule Them All!’. I caution you to beware zealots defending their favorite anything.

More specifically, while just like you could in theory build anything with just a hammer, its not necessarily the best tool for every job. Java is mainly a tool for building software with a graphical UI. ie, it is focused on User Interface. Many Web sites are written in Java, however, JavaScript is significantly more popular now, and would likely be a better choice for someone wanting to learn a language for Web development.

Web software, or software with a UI, is only the surface though. Like the surface of the Earth, it gets the most attention, but by volume is an incredible minority of the whole. Most software does not have a graphical UI. Im not talking about the difference in ‘back end’ and ‘front end’ that are both just components of the UI. Under the surface, there is much more.

If you want to go into hardware level programming and interfacing with devices, C is probably the best choice. If you want to go into AI, Machine Learning or Deep Learning, or anything scientific related, then Python is the usual suspect.

The first software I wrote used punch cards, and in the decades since I have seen languages rise and then fall in popularity in what is now a predictable pattern. If you are interested in why JavaScript is on the rise and Java is on the decline, I recommend Douglas Crockford’s excellent talks on the subject.

In the end though, it comes down to a choice of what is the right tool for a particular project. Without that context, its a purely theoretical and subjective comparison that just draws out people’s strongly held opinions.

I am using both Python and Java and I am not religious about any of them.

Grass trimmer will never replace chainsaw, simply because you don't use these tools for the same thing. You never use trimmer to cut woods, or chainsaw for mowing the lawn [if you do, you should reconsider your life a bit]. Note that chainsaw IS capable of cutting grass, but you'll agree that a trimmer is better choice.

Use same analogy for Python and Java. Don't think of them as Python vs. Java, but rather Python with Java. You have problems that should be sorted out with Python, and you [arguably] build enterprise level apps with Java.

Software developers often identify strongly with their tools of choice, freely mixing objective facts with subjective preference.

The last decade, however, has seen an explosion both in the number of languages used in production and the number of languages an individual developer is likely to employ day to day. That means that language affiliations are sometimes spread more loosely and broadly across different codebases, frameworks, and platforms. Modern projects and modern developers are increasingly polyglot—able to draw on more languages and libraries than ever before. Informed choice still has a part to play.

From that bustling bazaar of programming languages, let’s narrow our focus to two survivors of the 1990s that have very different origin stories: Java and Python.

Python’s Story

Python is the older of the two languages, first released in 1991 by its inventor, Guido van Rossum. It has been open source since its inception. The Python Software Foundation manages the design and standardization of the language and its libraries. The Python Enhancement Proposal (PEP) process guides its development.

In programming language evolution, it is common to maintain backward compatibility indefinitely. This is not the case with Python. Python 2 arrived in 2000 and Python 3 hit the scene in 2008. They are largely compatible, but have enough functionality- and syntax-breaking differences that they can be treated as different languages. Rather than retrofit newer trends and ideas into Python 2 (complicating and compromising the language), Python 3 was conceived as a new language that had learned from Python 2’s experience. Python 3—version 3.6 at the time of writing—is where current evolution and emphasis in the Python world exists. Python 2 development has continued separately, but its final incarnation is version 2.7, which will no longer be maintained after 2020.

Python’s syntax embodies a philosophy of readability, with a simple and regular stykle that encourages brevity and consistent code layout. It originated as a scripting language, embodying the Unix philosophy of being able to compose new programs from old, as well as using existing code directly. This simplicity and composability is helped by Python’s dynamic type system. It is an interpreted language available on many platforms, making it a portable option for general development.

Python’s reference implementation, written in C and known as CPython, is available on many platforms and is the most commonly used. Other groups have created their own implementations, such as IronPython, which is written in C# and offers close integration with the .NET runtime.

Python is a general-purpose language built around an extensible object model. Its object-oriented core does not necessarily mean object orientation is the most common style developers use when programming in Python. It has support for procedural programming, modular programming, and some aspects of functional programming.

The language’s name—and no small amount of humor to be found peppered through its documentation and libraries—comes from British surrealist comedy group Monty Python.

Java’s Story

Although it was not released until 1995, Java’s story begins in 1991. James Gosling and others at Sun Microsystems conceived a language for programming interactive TV systems. It was released with the fanfare of being a portable internet language, particularly in the browser. It is now a long way from this starting point and the original name: Oak.

Just as it was too heavyweight at the time for its original TV target market, it lost the browser space to dynamic HTML and JavaScript (which, in spite of its name, is unrelated as a language). However, Java rapidly found itself on the server and in the classroom, helping ensure its ranking as the dominant language at the turn of the millennium.

Part of its attraction and value is its portability and relative efficiency. Although not a native language, such as C and C++, Java is a compiled language. Its execution model is more machine-centered than purely interpreted languages, such as Python and Perl. Java is more than just a language and libraries: It is also a virtual machine and, therefore, an ecosystem. The Java Virtual Machine (JVM) is an idealized and portable platform for running Java code. Rather than worrying about hardware specifics and having to port code to new platforms, the promise of Java has been Write Once, Run Anywhere (WORA). That is so that as long as a JVM is present, anything compiled into its bytecode can run and interact easily with anything else written for the JVM. There are many JVM languages, including the more script-like Groovy, the functional Clojure, the object–functional hybrid Scala, and even a Python variant, Jython.

Java is an object-oriented language with a C/C++-like syntax that is familiar to many programmers. It is dynamically linked, allowing new code to be downloaded and run, but not dynamically typed. As a language, Java’s evolution has been relatively slow, only recently incorporating features that support functional programming. On the other hand, the philosophy of both the language and the VM has been to treat backward compatibility as a prime directive.

After Oracle bought Sun, the language and its compiler were eventually open-sourced. The language’s evolution is guided by the Java Community Process (JCP), which includes companies and individuals outside Oracle.

So how do these two languages stack up? Let’s break it down by category.

Speed

Although performance is not always a problem in software, it should always be a consideration. Where network I/O costs or database access dominate, the specific efficiency of a language is less significant than other aspects of technology choice and design when it comes to overall efficiency.

Although neither Java nor Python is especially suited to high-performance computing, when performance matters, Java has the edge by platform and by design. Although some Python implementations, such as PyPy, are fine-tuned for performance, raw portable performance is not where Python shines.

A lot of Java efficiency comes from optimizations to virtual machine execution. A JVM can translate bytecode into native machine code as a program executes. This Just-In-Time (JIT) compilation is why Java’s performance can often rival that of native languages. Relying on JIT is a reasonably portable assumption as HotSpot, the default Oracle JVM, offers it.

Java has had support for concurrency from its first public version, whereas Python is more resolutely a sequential language. This has implications for taking advantage of current multi-core processor trends, with Java code more readily able to do so. The Global Interpreter Lock (GIL) in the dominant implementation of Python, CPython, stands in the way of such scaling. Python implementations without hits restriction exist, but relying on them can interfere with some of the portability assumptions underpinning Python code.

Legacy

Often language choice is not about the design and intrinsic qualities of the language itself. Languages exist to create code, and that code has a context in business, economics, history, software architecture, skills, and development culture.

Legacy systems have inertia around their incumbent technologies. Changes will more easily follow the path already laid down, shifting gradually and incrementally rather than by rewrite and revolution. For example, an existing Python 2 codebase is more likely to find a new lease on life in Python 3 than in a rewrite. The back-end of an existing Java enterprise project is likely to grow its functionality with more Java code, perhaps migrating to a more current version of the language, or by adding new features in other JVM languages such as Scala and Groovy.

Java’s history in the enterprise and its slightly more verbose coding style mean that Java legacy systems are typically larger and more numerous than Python legacy. On the other hand, organizations may be surprised to find how many of the scripts and glue code that hold their IT infrastructure together are made up of Python. Both languages have a legacy problem, but it typically presents differently.

Practical Agility

Development culture and trends have benefited both Java and Python. By virtue of publications that have used Java as their lingua franca and tools that focused on working with Java, Java is often seen to have the closer association with agile development and its community. But no community is static and so easily defined. Python has always had a presence in the agile space and has grown in popularity for many reasons, including the rise of the DevOps movement.

Java enjoys more consistent refactoring support than Python thanks on one hand to its static type system which makes automated refactored more predictable and reliable, and on the other to the prevalence of IDEs in Java development (IntelliJ, Eclipse, and NetBeans, for example). Python’s more dynamic type system encourages a different kind of agility in code, focusing on brevity, fluidity, and experimentation, where Java is perhaps seen as a more rigid option. That very same type system, however, can be an obstacle to automated refactoring in Python. Pythonic culture favors a diverse range of editors rather than being grounded in IDEs, which means there is less expectation of strong automated refactoring support.

The early popularity of JUnit and its association with test-driven development (TDD) has meant that, of all languages, Java enjoys perhaps the most consistent developer enthusiasm for unit testing of any language. The automatic inclusion of JUnit in IDEs has, in no small part, helped.

That said, Python’s origins in scripting and the inclusion of test features in its standard library mean that Python is no stranger to the emphasis on automated testing found in modern development, although it is more often likely to be integration rather than unit testing.

Human Resources

Sometimes language choice is more about the application of skills than it is about the software applications themselves. Staffing may count for more than language design and tooling. If the ideal language for the job is one that no one has skills in—and no one wants skills in—then it is probably not the ideal language for the job after all. On the other hand, if developers are keen to embrace a new technology then all other things being equal, this can be a good enough reason to go with that technology. In the Java world, the pill of a legacy Java codebase can often be sweetened by embracing another JVM language, such as using Groovy or Clojure for automated testing, or stepping outside the Java universe altogether, such as using Python to handle the operations side of the system.

Another side to the staffing question is the skills market. Both Java and Python are stalwarts of the TIOBE Index programming language popularity top 10 list. Java has consistently been more popular than Python, but Python has experienced the greater growth of the two languages, picking up where Perl and Ruby are falling.

Following the idea that one of the greatest influences on both personal choice and employment interest is going with what you know, both languages have a strong foothold in education, with Java more typically used on university courses and Python used in high school. Current IT graduates have one or both of these languages on their résumé almost by default.

Architecture

Skills and existing software systems and choices inform the programming languages used in any given software architecture. Software architecture is also matter of frameworks and libraries, reuse, and integration. In many cases, it is the technologies people want to take advantage of that dictate language choice rather than the other way around. A software architecture conceived around a Python web framework will not get far with a Java-only development team.

Both Java and Python enjoy a seemingly endless supply of open-source libraries populated by code from individuals and companies who have solved common and uncommon problems, and who are happy to share so others can take advantage of their solutions. Indeed, both languages have benefited from—and been shaped by—online forums and open-source development.

When questions of legacy, reuse, performance, and development skills have all been accounted for, some architectural decisions can still leave the choice of language open. For example, the rise of microservice architectures (where internet-facing systems are partitioned into small, cooperating processes) make the choice of language more of a localized detail than a dominant consideration across a project.

For all the diversity present in the modern programming landscape and its software architectures, some teams and businesses prefer to reduce some of their technology choices rather than live with a jumble of past decisions and personal whim. But consolidation can reduce options, so this is not a decision to be taken lightly. It is worth keeping an eye on trends in languages and frameworks to avoid taking the wrong fork in the road.

Conclusion

Java and Python are both in it for the long haul. Along with their development communities, they’ve evolved and adapted since the 1990s, finding new niches and replacing other languages—sometimes competing in the same space. Both languages are associated with openness, so companies, teams, and developers are best keeping an open mind when it comes to making a decision.