Java is Dead! Long Live Python!

Version 3.0 of Python has been released. Notably Python has again done something Java has long resisted: it has broken backwards compatibility with Python 2.x. Notable fixes include a much saner string processing model based on Unicode. I am told by my Pythonista colleagues that a lot of other weirdnesses such as the print operator and the meaning of parentheses in except clauses have been cleaned up as well. Though I don’t expect all Python programmers to upgrade immediately (and version 2.x will be maintained for some years to come) version 3.0 is clearly a simpler, better, saner language than version 2.x that will enhance productivity and make programmers’ jobs more fun. Bravo for Python. This is clearly a living, evolving language.

Java by contrast, is dead. It has at least as much brain damage and misdesign as Python 2.x did, probably more; yet Sun has resisted tooth and nail all efforts to fix the known problems. Instead they keep applying ever more lipstick to this pig without ever cleaning off all the filth and mud it’s been rolling in for the last 12 years. They keep applying more perfume when what it really needs is a bath.

Backwards compatibility was maintainable and useful through about version 1.4 of Java, but it completely broke down in Java 5 when autoboxing and generics moved the core language beyond any hope of comprehensibility. Autoboxing was a misguided effort to paper over Java’s early decision to have a segregated type system for primitives and objects. It was Java’s Plessy v. Ferguson decision that pretended primitives and objects were separate but equal; but the claim was no more true in Java than it was in American jurisprudence. A separate primitive type system may have made sense in 1995 when CPUs were slower and virtual machine technology was not as advanced. Today primitive types just complexify the language to no particular benefit. Autoboxing would not have been necessary or even considered were backwards compatibility not worshipped beyond all other gods.

Generics are another case where backwards compatibility took a good idea and warped it into something horrible. Multiple design compromises were made to enable genericized code to run in older VMs, most notably type erasure. Then, in the end, binary compatibility was broken anyway. However no one went back to the drawing board and considered how much simpler and more powerful generics could be if they redesigned without worrying about backwards binary compatibility.

Closures, if added now, would only make the situation worse. Closures might be a nice addition to the language if and only if Java simultaneously removed inner classes and made all other syntactic changes necessary to support true closures. Otherwise closures will just be generics squared. New features simply cannot be added on top of the current weak foundation unless we’re willing to go back to the drawing board and take things out as well.

I can’t think of another major language as old as Java that still attempts to maintain compatibility with version 1.0 of itself. In fact, I can think of only one language that attempts that (C#), and that one’s half Java’s age. Unless we’re willing to make the hard choices and abandon the legacy as Python has, Java is doomed to the fate of C++ and Cobol: a tool for programmers with long white beards who grew up with the language and have learned all its arcana by gradual accretion and who spend their lives maintaining code written a decade or more ago. Meanwhile a new generation of programmers will abandon Java in favor of more nimble modern languages like Python just as we abandoned C++ in our youth in favor of Java. (Seriously: is anyone under the age of 30 actually reading this site any more?)

Admitting that you have a problem is the first step to recovery. Java has not yet admitted that it has a problem. The language is too big, too complex, and too baroque. Trade-offs that made sense in the era of single core Pentium II’s, 100Mhz processors, and 32 megabyte memory spaces no longer apply. Backwards compatibility has become a millstone around Java’s neck. We’re deep and sinking fast. Until this millstone is cast off, and we correct the mistakes of the past, no further progress can be made.

It’s hard to believe that I first started saying this over five years ago, and absolutely no progress has been made in that entire time. In fact, matters have gotten worse. Maybe Java is a lost cause, and it’s time to fork and replace the language. If nothing else, Java proved that’s possible. Just look what it did to C++. Perhaps it’s time to repeat the experience.

92 Responses to “Java is Dead! Long Live Python!”

  1. Kjetil Says:

    One minor nit: the point is not that Java 5 genericized code can be run on older VMs (it won’t). It’s that code using the pre-generic collections library will still run on the new Java 5 VMs.

    If you had generics through type reification, you’d need one non-generic collections library for old code and one with generics for the new (generic) code. That’s the main point for type erasure as I’ve understood it.

  2. Daniel Lemire Says:

    But then, why can’t we all switch to Jython 3.0 once it is ready? This way, you get to keep around your old Java code, but all new stuff is done in Jython.

    Of course, Jython is slower. So what. For most projects, it will not matter. And when it does, old folks can write “java code”.

  3. Ricky Clarkson Says:

    Autoboxing doesn’t have to be stupid, it just often is. Java’s generics are ok, except for the ? super and ? extends, which are in the wrong place. They should be declared on the type not on every use of the type. C# 4 implements it the right way, as does Scala.

    Reification would be useful, but there are more things you can do statically than Java does with generics; allowing dispatch on type (i.e., static dispatch) would solve a lot of the use cases of reification, and in a better way than reification.

    I’m not sure how moving to an untyped language would be a step forwards from Java. Though Python’s syntax is certainly better.

  4. Rudd-O Says:

    I am less than 30 years old. I love Python. I hate Java. Py3K FTW!

  5. Suits Says:

    Java was my first programming language. I loved it while it hated me. Over the years it screwed me and i grew to hate it! However after i was exposed to python life became better and now i am in love with programming again.

  6. JeffS Says:

    So, how many job postings for Python 3000 are there? How many will there be in 5 years? Answers: 0, and maybe 2 (nationwide).

    How many job postings are there for Java? – on alone, over 11,000 nation wide.

    And, oh yeah, there’s C++, another so called “dead language” – listings: 5878

    Python 2.x: 1164

    Tiobe Index (ranking programming language popularity, with a reasonably credible methodology), ranking in order:

    1. Java
    2. C
    3. C++
    4. PHP
    5. Visual Basic
    6. C#
    7. Python

    … gee, with all that evidence, I better brush up on my Python 3000 skills, or be left behind. 😉

    Oh yes, Java is most certainly dead! 😉 😉

    And please, oh please Java designers, please do break backwards compatibility, because it will be great to break hundreds of millions (if not billions) of lines of existing production running Java source code, all in the name of appeasing the bitching Java guru bloggers, who prefer design “purity”, and copying so called “cool stuff” from Python 3000, in favor of stuff actually working.

    Nevermind that stuff like Groovy, Scala, Clojure, JRuby, Jython, Rhino, et al, are already providing what these people want. Let’s make existing Java source not work, so that we can make Java “cooler” (and not “dead”).

    Sorry for my dripping sarcasm. But in the real world, where busnesses depend on stuff working, backwards compatibility is of the the utmost importance. Having “cool stuff”, or design purity, or whatever else programmers like to bitch about, it completely irrelevant to the CTO, or IT manager, whose jobs depend on making stuff work.

  7. Stefan Tilkov Says:


    Having “cool stuff”, or design purity, or whatever else programmers like to bitch about, it completely irrelevant to the CTO, or IT manager, whose jobs depend on making stuff work.

    The problem is that they pay for the complexity – with exposing their staff to steep learning curves, getting unmaintainable systems that have grown too fat and ugly to be changed, ultimately increasing cost and decreasing quality. They pay for it because the vendors are slow in releasing new version of their tools, such as App servers, because they carry way too much baggage from the past. If your Java 1.4 code did not run on Java5, what would have been the big deal in leaving it on Java 1.4? Why does Java 7 have to pay for mistakes from Java 1.1’s past?

  8. Jon Strayer Says:

    I agree Java is not dead. But I disagree on the reason to break backwards compatibility. It’s not to make the language cool, it’s to clean off the cruft. And there is a good deal of cruft.

    But I think Jeff and ERH are referring to two different types of backward compatibility. ERH want’s to break backward compatibility with the compiler and Jeff wants to keep backward compatibility with the JVM. It might even be possible to make both of them happy. Given the version number in the class file it would seem possible for one JVM to execute both types of code.

  9. JeffS Says:

    I don’t want to break backwards compatibility with anything. Not the JVM, or the Java syntax.

    But to move forward (yes, I do want progress), I think Java as it is should be mostly feature frozen, with adding to the standard library as needed, and improving existing features. But then progress can come from *other* JVM languages – Groovy, Scala, et al, where those languages can integrate with regular Java (under the hood, they compile to the same byte code).

    And perhaps there can be a new Java. Existing Java can be something like “Java Classic”, or “Java Stable” or “Java-doesn’t-break-your-existing-shit”, or something, and the new Java can be “Java 3000”, or “Java-Way-Bitchin'” or “Java-has-latest-cool-stuff”, or, “JavaEZ”, or, ahem, “JavaFX”.

    Seriously, this new Java can be very similar to old Java, and integrate with old Java, but clear out old Java’s warts, and add the latest things that developers want to make their jobs easier – closures, proper generics, functional idioms, etc. Then there can be a gradual migration over time to the new Java.

    But don’t, under any circumstances, break backwards compatibility, JVM or syntax, with existing Java, risking breaking reams of existing production code.

    If that happened, Java actually would be truly “dead”.

  10. suy Says:

    I’m 27, and certainly I don’t understand how you can say that C++ is abandoned. I run a whole desktop environment written in C++ (KDE), with some parts of the stack written in C. I only use a desktop app written in Python (Anki), and I don’t want to imagine the nightmare it would be the whole desktop coded in this language.

  11. Tom Says:

    Java is evolving. Search on ‘Groovy’ and ‘Grails’ and you’ll see that.

  12. J Donald Says:


    You should read Paul Graham’s essay entitled “Beating the Averages.”

    Python may not be the best opportunity for you, but point is that the number of jobs has nothing to do with the quality of those jobs.

    Opportunity has more than one dimension.

  13. David Hofmann Says:

    “They keep applying more perfume when what it really needs is a bath”

    It is true that good API’s should stand the test of time, but 12 years is out of that scope !

    API breaking, whenever it is well documented, is perfectly ok and needed

  14. Phil Varner › Java is dead/alive Says:

    […] one of my favorites, Elliotte Rusty Harold, in Java is Dead! Long Live Python! This was written by Phil. Posted on Wednesday, December 10, 2008, at 12:59 am. Filed under java. […]

  15. Martin Wildam Says:

    I evaluated programming languages during the last 2 years because I was searching alternatives to Visual Basic which I used for about 10 years now. And before I learned several other languages actively using. I also was doing some maintenance work for PHP or Python driven applications.

    Language purity is just one point. There are many others. See my posts The IDE and the libraries or Homogeneous programming style for instance.

    I am seeing it from a practical point of view as I am working in a smaller company where productivity is a key factor. And I have chosen Java – now – so it is still attractive from the current point of view without any old applications with already a Java history.

    Especially regarding the IDE and regarding homogeneous programming style I was disappointed from Python although I liked the language in general very much.

  16. ben Says:

    I would love someone to show me a study looking at the differences in maintainability between java and python/ruby/lisp et al.
    It has been our experience that the former is more maintainable than the others (comparing similar apps, 1Mloc java vs 150kloc python). The java app is easier to maintain simply because of the tooling support and the wealth of stable open source libraries.

    There seems to be a difference of opinion for those who think programming should be “the best tool for the job right now” vs “the best tool for the business long term”. We are in the latter camp after switching to rails early on and having to port everything back due to maintainability issues. Ruby is a dog to maintain due to monkeypatching.

    Anyone else?

  17. Martin Probst Says:

    Well, I’m under 30, and I’m reading this, and I’m mainly writing Java code.

    I like programming Ruby, and I like what I’ve seen of Python, possibly more than Ruby. I like some of the ideas in Scala, but I think Scala as a language has severely exceeded it’s complexity limit, already by now.

    I also really appreciate the good things about Java – and there are lots of them, not only in the JVM. I also personally like static typing generally, though it could be greatly enhanced in Java (structural typing for interfaces, local type inference).

    So yes, please go for Java 2 (in real version numbers, not Sun’s attempt at them).

  18. links for 2008-12-10 « pabloidz Says:

    […] Java is Dead! Long Live Python! The Cafes (tags: java python) […]

  19. lzap Says:

    Complete misunderstanding of two terms: code compatibility and binary compatibility. The author is mixing this and conclusions are irrelevant.

  20. oLdsk3wL Says:

    For me:

    – Java the best platform ever!
    – Java the language (syntax) is outdated. I also think that breaking language compatibility would be a good thing. Not to be cool, but to more clear and easier to read.
    – Java SDK. I am here with Stefan Tilkov, many pitfalls because of design mistakes years ago (Swing or Date & Time are good examples). Breaking it, would also result in a small JRE.
    – Java has exceptional performance. Actually, I think it is the fastest platform available. Many developers argue that performance is not so important, I disagree. Performance is always important and probably in a few years the trend will go back.
    – Java is far away from being dead, but I think you just took this title to get more hits :)

    I am currently doing a lot with JRuby and some Groovy. They are great, especially in the context of Web Development. My guess, Java will probably prevail as the dominant language on the VM, but it has to give up some shares to the new kids.

  21. robert Says:

    It was Bruce Tate, both in his book and blog, who said (paraphrasing), “java is the new COBOL”. The became true with servlet and jsp. In the Corporate world, accreting cruft on top of crumbling foundations is “the way it’s done”. There are COBOL systems from the 1970’s (I’m leaving such an organization in a few days) which now have “java” pixelated UIs (either applet or jsp/faces/etc.) running sequentially processed copybook code (if you know what that means, you know what I mean). Java will remain relevant in the Fortune X00 until those dinosaurs die. The financial services industry is the major offender. Good Lord willing, it will die, and take java with it.

    Building “normal” (where the user inputs data into some form, which is then processed) systems doesn’t require low-level languages, necessarily. Even the younger folk are figuring out that such can be driven from a database schema. Habanero/Oslo/LINQ, in the M$ world, are developing just that. With the emergence of industrial strength solid state disk subsystems, 3 or 4 NF databases no longer will be cloaked with the stigma of “it ain’t fast enough”. Nor will they be burden with the explosion of data from flat-file and xml datastores. There will be carnage. The database will do the heavy lifting (and not so heavy, anymore), and the Python/Ruby/whatever screen painter will do the user I/O.

  22. python rocks Says:

    5y ago I switched from Java to C and Python, I’ve never regretted the decision.

  23. Brett Says:


    “And perhaps there can be a new Java. Existing Java can be something like “Java Classic”, or “Java Stable” or “Java-doesn’t-break-your-existing-shit””

    Uh… what is stopping you from running your current applications on 1.6 (and probably even 1.7)? Do you expect those JVMs to suddenly break? Run your legacy applications on a legacy VM and start working with tools that let you get future work done _faster_.

  24. coffee snake Says:

    I use both Python and Java, and both have advantages and disadvantages.
    However since this article pours all the mud on Java, and none on Python
    let me add a few points where Java is superior to Python:

    1) Performance
    Python code is several times slower than Java.
    Where speed matters, writing Python code is out of the question.
    Global interpreter lock doesn’t allow multiple threads to actually
    run at the same time.

    2) Code analysis
    Try picking up a large body of code and analysing it, in Python vs Java.
    Because Java is typed there are actually tools to tell you who calls
    this function, how this variable is being accessed etc. Not possible
    in Python.

    3) Compiler finds many errors
    There is a certain class of errors that compiler catches for you,
    that’s not possible in Python even with pylint. Let’s say you have
    a typo in an if branch that only gets executed when you have a rare
    error condition, that you cannot cover with unit-tests.
    Guess what happens when that error actually happens.
    Python code blows up, just when you need it.
    While javacc reports an error during compile phase.

    If you want quick and dirty prototyping use Python.
    If you like to actually think a little before writing code,
    like what type of things would this variable hold? use Java.
    It’s more typing but results in more maintainable code.

  25. bwtaylor Says:

    It seems that every year or so somebody declares Java dead. Look at Tiobe. Java is #1, Python is #7. You’re full of crap to say java is dead. Moreover, any gains over the last few years that Python has achieved pretty much match the losses that Perl has had. Unfortunately, Python didn’t learn the lesson from Perl. Breaking backwards compatibility is the kiss of death. Your community will shrink if you dinker with it. Python just assured that the (rather small, by java standards) set of 3rd party libraries that work with python 2 all have to choose between either switching purely to python 3, maintaining both 2 and 3, or waiting and staying with 2. This fragmentation will be a drag that will assure that less total functionality is implemented by the libraries of either platform. This means your libraries will fall further behind compared to those of other languages. People who’ve coded to python 2 and want to upgrade can’t until all the libraries they use are ported forward, which may never happen.

    It’s funny to see people so gaga over language features. They’re unimportant compared to the health of the 3rd party libraries produced by the community.

  26. Jason Says:

    “python rocks Says:
    5y ago I switched from Java to C and Python, I’ve never regretted the decision.”

    Congrats… 5y from now you will still be jobless.

  27. Michael Easter Says:

    The premise here is that life requires evolution which implies “progress of new language features”.

    What if evolution can be defined in other terms? e.g. Java has evolved into a de facto syntax for systems away from the JVM: e.g. Google Web Toolkit and Android. Can one truly say such a language is “dead” with no evolution ?

  28. Russel Says:

    Most of what I love about Java is either very low level or mostly taken for granted.

    It wasn’t the first language to use a garbage collector. But it was the first to popularise the use of garbage collectors and the structure of Java bytecodes allows exact garbage collection. A point that is lost on a lot of programmers, especially the C/C++ variety.

    It insisted on run time checking of arrays. The #1 reason for security exploits in the real world.

    It insisted on the abolition of hardware pointers. The #2 reason for security holes and bugs.

    It uses a set of bytecodes designed such that correctness at the machine-code level can be determined algorithmically. Something you cannot do in most other languages. And that’s a property yet to be exploited in future operating systems.

    Anyhow, Python is fun. It has its uses. It has its faults. But its not the language we all hope for. The language that comes after Java. I sympathise with the frustrations of not breaking backwards compatibility. But I hope people don’t lose sight of those four things that make Java such a breakthrough.

    So here’s to Java mark 2. The Java we would have designed, given what we know now, but keeping those strengths of design and certainly avoiding the unsafe crap in C#

  29. Java : the perpetually undead language Says:

    […] coming out with statements of Java’s demise. But to see Elliotte Rusty Harold in his post Java is Dead! Long Live Python! do it caused me consternation to no end. You may want to check out his web page to get a sense of […]

  30. Five years ago Says:

    You started saying this five years ago, and no progress has been made.

    Also, Java is as alive and well as ever.

    We have closures, we have php running faster on a jvm than off one, we have dynamic scripting languages on top of Java.

    We have Java.

    Every day I see more elegant solutions to development problems in all spaces by using newer ideas, but it all gets back to simpler implementation and code – fewer bugs, better productivity and mapping 1:1 business requirements to development process.

    I have that today. I am not saying you are wrong about backwards compatibility – we have deprecation after all, we also have JVM speed-ups now and the world’s largest open source stacks are Linux / Solaris, GNU, apache, java / glassfish / tomcat+catalina / jetty, mysql and these are all very well aligned to keep growing together.

    Code will be runtime optimized, in VM’s. The worlds greatest, fastest, most reliable and proven VM is the JVM, by a huge leap.

    What we plug into the JVM, servlets, jsps, beanshells, groovy, jython, etc, or some other domain specific language you design, all adds to the value space of Java, not detracting from it.

    I hope a little light went on in your head, and I won’t make fun of you too much for suddenly writing a blog post that “you’ve worked it out” and want to tell everyone the clever news.

    JVM + awesomeness == JVM awesomeness, and I defy you to contradict that.

  31. Five years ago Says:

    As an addendum, I can tell you one dead language. Ruby. Rails has died and people are realizing it.

    Sure there is a micro-economy bubbling away but it will peter out as they realize their adoption bar on their business graph keeps stretching and real profits die away.

    Rails was one bag of magic coding that was just tripping up on itself.

  32. Elliotte Rusty Harold Says:

    A couple of further thoughts:

    1. On Python jobs: at least in the New York area, the demand for competent Python programmers dramatically outstrips the supply. I have seen projects that really belonged in Python written in Java for no other reason than that Python programmers could not be hired. I have also seen programmers who would have been laughed out of most Java shops have their pick of Python jobs because they were the best that could be found. (Yes, many Python devs are fine programmers. My point is simply that the difficulty of finding them means that employers will accept less experience and put up with more incompetence from a Python programmer than a Java programmer.)

    2. A different language running on the same VM is still a different language. That proves my point, not negates it.

    3. If the cow is big enough, one can feast off its dead corpse for a long time, especially if you keep pouring ever increasing amounts of barbecue sauce on top of it. That doesn’t make it any less dead. Sooner or later it’s going to start to stink.

  33. Ulrich Weber Says:

    Midlife-crisis, Rusty?

  34. Andrew Says:

    I agree with the criticisms levelled at Java’s cruft creep as a consequence of backward compatability, but as many other commenters have also said – this isn’t enough to make a difference for most people.

    In the long run Java’s advances and mistakes will be learnt from (e.g. the premature successor in the form of C# is doing some good stuff) but as the man said, in the long run we are all dead.

  35. Jimi Says:

    Backwards compatibility has become a millstone around Java’s neck. We’re deep and sinking fast. Until this millstone is cast off, and we correct the mistakes of the past, no further progress can be made.

    Nitpick: millstones are not what drag people down. It’s “albatross around the neck”.

  36. Tom Ritchford Says:

    The best jobs aren’t being offered on notice boards. You’re seeing a lot of maintenance jobs there and very few cutting edge positions – positions where the language that a couple of programmers use today will control the language that dozens of programmers will use on the same project in five years.

    I also agree that Java is in a poor state for all the reasons above. In fact, I believe that if Eclipse hadn’t come out, Java would be starting to collapse around now. Eclipse makes you pretty darned productive, and more, it allows people who are basically semi-programmers to generate useful work by using command completion to glue together predefined boxes. But it’s so verbose. Reading the code is quite slow because your brain runs out of “fast RAM” and you lose your mental representation about the first screen in a file when you’re reading the fifth one.

    But damn, Python is *fast* to write programs in. I’ve been at this programming thing for almost three decades and I’m still always disappointed in the huge time gap between the conception and the working program. But you can often sit down in front of a text editor and write a reasonable-sized Python program and get up from your chair with it all done *and complete unit tests*.

    There are a lot of fundamentally good features that make it fast: the extremely sparse notation, as simple as possible but not simpler – you should read the endless debates about why self is necessary in each method (a decision I agree is correct!) to see how close to the bone they will cut it; the fact that everything is a function and thus you can drop in a mock or fake at any point in your code(*); the fact that most data structures are either a sequence or a dictionary;

    The 3.0 move is simply icing on the cake. If there were a Python-based IDE then it would be the best thing since sliced bread.

    (* – Seems like every other function I write looks like def Foo(bar, baz, open=open):)

  37. Mike Says:

    Seconding “python rocks”, I also have been using Python+C for several years to good end. Specifically, Python is for the 90% of code that’s not performance critical, and C for the 10% that is. For the latter, Java is just too bloody slow, and for the former, Python is simply much more pleasant to write code in.

    To be sure, not all projects would fall into such convenient parts. Luckily, mine do.

    (Disclaimer: I started using Java during its first public alpha, but haven’t used it much in the last 8 years or so. The only thing that even sort of tempts me at this point is GWT…)

  38. a little madness » Devoxx: Future of the JVM Says:

    […] however, is the idea of versioning as an enabler to make incompatible changes. Even as the news of Java’s death continues to roll in, it appears Sun is looking to put a mechanism in place that will allow them to […]

  39. Mark Nottingham Says:

    Java is indeed a language for people who get their jobs out of newspapers or off of job Websites; always was.

  40. bubak Says:

    Good luck with Python, Java have things like Unicode from beginning…

  41. Elliotte Rusty Harold Says:

    The problem is the Unicode Java has had since the beginning is broken in various ways, and Java has refused to fix those breakages. They’d rather stay compatible with the original broken design.

    Python’s Unicode support had similar breakages, but now in Python 3000, they’ve fixed all that, even though it means the language is not quite the same.

  42. Aapje Says:

    What Java needs right now is modularity (slated for Java 7). That will allow API’s to be cleaned up and makes it far easier to manage big applicaties with hundreds of dependencies. That will make far more of a difference to most programmers than an improved implementation of generics or better unicode.

  43. Mark Thornton Says:

    It still isn’t possible to abolish primitives without seriously impacting the performance of some types of code. You can make them extendable as “value” types, but those still have quite different properties to regular objects. Sure, computers have got faster, but I still run jobs, written in Java, that push all 4 cores on my machine to 100% for extended periods of time.

  44. Pinner Blinn Says:

    I say go ahead and fork a NewJava, and make it perfect.

    “The language is too big, too complex, and too baroque.” To you perhaps, who have to write books about it. To me, it’s the best general-purpose language around. Powerful on the server and on the client. Not perfect, but perfectly suited to the tasks at hand.

    Backwards compatibility? If that means my applet will continue to run perfectly on all clients as they continue to update their JVM s, then, yes, that’s what I want in a platform.

  45. Andrew5 Says:

    Not to be “un-original”, but I would just like to say that I 100% agree with people like “Russell”, “Five Years Ago”, and “ben”. Java, like any language, has faults, but anyone who tries to tell me that Python or Ruby doesn’t introduce new faults of their own is either naive at best, or they are flat out lying at worst. The amount of backlash against Ruby/Rails is really starting to grow, not because Ruby/Rails is in any way a “bad” technology. On the contrary Ruby/Rails (& Groovy/Grails also) is extremely good at creating well structured conventional solutions with very little coding effort. But I have personally seen more than one project get scrapped from using Rails and re-written in J2EE when it became blatently obvious that Rails was not going to offer the maintainability and stability that the business required.

    The thing I find most compelling to this day about Java is that every time people starting thinking it was “dead”, one year later it showed its ability to adapt to the market and it always came back as being the flagship technology for low cost, flexible business solutions. Remember when we all thought Java would disappear because EJB 2 was such a dismal failure? But then Spring came along and allowed people to re-imagine how they used Java and it came back in FORCE!! With that came Hibernate (another ‘lightweight’ toolset) which, btw, forced the EJB community to totally rethink how they were doing things (which they proved when they brought our EJB 3).

    In short, Java has been “dead” many times before. And yes, if the Java community wasn’t willing to change during those times, then it truly would have probably died. But that’s not what happened. The Java community ditched what was broken (EJB2, and other heavyweight toolsets) and brought in newer and better ways of using the language (spring, hibernate/ejb3, the introduction of groovy, etc).

    So I’d like to propose the following for those who are interested. Instead of saying a bold (and, lets face it, untrue) statment like “Java is dead”, maybe we should just call it like it is and say, “Java WILL BE dead if we don’t adapt and change X, Y, and Z”. That statement seems to reflect history much better.

    This is why I don’t buy into the argument “Java is the new COBOL”. There’s a huge difference there in that COBOL did not try to evolve with change (or at least didn’t try very much). Java has already proven itself willing to make drastic changes to adapt where necessary. To that effect, I agree completely with people like JeffS:

    “And perhaps there can be a new Java. Existing Java can be something like “Java Classic”, or “Java Stable” or “Java-doesn’t-break-your-existing-shit”, or something, and the new Java can be “Java 3000?, or “Java-Way-Bitchin’” or “Java-has-latest-cool-stuff”, or, “JavaEZ”, or, ahem, “JavaFX”.

    Seriously, this new Java can be very similar to old Java, and integrate with old Java, but clear out old Java’s warts, and add the latest things that developers want to make their jobs easier – closures, proper generics, functional idioms, etc. Then there can be a gradual migration over time to the new Java.” – JeffS

    I think this is a superb idea! For certain, there are some core problems with Java that cannot be fixed without breaking backwards compatibility, but business will not go for it when you come in and say “We’ll need to rewrite this in Java ‘Prime’ (or Ruby, or Python for that matter)”. Trust me, I’ve tried. Businesses HATE to hear “convert” and “rewrite”. My boss is about ready to fire anyone on the spot to suggests that these days, and he’s not alone.

    So, instead, I think having a new Java ‘Prime’ that can integrate with existing Java code (with perhaps a little work) while itself fixing the core java issues is a great approach! And, just for you Python & Ruby/Groovy fans out there, I strongly recommend that any developer do themselves a favor and learn these languages too! They are great toolsets and have lots of potential for solving many problems. But sometimes, they just flat out aren’t enough and you need a more low level language (Java, C#, C++, etc) to do what you need to do. And in that case, I find Java, even with it’s faults, pretty hard to beat.

  46. robert Says:

    I don’t buy into the argument “Java is the new COBOL”.
    Businesses HATE to hear “convert” and “rewrite”. My boss is about ready to fire anyone on the spot to suggests that these days, and he’s not alone.

    You can’t have it both ways. The process of accreting ever more cruft on top of a soggy, muddy foundation of stuff is exactly what COBOL shops do. They were doing it the 1970’s when I started, and they’re still doing it. True fact: it was a large American insurance company CIO who blocked changes to COBOL ’74 because it would impact some ’68 code. It is this approach which makes java the new COBOL. I worked in that industry for the last eight years (no longer, phew), and there are insurance companies that refuse to upgrade from jdk 1.3. The American financial services industry (which is being exposed a tad these days) runs on 30 to 40 year old COBOL codebases; they don’t see the need to rewrite or convert to anything better. They are applying the same “thinking” process to their java code. The language is COBOL.

    It has been argued that java (specifically OO as embodied in java) has been embraced by the corporate industries *just because* it supports the COBOL approach of accretion of ever more cruft. From my direct experience, when I read that for the first time, it was epiphany time; of course THAT’S why they view the database as copybooks rather then tables. And, just for the record, where else is java used anymore? Not including phones, which isn’t really java.

  47. verisimilidude Says:

    +1 for ER Harold
    I just got off a two-and-a-half year job using C# and am back in Java land. I was suprised and impressed with what Microsoft has been doing with the CLI (the equivalent of the JVM) and disappointed (but not suprised) with what Sun has (not) been doing. Microsoft has taken Python and ML (OCaml variant) and made them major languages aboard the CLI. And where there were problems implementing constructs that existed in these new languages they have (it appears) modified the CLI and then modified their flagship C# to also offer these constructs. So C# now offers closures, SQL and set operations on collections and something like macro’s, derived (it appears) from Python decorators. On the other hand no language that I know of has tackled the death of the WMP interface as multi-touch moves from phones onto desktops. And I don’t expect to see that level of innovation from either Microsoft, Sun or Google (current sponsor of Python).

  48. The week in review - 2008-52 | Java Thinking Says:

    […] interesting discussion about the direction of java. Should we ditch backwards […]

  49. Angel Blue01 Says:

    For what it’s worth, I am 23 years old, just stumbled on this blog, and have a bachelor’s degree in computer science. I hate programming however, I’m an IT guy but they didn’t have an IT degree program until my senior year.

    Now, to Java, it’s one of the real programming languages I know to any extent. At my university, when I started, they taught freshman the basics of programming in C++, and most of the more advanced classes in VB.NET. My junior year they switched over from C++ to Java, so after having to learn Java, and discovering it was nicer than C++, I took operating systems in Java using Eclipse. And that’s it, except for one semester of Web development (XHTML/CSS, Javascript, ASP.NET), one semester of UNIX (including basic Perl and C). The database classes were in (T)SQL of course, with some VB.NET. So basically what I picked up was that as far as application development is concerned C is for UNIX (commandline only), VB.NET/C# for Windows (GUI), Java is for cross-platform (GUI as well), Perl seems to have no reason to exist.

    Python? That’s just a snake. 😉

  50. Barry Says:

    @Angel Blue01

    I am not sure what kind of school you go to.
    But as far as I know, none of elite CS school teach OS in Java….or even offer courses on XHTML…

    Computer Science is about algorithm, concurrency, graphics, ai. What you did was more like a Bachelor degree in Programming.

  51. Barry Says:

    Yes. Python is just a snake.

    But, it happens to be a snake favored by companies ,like Google.

  52. Rushen Aly Says:

    I think, with GIL limitation Python will not live so longer in this multicore century. Java will gain its power again with multi cores. I hope wizard of Oz can help python…

  53. Liam Knox Says:

    This is article is particularly brain damaged. To claim Java is Dead is just insane. Sure it has its problems but the core fact is it is the most successful industrial strength lanaguage on the market. This is shown in adoption in even industry, front to back. People actually think about maintaining backward compatability seriioursly , unlike this author. Python is just another one of these Toy language , Ruby , Pearl , Php etc that find a niche in some areas but are no good for hard core distributed based computing and fall apart becauase they lack structure in many fields.

  54. The Java Developer’s Dilemmia « Echo One Says:

    […] for a long time and you are happy to be the one maintaining the legacy apps in their twilight. Elliotte Rusty Harold has it right in the comments when someone says that there are a lot of Java jobs still being […]

  55. chromatic (chromatic) 's status on Wednesday, 29-Jul-09 07:45:17 UTC - Says:

    […] Lessons for !perl 5 from !java: […]

  56. Nathan Says:

    I must say, you’re quite wrong is your Java 5 assumption of breaking code – for one thing, you start by complaining it breaks downward compatibility, and then a few sentences later you complain that there even IS software complexity. I’ve compiled code from as far back as Java 1.1.8 without ANY issues. Seems rather backward compatible to me – not too sure what you’re referring to there.

    Generics? Doesn’t break anything. If you don’t specify the type to use, it defaults to the top-most generic type anyway. Doesn’t break anything, but adds quite a lot of usefulness if you CHOOSE to use it. Not too sure what your issue there is.

    As for closures? Who cares? Overrated. Anonymous classes work just fine, and are more predictable anyway. JavaStubs uses it to great effect without the need for the alpha-and-omega that is closures.

    As for complaining about it’s size – okay, fair enough, but Sun had to do that to expand the basic offering of the core language. It’s called being feature rich.

    Finally – dead? Sinking fast? Maybe you should actually evaluate the landscape before making absurd statements:

    My sources show a language that’s in a very healthy state, usage-wise. Love it or hate it, there are still plenty of things you can do in Java that you simply cannot do in other languages.

  57. sj Says:

    Are people still using python?

  58. Mike Says:

    I read most of this and I’m 47 year old(over30).

    Actually i’m glad they keep Java backward compatible instead of breaking everything as other languages do; i have to keep putting out software and not fixing incompatible code which would make be late getting home each day.

  59. Akintayo A. Olusegun Says:

    and I used to respect this guy, this post is a blunder man.

  60. Java Worker Says:

    I develop Java code for companies in sectors such as finance and insurance. These companies usually have millions of lines of Java code, a lot of the code is often quite aged and has been through the hands of many programmers. In spite of this the code in general is surprisingly maintainable and extendable. I attribute this charactaristic to the general traits of Java code. Java code is generally very verbose and readable, dosent allow too many styles of code but still has a good balance of expressibility – something you learn to love when you dont have the luxury that smaller projects have to start from scratch. Java applications generally have very good error handling and the code is robust. Java programmers have for more than 10 years had a strong tradition of documenting and using Design Patterns – it makes me easily recognise the the design when I have to maintain and extend other programmers code.

    What makes Java so maintainable and extendable is also about the staggering availability of APIs, Frameworks, solutions and tools. I have never had to tell a customer “it cant be done” or “it can be done but first I have to reinvent the wheel”. If any changes were made to Java suchs that it was no longer backward compatible I would stand to loose what… 50-90% of all those APIs and Frameworks available today?? and Java would become just as useless as Python, C/C++ and many other languages for building enterprise scale systems. It also deserves mention that Java a few years back entered a golden age of development tools – can any other language boast a lineup like netbeans/idea/eclipse/jdeveloper?

    Why would the “warts” of the java language such as primitive types have any bearing on its future? Python has different warts – so what? My customers are conserned if they can keep extending their codebase, if it will scale to twice as many users next year, if developers are sufficiently skilled/certified/available, if the brokers pushing the developers/consultants to customers know what they are selling, if the platform has good tools to enable productivity. I have no particular desire to code Java for the rest of my life but I dont expect Python to challenge Java in any near future. The only way to kill Java through the language design itself is to stuff the language with so many concepts (functional programming etc) that an average joe programmer will find it too complex to extend the code I leave behind.

  61. dhruvin Says:

    I m 20 years old…Fresher currently working on Struts & Hibernate..and one of my frnd went for python and he is regrating it due 2 no jobs in it..i just wonder what is the future in java struts hibernate etc…wat shuld i do for future??… 😕

  62. Emil Koutanov Says:

    Dear author,
    When you say “Today primitive types just complexify the language to no particular benefit.” it shows that you have no understanding of performance computing. What facts can you present to back you claim?

    Primitive types are “primitive” insofar as they don’t require the instantiation (and subsequent destruction) of an object just to represent a scalar quantity that may be only 4 bytes wide. To employ full class semantics when all you want to do is to read to and write from a 4 byte contiguous chunk of memory is like killing a flea (not even a fly) with a very large sledge hammer. In terms of detrimental effects on performance, compile and run the following code:

    public class AutoboxBenchmark {

    public static void main(String[] args) {
    final long start = System.currentTimeMillis();
    final long RUNS = 1000000000;

    for (long i = 0; i < RUNS; i++)
    add(i, i – 1);

    final long took = System.currentTimeMillis() – start;
    System.out.println(String.format("%d runs took %.1f seconds", RUNS, took / 1000f));

    // private static Long add(Long a, Long b) {
    // return a + b;
    // }

    private static long add(long a, long b) {
    return a + b;

    First run it with the method that uses primitives, and then with the one that uses object types. The performance difference is more than substantial.

  63. Elliotte Rusty Harold Says:


    You’re demonstrating ignorance of modern compiler and optimization technology. Primitive types are primitive in that they do not support subclassing, method invocation, and other features of objects. How they are implemented is a detail. There is no reason the code you present cannot be implemented with object types that do not require allocating more than eight bytes per long. Indeed, if Long were the only type a good compiler would produce *identical* byte code to what you’d get from compiling the above. javac just isn’t that good, and the language spec doesn’t really allow it to be that good. :-(

    The code you present can be quite fast in languages with no primitive types such as Eiffel. Java doesn’t do this for reasons of backwards compatibility with a language designed 15 years ago. Do not confuse the limitations of the Java VM with fundamental issues. Java made compromises in its type system it shouldn’t have made because its inventors weren’t sufficiently familiar with the state of the art in object oriented optimization. The state of the art has only advanced in the 15 years since Java was released. It is precisely Java’s refusal to change the language to support modern constructs and optimizations that killed it.

  64. Objective P is like a neutron. Says:


    Whell i dont tink java is dead at all(it is more like a unstable finnacial chart that goes down and then upp like a rocket), still its in use all the time in diffrent companies.

    Java aint COBOL(alltho some pepole seems to se it as COBOL when looking at java)

    I tink that java could need some cleanups(as many other have stated), but the bottom line is that it works for the present tasks avable today, i tink i just need to say the old but so true phrase “a professional programmer is by widely defenition one who charges pepole/companys for money in exchange for some code” it dossent nessesarelly saying that this programmer is good. infact i dont know any by defenition good python programmer(currently) all again(so called top-notch) python programmers extensevly use fuctions that in the end is (native) so basicaly its uncontrolled C since they ofently dont know exactly what C python will use in the background (maybe its a little arrogant to make this to be just C but in general).

    Young pepole especially(i am a young man,i am also an exception to this, i am 20yrs old atm) seem to tend to see java and old languages as “BAD OLD SHIT” becouse it wont produce a pretty game or other tings in a fast and to the eye a clean way. As some has stated Python has its advatages/disadvatages, but in the Real World python or any of these other Candy languages dossent seem to cut it becouse of triveal reasons like MTBF factors witch i think is a big concern that pepole has left out in this discussion/review when it comes to python, yes Java can be Resource consumeing(with a extra ! on the R) but the good advantage is that it IS exceptionally whell working in Real Time applications and in general systems and so on. python however(not saying that python is bad in general) dossent cut it i dont know any programmer that works withtin big coporations or anyting critical that says “you know python works” take mobile phones for example a common ting i hear from the industry is “shit we let some super python programmer do some python code still ist explicitly buggy alltho the programmer is the best you can find for money” then the end of the line is “Woops instead of hireing a programmer for a hire salary that would give us a direct working emedded java like system for a total cost of $xxx the total cost now with all fixes is $xxxxx. i think this resembles alittle of the atitude when ADA arrived, the line is why use C when you could use ADA that was from a practical standpoint undefinable many times better, whell i heard of some old pepole back in those days the old and true saying “it is not a technical problem it is a political problem reffering to the internals of the company” resulting in code that took more time to get working and in the end costed undefinable more $.

    As a coclusion i would say that yes Candy languages is prefectly fine when it comes to short lived applications like a homemaid program that runs a calculate once then display fasioned program but its not suited for most programs that is programs who will have a runtime lifespan for hours or so. or applications that will cope with extensive ammounts of third part extensions, embedded devices is an excelet example in that matter.

    I recomend Java over python in terms of “lifespan” and “general concistecy”

    I recomend Cady lanuages (python and so on) for maybe general personal day use NOT FOR SERIOUS APPLICATIONS(tink resonable here)!

    And to all young programmers lets say <30(college educated or not) try out all common languages and get your own opinion in terms of (feel/style and sutch) not in (technical specs becouse most pepole doessent understand the tings under the hood really!, that icludes college students in various programming flavours trust me) please dont ask all the time WITCH LANGUAGE IS THE BEST! OR SO! its just so personal and location and purpose dependant.

    Sorry for all the bad english and sutch im tired as hell.

    My favorite langs are(ASM,Fxx,ADA(defenatly best language in exsitence(with ASM OFC) yet but it could need some extra librarys but that will come ie for graphics)

    Languages i can understand exist becouse of the human factor/time (C,C++(altho C is way cooler than c++),Pascal and so on)

    Languages i dont use since practical problems mostly requires more reability is: Candy langs(python and so on).

    Last but not least Python in real life may save you time in the moment of programming(if your not a vet ofc) but in the end all candy langs cost you more $ than java like langs becouse of various mentioned problems.

    Yes i personally beleve that Python is as most other langs a Hello – Goodbye story,(a sleasy lovestory).

    Best Regards Mr. R

  65. Objective P is like a neutron. Says:

    “”””Woops instead of hireing a programmer for a hire salary that would give us a direct working emedded java like system for a total cost of $xxx the total cost now with all fixes is $xxxxx.””””

    Woops let me clarify it should be higer not hire

    And when i mean back in the old days i mean the pepole that programmed in that time period not ME

    thats a woops.

  66. Young FOOL! Says:

    WEEERY long post there Obj P, alltho i am guilty of the young ppl problem,
    I LOVE PYTHON REALLY! but i never get superbe applications out of it NEVER!

    Its perfect for nice @home tasks ie smal physics graphs.

    I tryed java but i tink that it is quite hard ecspecially all interfaces and inheretance moments.
    Alltho i tink this Author is a nutcase: java is dead now that is indirect advertiseing.

    Only major problem i have with Python is that to to most useful tings i need to get that extend this and so on and yes my java programs works mutch better than my pythons, but dont get me wrong i love my snakes!

  67. ansi_c_still_rules Says:

    After java, python and come and go, C will still be around. And why is that? Simple. Because it’s not a huge, big bloated language. It’s simple and you can’t match the speed. Yeah I know.. some of you weird java nuts still will claim that java beats C++ or even pure C. fact: A hand-tuned machine lang. program still can’t be beat. And a highly optimized and tightened C or even C++ program is as close as you’re going to get to that and still runs circles around the best written java programs.

  68. Emil Koutanov Says:

    Dear Elliotte Rusty Harold

    >There is no reason the code you present cannot be implemented with object types that do not require allocating more than eight bytes per long.
    No, no reason, but having all other objects point to this object that is simply a wrapper for an 8 byte long (additional dereference) is rather excessive, wouldn’t you agree. If you think boxed primitives are sufficient, you need to get some experience with signal processing.

    >It is precisely Java’s refusal to change the language to support modern constructs and optimizations that killed it.
    Wake up. Java is the perhaps the most relied on language in the world. One of the reasons this is so is because Java is not a “dynamic” language – its a language that is built upon solid compile time checking as opposed to Python that is scripting language – nothing more, nothing less. How many critical applications (banking, finance, etc sector) are written in Python.

  69. Elliotte Rusty Harold Says:


    You still don’t get it. There is no wrapper type. There is no extra overhead. Longs and ints can be implemented with full object semantics without any additional runtime overhead compared to how primitives operate in Java today. Autoboxing as implemented in Java today is way behind the state of the art. Eiffel has been doing this for over a decade. All you need is a smarter compiler and a slightly different language spec. No VM-level changes are required.

  70. Emil Koutanov Says:

    Hi Elliotte,
    I’ve been long enough in the language and compiler design business to understand what you’re saying. Yes, we don’t need to box types to give them object-like semantics. But it appears to me that in order to distinguish Python from Java, you are hanging your hat on that, and a couple of other esoteric things.

    What you’re lacking is the understanding of the broader picture. Gone are the days of “cowboy” style software development. When you have to write a lot of software (and I’m talking about project scope varying from 100 KLOC to well over a milllion LOC), the language selection is crucial. Java facilitates software evolution because of a number of things, some of the most important being compile time type safety, especially since version 5. The more problems can be found before deploying – the less defects are likely to manifest themselves in production. Ever wondered why ADA is a milspec language, and why Java is found in just about every new financial app in the world? This is what many proponents of highly dynamic and loosely typed languages like Python and Ruby fail to realise. They want flexibility, but what they end up with is unmaintainable chaos. Ask yourself one question: would you fly in a plane with its avionics suite written in Python?

    I don’t berate Python. I think it’s good for what it was designed for. Certainly, building a console based app to do something quick on Linux in Python beats Bash any day. But let’s not take it outside its “flight envelope”.

    Oh and just one more thing. The statement “Java is dead” is among the most absurd I’ve heard in a long time. Please don’t say that again.

  71. Burningk Says:

    I have to disagree with this title. Just in, new Blu-ray discs and DVD players and set top boxes have been staged on Java. I believe Java is far from dead. In fact it’s almost like a “baby boom”.

  72. Hello Says:

    Java will always be better than Python!

  73. Hello Says:

    I agree!

  74. Hello also Says:

    I just agreed with myself

  75. Martin Wildam Says:

    In reply to ansi_c_still_rules:
    > some of you weird java nuts still will
    > claim that java beats C++ or even pure
    > C. fact: A hand-tuned machine lang.
    > program still can’t be beat.

    This is not necessarily true. I talked to a member of the JVM developer team and discussed that. Fact is: Most programmers (even C++ programmers) do not really write optimum code – they can’t, because optimum code would – just to give an example – involve a lot of copy & paste instead of function calls because function calls are expensive. That would cause the code to be very awful and not maintainable. On the other hand the automatic optimizations done by the Java compiler or JVM often do a really good job because on compilation such optimizations can be done. Next: The JVM does optimizations at runtime based on application use (“warmup phase” for server processes) – that means if two customers are using your application in different ways, different optimizations might be done. That dynamic is not available in your C++ code optimized by hand.

    Of course, if you know exactly what you are doing you might outweigh AI compiler optimizations – but this is not what in the real world happens too often. IMHO: Basically C++ and Java are both very fast and faster than many other languages (if not faster than most). With both languages you cannot be really wrong if performance is important for you (except for small commandline apps where Java does not really fit).

    Read more about Java performance at popular Java myths and Java applications on the desktop.

  76. g Says:

    but how about now? since oracle already take over Sun…

    sigh… i feel sad when someone said ‘no java programmer’ here… :(

  77. _ Says:

    C is the language of hackers.
    Bring it to the point.
    Java and python all comes later in life.

  78. Burningk Says:

    Java is still around. Android and BlackBerry smartphones run on Java. Java just keeps winning in the popularity contest. Have a Cup of that.

  79. Mike Says:

    I think the reason why he has chosen to goto python because it supports UTF-32. Java only supports UTF-16 at the moment. Python coding is for the 80’s. Java is newer, why work on python when Java is much newer? If any language that is good why don’t they just bring back Assembly Language? Takes longer but the coding is the fastest. I’m sure thats why Linux is widely used and as well for Playstation.

  80. antred Says:

    Abandoned C++ in favor of Java?? Speak for yourself, lad. I’d rather poke my eyes out with a rusty nail than go anywhere near the abomination that is Java.

  81. richard bucker Says:

    I’m not sure if the point has been made, however, as wonderful as P3.0 is; until it is included as the default python in most OS’ or until python truly supports multiple concurrent versions in a same model it will be very hard to move on. Perl will have the same problem.

  82. James Says:

    Although i am not a Java advocate (a C++ programmer ) i have to say this is most idiotic, obscure and funny article i have ever read. Saying Python (or any dynamic language ) is better than Java (or any static language) shows the lack of maturity/experience on your part and it seems you are suffering from fanboyissh syndrome ( common among scripting language programmers).

    “Java in favor of more nimble modern languages like Python just as we abandoned C++ in our youth in favor of Java.” Abandoned C++ ??? wow thats news to me

  83. Mark Says:

    *ROTFLMAO* Classic arrogant blogger without a clue.

    Android is Java, Java is Android. Ironically after almost 2 decades, Java is finally on devices for which it was originally intended.

    I found this page because I was looking for a info on Python and a dead(). The book I am using to learn Python, for fun, made the comment that if anyone told you NOT to learn Python 2 you should ask them if all of their production code was P3. If not, wait the 10 yrs it would take them to convert it, and by then P4 would be out, and learn that.

  84. Adrian Says:

    I hate Java not for the language but for the clear fact that HR and dull-witted managers expect one to know the latest secondary APIs or libs whenever they come along. A competent developer would have seen problems, suggested solutions and written corporate class libraries years before they were officially released. Whether its thread-safe and unsafe collections or web frameworks prior to that horrendous EJB crap.

    With C or CC++ that obsession with the latest and greatest doesn’t exist. I think its because no single company is guiding C/C++.

    Java is not only a language but a product of a distorted marketing machine. It offers slogans and branding all the way along. That tricks feeble managers and programmers faster than pharmaceutical reps convince doctors by way of golf and hand-jobs.

    Java, stripped of the bullshit is actually a great language.

  85. Peter Says:

    I used to code and publish software products for both MVS and the Unix platform in C and C++. About 1996 I tried to switch to Java, but it was extremely difficult. The C language takes significant skill to do right, and you do have problems on projects with large numbers of people due to different coding techniques… anything that is runnable anywhere and makes our job easier – I’m all for. That said, our company decided to switch to java, but I just never “got it”. Neither did the other guys on our team. I completely understand OO techniques and it was fairly straight forward using C++, the first problem was that I just couldn’t remember and digest all the different types of file access methods. While it is tedious in C, java just replaced it with a zillion different types of file access methods. What was even worst, it seemed that the problem I was trying to solve was buried under all these new concepts that I started losing focus on what it was I was trying to solved. I’ve been programming MVS assembler, cobol and now (CC++) wiith ease MVS and Unix for 12 years (as of 1996), and when I arrived at java, I hit a brick wall. For many years, there was this huge advertising campaign by Sun touting all these features that I couldn’t figure out how to use, or find a situation where I could use them. Some people on this post say they love the language, but I even had trouble with that. By far, the absolute best language ever invented was IBM’s rexx, and now netRexx on the java platform. I’m considering using it going forward, but the downside is it doesn’t have it’s own file handling or socket (network) abstractions that say Python does, so it sort of makes you use java’s libraries as they are.
    I don’t know you guys do it with java….perhaps I as born and raisded in a different era. Strange though, Mike Cowlishaw (inventor of Rexx/netRexx) seems to understand it, so maybe I’m just burned out.
    Good luck to you.

  86. xxx Says:

    Java died when Oracle bought Sun.

    Best to use an open source language.

  87. anafa david mudi Says:

    Hello guys, i really appreciated the discourse for and against python. However i wish to ask a question, i wish to learn how to use my knowledge of python to develop andriod apps, what do you think? is python made for that also since i heard that Java is better for it. thanks

  88. Lukasz Says:

    Python is a scripting language and good for small things (like a Basic was a decade ago). Lack of compile-time checks precludes it from being used in more complex applications. If one needs a dynamic language, why not to choose Groovy, which provides type safety?

  89. Getters and Setters: Code smell, Necessary Evil, or Can’t Live Without Them | Ask Programming & Technology Says:

    […] seems to be a common occurrence with Java, less so with Python. I’m beginning to wonder if this is more of a cultural phenomena (related to the limitations of… As I do not program in Java (currently by choice) I cannot make that […]

  90. Eliphas Grote Says:

    It’s entertaining to read this old post from the far future world of 2014. Your enthusiasm for breaking backward compatibility would perhaps have not been so great, had you known how things would turn out. People were (unsurprisingly) reluctant to rewrite huge existing codebases, and stuck with Python 2. So even though I know Py3k is a much nicer language, I’m still writing Python 2 because that’s what my users run and that’s what the libraries support. Python 2 EOL has already been extended by 5 years to 2020, and will doubtless be extended again. (Either way, enterprise distros will have to keep supporting for a few years beyond official EOL.) Meanwhile, PEP 466 has cautiously unthawed the feature freeze on Python 2.

    So, yes, keeping language warts for the sake of compatibility is annoying. But Python 3 provides a sobering glimpse of what *would* have happened had Sun followed your advice. Yes, you get a much nicer shinier language, but unfortunately most people have to keep using the old one.

  91. mithun Says:

    python is better than java

  92. Python:What kind of things can be done with Java but not Python? – IT Sprite Says:

    […] Java is Dead ! Long live Python […]

Leave a Reply