Slashdot Mirror
How Java Changed Programming Forever
snydeq writes: With Java hitting its 20th anniversary this week, Elliotte Rusty Harold discusses how the language changed the art and business of programming, turning on a generation of coders. Infoworld reports: "Java's core strength was that it was built to be a practical tool for getting work done. It popularized good ideas from earlier languages by repackaging them in a format that was familiar to the average C coder, though (unlike C++ and Objective-C) Java was not a strict superset of C. Indeed it was precisely this willingness to not only add but also remove features that made Java so much simpler and easier to learn than other object-oriented C descendants."
Why does it feel like Oracle is advertising Java with these stories...
20 Years of write once and test everywhere! And now thanks to Android there are over 18000 distict Andoid platforms to test on too!! http://thenextweb.com/mobile/2...
I for one salute out software testing overlords :|
Build a Man a Fire, and He'll Be Warm for a Day. Set a Man on Fire, and He'll Be Warm for the Rest of His Life.
While Objective C is. You insensitive programming clod.
Sent as ripples into the electromagnetic field. No single photon has been harmed in the process.
Maybe it's the applications. As you note, we have proved, time and time again, that in contrived scenarios Java code can meet or even beat the performance of so-called "performant" languages like C, C++, Lisp, VB6, or JavaScript. And when presented with such evidence, most sane, open-minded opponents will hang their heads in shame and promise never again to spread such slander.
...but then, they fire up Eclipse, or NetBeans, or Guiffy, or enable the Java support in their browser, or try to run an app on their favorite feature phone. And they wait for it to become responsive...
...and wait...
...and wait...
...and wait...
...and wait...
...and...
...what did I promise never to do again? Sorry, must have dozed off...
"I decided I could write something better than everything out there in two weeks. And I was right." - Linus Torvalds
Forever is a bold claim. What about after the apocalypse? What about Planet of the Apes?
Are we making the Java manuals out of IBM keyboards or something?
"...turning on a generation of coders."
I'm glad to hear someone finally having the courage to admit this. Especially considering how widely it has been adopted as an instructional language and how many young people were betrayed by their institutions and communities at the very start of their programming careers.
But I'd also like to hear more from the many people who've risen above these challenges and gone on to become developers even so. It may be hard. It may be traumatic. But it's good to remember that it's possible to rise above it.
Yeah. When I saw in which direction Java was going, I thought to me: "thanks, I've had COBOL once, Don't need a second serving"
On a slightly more serious sidenote, it's easy to see Java's popularity dropping, since Google seems to be dumping java for high performance javascript/dart development, as they have already been announcing for Android.
http://arstechnica.com/civis/v...
Linus has actually stated it in a way that is frequently seen as toxic. But, while C++ is one of my favourite programming languages, certain language features tend indeed to "rotten" people's brains, just like pre-GIT CVS+derivatives did to source control habits. And I find that Java is actually the perfect representative of that nowadays, not C++ (and even Linus is now commiting patches in C++) I don't know what you guys people but when I have to traverse a tree of 10 folders, and files have 10 lines and exist only for a single abstraction's sake, I kinda feel OOP, though a powerful tool, has been overused. When everything has to be an object just for a paradigm's sake, things can get kinda distorted. One of the greatest programming innovations is, in my opinion, MVC (or even MVVC stuff like Angular) is one of the greatest things that have been getting popular lately. By separating logic from models and views people are encouraged not to create stupid abstractions and use procedural programming where it is adequate and avoid performance losses.
(proof that torvalds actually uses C++ if anyone hasn't seen that: https://github.com/torvalds/su...)
"I decided I could write something better than everything out there in two weeks. And I was right." - Linus Torvalds
I have endured java written apps all these years. Insane requirements to keep multiple versions and a most horrible cludge design required when using version specific java based tools from cisco , hp, brocade. Hands down above anything else, java is the number one thing I take out with my time machine.
I don't have any philosophical issues with Java, but the "simplicity" of it has led to software vendors thinking they can hire simple people to write mission-critical software, with terrible results.
At work, we have several pieces of server software written in Java, and they are just awful. The RSA server, an auth server from Cisco, and others. They crash when the wind blows the wrong way. They bloat and need to be restarted every few months. One executable starts multiple network services on multiple ports. They rely on using dozens of threads with dozens of queues, and there is no way to inspect them. Logs show high volumes of Java call traces and error messages, even when the software is running fine. Sometimes components just stop working, we call the vendor, and the vendor instructs us to restart and/or reboot.
With the RSA server, we had a massive outage one time because an admin kicked off a few reports. It turns out the reports hung a few threads, and took down the service for the whole enterprise.
The Cisco server has the same problems: dozens (hundreds?) of threads with dozens of queues, and the synchronization among the threads just doesn't work 10-20% of the time.
It's not just these servers. In a previous role, we had some Java middleware that translated DIAMETER RADIUS in a service provider setting, and that was it. That software blew up every month or two, and we had to fail the service open for all our customers.
Terrible, flaky, unreliable software. Again, I think it's probably not the language, it's the shitty, shitty programmers.
But, hey, it's job security for me!
In contrast with other languages...
I find a better IDE for different and I was like, how about that, this makes it easier for me to write code for the language.
If back in the day where you had GWBasic
Ok
LIST
10 PRINT "HELLO"
20 GOTO 10
Ok
15 PRINT "WORLD"
Ok
LIST
10 PRINT "HELLO"
15 PRINT "WORLD"
20 GOTO 10
Ok
15 PRINT "WORLD!"
LIST
10 PRINT "HELLO"
15 PRINT "WORLD!"
20 GOTO 10
Ok
RUN
HELLO
WORLD!
HELLO
WORLD!
HELLO
WORLD!
HELLO
WORLD!
If we had that type of IDE today the program will fail miserably. However you take the same language and give it a new IDE then you could in theory make an Enterprise class application in GWBASIC.
If something is so important that you feel the need to post it on the internet... It probably isn't that important.
>> One thing I'll never understand is how it practically requires an IDE to do anything non-trivial, in contrast to any other language.
Hate to break it to you, but if you don't need IDE for specific language. You need IDE for large project. Regardless of the language used.
I've tried to get into Java on multiple occasions. Each time, I get thrown back by the amount of boilerplate necessary, and by missing features.
- No operator overloading. As a result, every container type is accessed differently. Arrays use []. Lists use At(). Hashmaps use Get(). Matrices, vectors, and complex numbers are absurdly verbose, because I cannot overload addition and multiplication.
- Type erasure for generics. As a result, I cannot define different function overloads for func(List) and func(List).
- Lack of first class functions. As a result, callbacks required the absurdity of implementing the Callable interface. This has been improved recently with the addition of lambda statements.
- Lack of properties. As a result, I cannot expose anything as public, because I might want to add additional code at some point in the future. Therefore, I must have an explosion of getters/setters.
I like the idea of having a sandboxed virtual machine. I like the idea of having a single version of the bytecode that can run anywhere. I just can't stand the language.
Sounds to me like it should be...
"Java: the language that changed the art into the business of programming." Not so many fancy or clever solutions in Java. Takes a lot of the fun out of it.
I can see it now, another thousand posts on how Java is terrible posted by Dunning-Kruger kiddies and get-off-my-lawn fogies. This is exactly the behavior that holds the profession back from maturing, a disdain for understanding history in context alongside those that cannot understand evolution and what drives it (or are simply acting out of fear); that and flat out shitty engineers.
Too many stupid comments that can't separate the Java language from an application (applets), from usage (development trends and or enterprise patterns that lead to verbosity), vendor implementations (I had to maintain multiple versions because a vendor wouldn't upgrade), tooling (eclipse is slow), the platform (the JVM).
C is slower than shit too, if you launch a new VM every time you want to run a program. Of course in the real world nobody does that, just like, outside of desktop apps, nobody starts a new JVM every time they run some Java code.
I take it you haven't worked on a large scale software project? Abstraction exists for code re-use and to make parts pluggable, both of which are critical in reliable enterprise software.
But maybe I don't want a language that turns on me.
I remember having a Java developer rip out a three line loop I wrote and replacing it with some 2MB Apache Commons library so that we weren't "reinventing the wheel."
My favorite thing about Java developers is Maven, otherwise known as the "let's download random code from all over the Internet and just run it without bothering to verify it in any form!" tool.
According to Joel, Java isn't hard enough to weed out mediocre programmers in college. (Great programmers can use any language well.)
If you reply, do so only to what I explicitly wrote. If I didn't write it, don't assume or infer it.
In the years I've done Java development, the only times I've never had a problem building on Windows or OS X and deploying to Solaris or Linux was when someone used hard-coded paths or didn't make the program's deployment properly configurable for deployment to the target OS. Write once, run anywhere is more or less true with Java.
And then, they try to fire up Microsoft Visual Studio, and they wait even more, and they realize that their perception bubble isn't reality.
Indeed, I've been using Eclipse as a daily driver for a decade. Current startup time for a new workspace is on the order of 10 seconds, VisualStudio is almost identical.
XML is a known as a key material required to create SMD: Software of Mass Destruction
You need IDE for large project. Regardless of the language used.
The OP is still correct about Java. "Non-trivial" is not the same as "large project." Small applications can be written in Python, Ruby, Perl, and C without an IDE, but writing a small application without an IDE is really difficult task in Java (and C# or basically any other .NET language, fwiw - Java's not alone) due to the strong dependence on boilerplate code.
Further, you do *not* need an IDE for large projects regardless of language. I've seen a number of large projects (tens of thousands of lines of code) written in C and Ruby where more than half of the developers did NOT use an IDE. In fact, for the C projects on which I've worked recently (last 10 years, including those with tens of thousands of lines of source), the primary code editing tools used by the developers were exclusively text editors like nano and vim - there is no IDE during development.
Funny you should mention MVC since it's one of the lead causes for many number of files and directories in typical java-applications.
If you're truly separating your logic, it makes sense to really separate them and not just pretend?
The reason people abstract everything is intellectual laziness and lack of design. If you need some abstraction, why not do it for everything, you know? Just to be "safe"... As a society, we value the "safe" and "correct" choices by copying other's success, while those who make fortunes and make their own success do not.. We're simply herd-animals still.
However, I fully agree that requiring all that separation without really utilizing it, is simply wasted effort. A more agile way, ie. using Feature Driven Development (FDD) you would only redesign/refactor the code this way when truly required, focussing on core functionality first and foremost.
OOP-paradigm is over-used, over-extended and has always been over-hyped. It's just that in the late 80's, early 90's I was too young and inexperienced to understand the healthy criticism that were put forth by professionals at that time. OOP's simply become yet another excuse for not thinking clearly and not taking the time to really think.. OOP never became the Silver Bullet many pretend it is.
For those who wants to go forward, the new paradigms that will come is the marriage of graph-databases and functional programming. However, it's not been properly invented yet, so might have to settle for in-house designs and solutions still (only IF required / best-fit solution!). What you can be sure of is that the breakthrough will be something generic that everybody can blindly follow.. If done properly, it should unify applications, storage and caching, while supporting concurrent, high-availability systems.
Or maybe future systems will be more specialization? One never knows 100%..
The IDE is so that management can hire ignorant monkeys and expect that the IDE's wizards will produce quality code rapidly and cheaply. Which, of course doesn't really happen since wizards are like the dock that carries you far out over the lake. And then ends before you get to where you really need to be. The IDE then allows ignorant monkeys to produce abominable-quality software. But hey, it was fast and cheap!
You can edit Java code all day long in Windows Notepad. An IDE in capable hands merely makes the clerical services more convenient. It's just a pity that capable hands aren't valued much these days.
> you could in theory make an Enterprise class application in GWBASIC.
In theory you could make Enterprise applications in assembly language. Or write the direct machine instructions in Hex. An IDE might help. But the language you use also plays a large part. Perhaps larger than the IDE. The IDE is a lever that helps leverage the power of the language that you start with. If the language you start with (GWBASIC or machine code) isn't that high level, abstract or powerful, then the IDE can only help you leverage what you have, which isn't much.
I'll see your senator, and I'll raise you two judges.
I was struck by the statement that Java "changed the art and business of programming." While that's certainly true as a general statement, it hasn't been true for me personally. I've lived my recent adult programming life with a combination of C, C++, Python, and Matlab. I haven't so far had a need for Java because one of those languages does anything I need to do better than Java.
I've studied Java (and C#) a little, and have generally been interested and see some value there. But I have never actually had an explicit need for Java, so I never stuck with it long enough to become proficient in it. In particular, mastering Java's libraries is a daunting task. So, if I can live my life without it, I wonder how much worse off the rest of the world would be if it had never been invented?
Java's core strength was that it was built to be a practical tool for getting work done.
If only.
I have abandoned Java shortly after Java 2 SDK release precisely because it was NOT anywhere near being a "practical tool for getting work done." Later encounters over the years only reinforced my opinion.
As one Java developer described it, comparing Java to Python at task of using the proverbial "wheel" in your program. In Python, if you need the "wheel", you just "import wheel" and use it. Java too provides you with everything necessary: "import map.ore.iron", "import tools.pickaxe", "import fire.matches", plus a 3rd party class "recipe.smelt" and a measly 1-2K LOC - and voila! you have the "class Wheel" in Java too!
All hope abandon ye who enter here.
Must be because they're mostly millennials
Wrong generation. The millennials are running javascript everywhere and/or rediscovering functional programming (joking).
Nothing like coming in the next morning with to a huge list of changes to a system that was working but now all the other dependent components have to be reworked because someone discovered the refactor button and couldn't resist staying up all night.
Your failure to recognize the flaws in your development process is astounding.
they especially love Agile (cough, vomit) development for obvious reason
I...don't...even....oh dear...where is the (Score: -1, Incompetent)?
You do realize that MVC is an _object oriented design pattern_ right?
On my laptop, a Sandy Bridge i7, on a cold start, Netbeans 8 takes 57 seconds to launch before it's clickable, Visual Studio 2013 takes 68 seconds. Netbeans is also more responsive while it's busy, with Visual Studio displaying the full hourglass cursor and triggering the "application not responding" behaviour if its window is clicked before it's ready.
Form the parent's link:
When I was a kid, I learned to program on punched cards.
And it goes on there as you expect.
Back then - and I was there too - you didn't have to knock out 50,000 lines of code, you didn't have GUIs, you didn't have to connect to a bunch of distributed machines, etc... and get it all done in two months.
Those punched card programs were procedural batch programs that you ran while you slept. You usually didn't have to deal with real time user input or network crazyness or even multiple threads. And it wasn't that hard to keep it all in your head or if you had to, draw it all on a page or two of a legal pad.
So, no we old farts were not smarter.
No language is inherently good or evil in and of itself (save for PHP, which is evil incarnate.)
It is simply a tool for expressing logic. A means of structuring data.
Some are elegant for certain classes of problems, some are abused to fit problem sets they aren't suited for.
The sole benefit of Java to me is it's portability for core logic, even though I know that once you're dealing with user interfaces and heavy duty multi-threading, there are "write once, test everywhere" problems with the language.
Java isn't even predictable on my Linux box. It randomly crashes for no apparent reason while running code that has run cleanly thousands upon thousands of times in the past. Yet after years and years of successful runs of my pet project (http://msscodefactory.sourceforge.net/), I had Java 7 on Ubuntu crash a couple weeks ago during a run. The compiler itself crashes on a regular basis; several times per week.
As to why all the Java articles lately? Oracle's "Java World" conference is coming up, so it's time to beat the drums, sacrifice the sheep, and burn the entrails on the altar of the language. The high priests are out in droves preaching the gospel.
I do not fail; I succeed at finding out what does not work.
Java code can meet or even beat the performance of so-called "performant" languages like C, C++, Lisp, VB6, or JavaScript.
Since when are VB6 and JavaScript "performant" languages? I can't think of anything slower than JavaScript.
Since many other Slashdoters have made it clear enough that "Java" is not just "Java applets" (and surely not "Javascript"!), i would like to give some love (trying to balance all the hate...) to "Java applets" - excluding the security problems (for which Java is not the only responsible - browsers, to a lesser degree, must be blamed also), i don't think that exist any other real (i like HTML5, but...) Rich Internet Application (R.I.A.) that is better than (or, nowadays, even alternative to...) "Java applets"!
Antisthenes: "Wisdom begins by examining the words/names." - excuse my English, i am (slightly...) better with my Greek!
Also, one of the main double-plus-good stuff in Java is concept of packages and jars. Anyone dealing with header files and libs (not to mention issues when libs are created by different compilers on different platforms) will know what I am talking about. If C++ in next iteration copy this concept and ditch header files, it will be greatest improvement in C++ ever.
839*929
You forgot: . . . and not check the licensing conditions of all those 3rd party packages.
I have not switched to Maven . . . so far.
But your 'three line loop' example is NOT a Java problem. That same kind of stupidity transcends languages, platforms and tools, and often opens up career paths into management.
I'll see your senator, and I'll raise you two judges.
Actually, Maven is the exact opposite of "let's download random code".
One of Maven's primary virtues is that it allows you to pull specific versions of the various products to produce a consistent result.
Unless, of course, some idiot substitutes "grab anything" for version numbers in the POM.
Please don't assume that bad developers and practices are intrinsically tied to a language or platform. As I said in this same thread, that kind of stupidity transcends languages. :-)
I'll see your senator, and I'll raise you two judges.
Yep, it's almost like the limiting performance factor for large complex programs like IDEs is I/O or something....
Latency and unpredictability of garbage collection is a severe problem for any UI, and even web/database backends. Your Cassandra node can run fine for a week and then fragment its heap and go into 20 second stop the world GC, causing user requests to time out. Silly things like allocating large byte arrays and dolling out offsets and length for individual uses are done to avoid big GC pauses. It still doesn't always work, because there are a lot of VM versions and user access patterns shift over time.
For all that, memory leaks are no less common than in C++ and non-memory resource leaks are horrendous. In C++, your object's destructor is cleanly called when the object is deleted or goes out of scope. That will take care of also calling destructors on anything encapsulated, which can then close files and unregister listeners. In Java, the while 100MB object hierarchy will be still consuming heap because some leaf node's close method was not called and it's a button click listener with an indirect link back to root.
A grown up language can support stack based and encapsulated object instances that don't have to be GCed and have predictable destruction time. Large and provably acyclical objects like bitmaps can also be reference counting. In practice, GC pauses are no better than crashes, so in real life even unsafe explicit delete makes sense in many cases.
Well, I used to think that too. In old times I'd agree 100% with you. I'm not gonna defend VB6, that was just a joke. But nowadays, javascript can run a lot faster than many compiled languages. You see things like Node.js which show that javascript engines have been insanely optimized, largely due to the languages (over)use on the internet. On my other post, I mentioned that Google made a demo using Dart (which is just a language which transcompiles to javascript, like CoffeeScript or TypeScript), rendering entire frames in 1.2ms. I am as much as baffled as you, but Google has found it easier to have low latency APIs for well-written JavaScript than with some Dalvik optimization.
My good advice is: it's hard for people with a compiled language background, including me, to accept that, but JS is very good for many things which we couldn't dream of 5 years ago, encroaching even C territory.
https://play.google.com/store/...
"I decided I could write something better than everything out there in two weeks. And I was right." - Linus Torvalds
writing a small application without an IDE is really difficult task in Java ... due to the strong dependence on boilerplate code.
that's a stinking load of bollocks
I wrote a java front end for tar, that makes it multi-threaded. I use it to make backups. It's maybe 4 or 5 pages of java. It's just one file, no IDE, no makefile, no build.xml, no nothing, just a .java file that compiles into 4 or 5 .class files. It's easier to work with and easier to port than ANY C or C++ program of equivalent size.
The absolute #1 contribution of Java: it has allowed colleges and universities to turn out a generation of coders who are incapable of dealing with pointers, explicit memory management, stack layout, static memory maps, etc., etc..
In other words: a crapload of people with "Computer Science" degrees who could not write an OS or even a trivial part, like the C library signal trampoline, to save their ass, because they are in this walled garden/protected environment where they are "safe" from having to actually deal with real hardware.
Ironically, all of their JVMs on which they are normally running this code are not written in Java, because it's not really practical to do that.
It is a shame the world doesn't pay more attention to Scheme.
scheme is indeed a fun language, but there are vanishingly few programmers out there who can wrap their heads around the "call-with-current-continuation" mechanism.
I can remember lots of times when people have done stupid things in SQL, XML, C, C++, football, cooking, mystery novels. etc.
That does not mean that any of those things are bad.
I take it you know that "abstraction" and "over-abstraction" are not the same..?
You need to buy an SSD. Visual Studio takes about 3-4 seconds to load on my mediocre i5 laptop, but it has an SSD. It takes almost 10 seconds when loading a very large solution on startup.
-- All that is necessary for the triumph of evil is that good men do nothing. -- Edmund Burke
I have seen what you are talking about, but there is no reason why java programming should have to go hand in hand with utter dependence on third party libraries. Where I used to work, there were two programming departments. We both did Java, but the other department was dead set on spending days and weeks researching third party solutions for simple problems. Then they would spend trying to learn the interface. Then inevitably, if there was a problem, it always seemed to be in the third part code. Well, of course, if you need to add two plus two, and you download a Cray simulator library to accomplish this, then you have to instantiate the library, and seed it with the two numbers, and start the thread that does the calculation, then receive the even that it is done, then retrieve the data, well you see where this is going.
I am not in favor of reinventing the wheel, but if it is going to take less time for me to write something than to research third party solutions and figure out how to integrate to them, and I can control the code, then I will be reinventing that wheel rather than download the global transportation library so I can use their wheel.
If you are not allowed to question your government then the government has answered your question.
I am not saying JavaScript can't perform in some specific scenarios. Just like C isn't always fast (code can be badly written in any language). But globally, JavaScript isn't known as a performance language, unlike say C, C++, Fortran and of course assembly.
Also, according to these benchmarks, JavaScript is much slower than C: http://benchmarksgame.alioth.d...
You forgot: . . . and not check the licensing conditions of all those 3rd party packages.
so java is the only language which has this problem?
Java is fully open-sourced and the most open-sourced programming language I know. OpenJDK is the same source code Oracle uses for its JDK. It's easy to download and compile all Java executables. Here is a guide and a Youtube video detailing how to build the JDK.
Java is defined and updated by the JSR process, which resembles RFCs. And also by the JEP process which tells you exactly what's being built into Java and when. You can also use their bugtrackers and mailing lists to track Oracle engineers' work.
I've learnt a ton just by tracking those lists.
Based on upvotes, Ageism is the only "-ism" Slashdotters care about and think isn't SJW
Would be funny if it where true, but Netbeans on my computer loads faster than Visual Studio. And both runs equally as fast.
Based on upvotes, Ageism is the only "-ism" Slashdotters care about and think isn't SJW
They were so preoccupied with whether or not they could that they didn't stop to think if they should.
And are you implying that doesn't happen with the C runtime?
Or seriously implying this happens less often when developers code in C/C++?
Based on upvotes, Ageism is the only "-ism" Slashdotters care about and think isn't SJW
Did you just call Lisp *performant*?
But I won't dispute that Java has changed the face of programming when comparing worlds before it existed and after, although many languages can make that claim, including C, and probably C++. I'd not be surprised if even BASIC could not be said to have had such a dramatic influence on programming. Fortran and COBOL would be up there as well, possibly even greater than most of the others combined.
File under 'M' for 'Manic ranting'
About the way COBOL was sold....
mark "puts paper bag over head before admitting he wrote COBOL long ago, using magnets to write the code...."
I work in a code base of about 475k lines of java (not counting comments, annotations of black lines) with vim as my typical environment.
On a related issue, I still hold my position: In a near future, (and perhaps because of this stupid IOT thing) {...}
I'm under the impression that: as currently lots of the precussors of future IoT projects are from the maker culture it's probably one of the more hipsterish languages like Python and Ruby which might see more rise.
If you think of it, currently it's platforms like Raspberry Pi which are the forerunner of all the future connected small things. It's the "plant tweeting when it needs water" of today, that are the "intelligent fridge which automatically fills your grocery list" of tomorrow.
And currently, Python is *the* most popular rapid prototyping language on these platform.
all the Java based appliances will start to work together and bring Skynet to life. Prepare yourselves to run away from hordes of Java-powered T1000s!!! I for one welcome our CPU and memory hungry robotic overlords.
Well, try to be gentle with them. Do to run too fast so they can try to pretend they can keep up. And while running, please push aside all the various garbage laying on the ground so that these Javaminators don't trip on them and fall (or stop to automatically collect it up).
Also be kind: if you meet more than 1 of them, it would be proper etiquette to act as a translator between them so they can understand each-other (specially if one of them speaks microsoft dialect)
Try also to be understanding toward their sensitivities. There are a few of their kind that the remaining Javaminators consider untouchable (specially the one called Dalvik). Try not to madden them because you don't agree with that rejection (Even if you consider that actually that pastry-obsessed-outcast is the cool guy you want to hang around with).
"Sufficiently advanced satire is indistinguishable from reality." - [Tips: 1DrYakQDKCQ6y52z6QbnkxHXAocMZJE61o ]
Minecraft - $2.5 Billion dollars - anyone beat that?
Its greatest achievement was to be a C-like language in which legions of mediocre corporate coders can work on the same codebase without hurting each other too badly. This lets you replace COBOL.
Then the whole bytecode on a virtual machine thing, which while it had been done before (UCSD Pascal), Java's VM really made practical. People complain about Java's slowness, but the VM is really quite speedy (and the sandboxing is amazing). You can write high frame rate FPSes in it (Quake!). It's usually bad coders and bad frameworks that cripple performance. And without the JVM we probably wouldn't have .NET, Mono, and the CIL. Certainly not as good - it really helps to have done a previous version.
I've seen a number of large projects (tens of thousands of lines of code)
This is a contradiction in itself.
10,000 lines even multiple of them, like 90,000 lines, is by no means "a large project".
The systems I work on usually have like 10,000 classes! no one bothers to count the lines though.
the primary code editing tools used by the developers were exclusively text editors like nano and vim - there is no IDE during development. ... we had this: vi(m) is better than an IDE talk a few days ago ... already.
That is their problem
Cost free eBook I read (by iBook/Kobo/Amazon/ObookO/Gutenberg etc.): "The Green Odyssey" by Philip Jose Farmer.
Java is most certainly not dead, but it has transformed. The language itself is not as much relevant as the JVM abstraction, since now you can code in Python, Clojure, Scala, Ruby, to bytecode. This minimum common denominator becomes immensely important when deploying applications to the cloud, since you can find tons of providers that can run applications on JVM, and you also get for (almost) free a ton of tools to monitor your apps with JMX (debugging, profiling, etc).
Hadoop and its ecosystem, Spark, Kafka, Storm and a lot of other cloud oriented software are written on the JVM. Nobody wants to care on which hardware you're running for most applications (that is, if you don't need a GPU, but that's being commoditized too).
Gotta love slashdot
Table-ized A.I.
Java the language/platform may suck. Just, it sucks less when compared to other solutions.
Funny enough, it is the lack of proper abstraction that causes the kind of code bloat you're describing. If you're cutting and pasting boilerplate code and doing a search/replace within your "new" files, that is a clear warning flag of bad software architecture.
The cesspool just got a check and balance.
Sounds like poor management, poor hiring, and poor technical leads.
I'm not understanding this. It was my impression that Java rigidly defined elementary data formats. In Java, an "int" is a 32-bit twos-complement number. In C or C++, an "int" is some sort of signed number at least 16 bits long.
"When you have eliminated the unacceptable, whatever is left, however improbable, must be the truthiness" - Holmes
0% interesting.
Table-ized A.I.
My favorite thing about Java developers is Maven, otherwise known as the "let's download random code from all over the Internet and just run it without bothering to verify it in any form!" tool.
I'm not super fond of Maven either. Gradle is more popular or simply Ant+Ivy has always been an alternative. But whichever dependency manager is used, the following features are available:
This provides an eco-system of libraries rather than having to go to a single vendor who will take the responsibility of integrating and providing a certified system of libraries to use. The benefit is increased pace of innovation, while the drawback is choice overload, and the same pros and cons exist for other platforms: Gnu Autotools dependency is super powerful, but takes a while to learn. There's virtualenv for Python, or RVM for Ruby. For Nugget, .NET came late, since Microsoft was able to watch innovation, including in other languages, and cherry pick the best so it was all there from a single vendor.
If it acquires resources on instantiation like a duck, then its a shared_ptr<Duck>
+1 Passive aggressive / racist