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
Java exists in a special type of programming environment. If it works for you, great. One thing I'll never understand is how it practically requires an IDE to do anything non-trivial, in contrast to any other language. It reminds me of APL's requirement for a special keyboard.
And to be clear, it will never catch on in vast swaths of the programming world.
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.
Java sucks. Few significant programs on any Linux or BSD system are written in it. The whole byte code thing is bazaar. C++ is the only comparable language. It is a shame the world doesn't pay more attention to Scheme.
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!
I've found Java developers to be the most annoying people to work with, ever. Talk about ADD!! Must be because they're mostly millennials and don't have the patience to sit back and think about a problem opting instead to download dozens of third party components, in a heartbeat, then slapping the bloody mess together which gives then endless opportunities for refactoring. 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.
They thrive like bacteria in places that have weak or non existent development practices like code reviews - they especially love Agile (cough, vomit) development for obvious reason.
Idiots all.
public class Java {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
Clearly it called method programming.change(system.time.duration.forever)
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.
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.
JVMs have ridiculous lists of dependencies of all kinds. This shortens / cheapens development time, and is mostly a good thing in order to get deliverables following established patterns out the door quicker. However each of these do add their own types of overhead: for development, deployment, maintenance and runtime.
In the end, it's simply a bunch of trade-offs of where you want to have the complexity. If it were simple, you wouldn't need projects and developers with thousands of hours of experience spending so much time on it. Ie. by using an external library, you're relying on someone else's work-schedule and future plans. This might sound smart until that external library go unsupported, especially if it's proprietary with no way to fork it.
The trade-off with Java and JVMs were less control over response times, giving up on promises of real-time systems and user responsiveness in order to buy cheaper and more flexible development and deployment. In other words: The users lost.
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.
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
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%..
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.
According to a lecture I heard at SAP Palo-Alto by Gilad Bracha who as much as I know worked closely with Mr Gosling on Java.
The plan failed due to CPU's at the time not being strong enough and it got converted to something else...
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 is really fast when running. but starts slowly. it is impossible to revert first bad experience.
I take it you haven't actually tried to re-use over-abstracted code.
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
c++ will never die
Take, for example, their stance on unsigned integers. "We won't do them. You can always assign to a higher precision number if you want to print out a number bigger than the signed integer allows!".
BOLLOCKS.
Binary data (e.g. a IP datagram or header) will define its contents as being a specific size. Reading that in and writing it out require some extra special hoop jumping to keep it going, and those hoops require that anything dealing with that data format has to know what's "inside the black box", which is BS from a good programming POV. And then again, if you want the unsigned (long) long, you're double fucked, because it isn't possible if that's the largest number available.
And worse, this carries over to the print formatting. There's NO FUCKING WAY to manage that without clunk.
Or take their stance on on multiple inheritance. "It's bad, therefore we won't let it happen". Casting, same thing. "We think it bad, therefore it won't be in there".
Then there's the entire bollocks about Java being paranoid about including ANYTHING that deals with the OS or hardware. Sun created Java to fuck over Microsoft, hence their design choice to preclude anything to do with the OS. Given the limited use and the better inclusion that brought in the early days, fair enough. A bit of a dick move, but understandable and defensible.
Nowadays, not so much. Just the dick is left.
Partly because there's no way to tell what format you're supposed to use when you want to print an "integer" when you don't know what integer size was used on the machine that wrote it or compare it with the machine you're running this on.
Therefore I've written many a program with a conditional statement based on what an "integer" is on this machine, dealt with the format of the writing machine by forcing this one to use "non native" integer types by aggressive casting, then changing the print format. It's a fucking mess because I can't use "uint32" or "int32" or similar. Because it's "too machine specific!". When the code I write has to fuck about to ensure that on a machine with only 32 bit integers, it uses long to store, adding to make it unsigned if it's negative, and using "ld" to print it out. Then on a machine with 64 bit integers, make sure that it doesn't use "lld" for 64-bit numbers.
To be slightly fair about that, C is pretty fucked up on what "lld" "ld" and "d" assume is being printed. But on C I can use "uint32/int32" or whatever then deal with it knowing what the value is I chose is going to do WITHOUT WORRYING what the fucking machine things is long or not.
They COULD have fixed it a different way, but they're refusing to allow "unsigned". And won't change "d/ld/lld" to cover it. It doesn't expose machine specifics, it completely nukes the need to keep machine specific code (more especially, java interpreter specific, since 32 bit java runs on 64 bit machines just fine). You need that machine specific steeplechase without "uint32/int32" but with "d/ld/lld".
i think your computer has a problem, son.
by no means, I think VS is a swiss army knife, but my lenovo x220, 5-year sandy bridge old i5, launches Visual Studio in 10 seconds.
Visual Studio can be pretty memory intensive but if you have enough RAM and an SSD, it is wonderful having instant auto-complete. I have not seen anything that matches it. Even Xcode, which is way better than any java crap out there can't match Visual Studio responsiveness. of course, it's not a text editor. if you want to do lightweight textediting, there's vim, emacs, sublime, or even Visual Studio Code if that's your kind of thing.
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
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.
The syntactical aspects of the language aside, it's hard to respect something that asks me to install an Ask.com toolbar and still doesn't have a good update mechanism.
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 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...
It had a universal GUI framework, and took the pain out of socket management. That's it.
Otherwise... It happened to be around right at the right time where people realized they needed rapid development for client/server oriented applications.
Java got lucky. It was there. If Perl had had a GUI, Java would have never gotten off the ground.
All of the "write once run anywhere" aspect of it turned out to be 99% hype. The language itself is terrible.
Assuming you have a reasonably good IDE, and you have a compiler able to do some optimization, and you are working with an SDK that is reasonably useful, that should be enough to "get the job done" for just about all of what's needed.
Not everything.
But a lot of coding is still doing non-interesting things for large companies, and you pretty much use whatever language their existing system is in, cause they aren't going to switch over no matter how many programmers tell them that language XYZ is somehow better.
imho, if you cannot learn a new language (not saying you have to like it better), or an old language, then you aren't much of a programmer. of course you will be slower til you get practiced, but the ideas, the logic, the data flow, the work flow, all that never really changes.
so, do I care if java rules the world? or becomes a niche language? not really. If someone needs me to code in it, I can. If someone needs me to learn AwesomeSauceOnRails, I can.
Difference is you're right for the wrong reason. Yes Java is used for a lot of enterprise server side stuff. What I don't understand is why. Well I do - it's so they can use cheap grad ready trained java programmers. I haven't yet seen a use case where another language wouldn't have been more appropriate than java for server side stuff.
The difference caused by html5/javascript advances is now I can rephrase that sentence to say server or client side stuff.
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
It's rare to see .NET positions in Silicon Valley, and common to see Java. But I also see a lot of C positions here, so we might be in a bit of a bubble when it comes to the kind of technology used by companies in this region.
I could probably be persuaded to dig up some numbers specific to Silicon Valley, but that is probably not meaningful. Generally I agree with you that the trend world-wide is there are most listings for .NET jobs than Java. Part of that is due to a lot of short term contracts for .NET, and part of that is that Java and .NET don't overlap much in where they are used even if the capabilities of each language overlap significantly.
If you want to tie a bunch of services together on Windows, .NET is what you use. If you want to ship a medium sized service for your business, perhaps in a heterogeneous environment, you might go to Java first. That's not to say there are technical limitations or advantages in each rule, those are just some niches that where people seem to have a preference for one over the other.
(bias alert - I have a strong preference for an open standard like Java over a privately controlled language like .NET)
An interesting bit of history is that Sun was developing an OOP language before Java called Self. Self was inspired by Smalltalk, but the major difference was replacing classes with prototypes. And of course that was Brandon Eich's inspiration for making JavaScript a prototype-based language. Unfortunately, Sun and Netscape were in cahoots. Sun wanted Java to be the language of the browser, but Netscape was developing their own language called LiveScript. So the compromise was to rename LiveScript and make it look like Java on the surface. And thus followed 20 years of confusion over the name and the prototypal nature of JavaScript.
It makes me wonder how things would be different if either of the two had occurred:
1. Sun stuff with Self and brought it to market instead of Java in the mid 90s. The JVM is based on pioneering VM work with Self to make it more performant.
2. JavaScript remained LiveScript and fully embraced prototyping like the programming language IO does.
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...."
Abstraction exists for code re-use and to make parts pluggable
Abstraction does not necessarily mean OOP.
Something is wrong with your computer then. All my computers have core i5's and it takes ~5 seconds to load Visual Studio. Eclipse has always been slow, but usually loads within 30 seconds. Netbeans sure wouldn't take longer than 30 seconds, but I haven't used it in awhile.
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 ]
IANAJP, but "practical tool for getting work done"...
Besides the memory management (garbage collection), what are a couple things that makes Java good for getting things done?
People still code in COBOL in some places.
Minecraft - $2.5 Billion dollars - anyone beat that?
Linus never said he wouldn't write or contribute to projects written in C++, he said the C++ language is inappropriate for kernel code. No more, no less.
Back on topic, I have been in programming and systems administration professionally for over 35 years, and the Java that exists in the field today is generally the worst performing, most overwrought code I've ever seen. This is not necessarily meant to be a criticism of the language, but rather of the programmers that write in it. It's said that a good programmer can make good code in any language, but Java programmers consistently produce expensive, underperforming garbage that is easily replaced with cheaper, faster code written in nearly any other language (even BASIC or PHP!).
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.
i7 3770K desktop with 16GB of RAM and a spinny (a.k.a. "slow") HDD:
- VS2012 launches in 7 seconds.
- VS2010 launches in 2 seconds, but I already had 2 instances of it running so most of the shared libraries were already in memory.
- VS2008 launches in 1 second, but again, I already had an instance running.
A "cold start" wouldn't cause it to take much longer than that, as long as the entire OS wasn't still spinning up a SQL Server instance or something. Under 10 seconds should be normal on a decent dev box. A laptop might take an extra 5 seconds, due to downclocking inflicted by power management stuff. It should NOT take anywhere near a minute to start an IDE.
And, yes, I really need multiple instances and versions because...
- VS2008 is the last version to be able to handle old-school WindowsCE development, and one of our clients has a WinMo 6.5 barcode scanner app.
- VS2010 is the last version to be able to use "datadude" SQL projects, and we have a few dozen of those.
- VS2012 is the first version to be able to use WebAPI 2.x projects, and we have some of those. We've also begun porting our database projects over to the new SSDT ones.
I also have a trial of VS2013, which we decided not to bother upgrading to because there wasn't an absolute need for it. But I have a feeling we're going to get VS2015 so we can do some "universal" apps, and possibly some Android/iOS cross-development stuff.
Perhaps my experiences are unique, but in the 10 or so years I've been working with and around java development what I've seen is that java permits mediocre developers to produce complex software that's inefficient and badly abstracted, that does complex things slowly.
Furthermore, the little third world walled garden that java puts these developers in isolates and insulates them from the systems they are impacting.
That's my honest experience. Java developers of all the languages I've had to support on average have been the least skilled and least - I don't even know. It's hard to even qualify. Other developers take an interest in systems issues and work to improve it. Working with java developers is often like working with ducks. You can explain things over and over, and in the end unless you fix it from a systems perspective, nothing is going to get done because they don't understand or don't care.
To me, java was designed for one thing which makes a moderate amount of sense. A platform that is global. It isn't that, because java on each platform is fundamentally different due to the libraries involved, but furthermore it's a terrible fit for most of things I've seen people do with it.
"No good deed goes unpunished"
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).
Perhaps you have worked on large scale software projects, but I doubt you have abstractions worth a damn.
Much of the enterprise software is abstracted badly, with pointless classes that do not reflect any kind of domain mapping. They do tend to have lots of lines of code in small methods to keep automatic code quality tools happy.
These applications typically are unreliable on timescales of a week, whilst we have (and I have built) true HA systems that have given little trouble over decades.
You have more fanboys who extoll the virtues of the only technology they know (and probably the only one that would have facilitated their career as low-grade code monkeys on applications they don't understand).
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.
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.
Sounds like you have something seriously wrong with the setup of that machine. On my 8 year old desktop with 4 GB of RAM running Windows 8.1 it takes about 10-15 seconds for Visual Studio 2013 to cold-start. It takes about 5 more seconds to create a new empty C# project and start actively typing code.
The most boring and brain-sapping 'Enterprise' technology out there. Honestly - who goes home and thinks 'Aah - a couple of nice quiet hours programming in my favourite language on my favourite projects'. Even the outsource Indians at work seen tired of Java. Or life. Can't tell.
Horses for courses, as the saying goes.
A proper C++ string class clearly trumps all the shite they have in C strings.
But yeah, nobody forces you to use an electric screw driver on a watch. APPLY BRAIN.
Mr Torvalds is already an old fart. Properly used C++ code could certainly make any OS kernel more secure (because of more intrinsic checks) and better to maintain (because of better abstractions). Of course, you now want to know the definition of "properly used".
This would be a long story, but lets put it this way: Don't use all C++ features; use the ones which make sense. Start out with the things you understand well. Don't use C++ gizmos because somebody propagandized them as "cool".
The last maxim is of course the most difficult one. Humans influence each other and some influencers are way more powerful than people realize. But at the same time their intelligence is rather limited or they are outright malicious.
The last proper VS was VS2008. After that they dumped the C++ code and replaced it by some shitty C# stuff. Little wonder it is now as bad as Eclipse.
Also, it now cannot even do basic things like navigating to definiton of a symbol. You need a third-party plugin for that to work.
All the fun of Cheap C# Developers.
I also hear the VS team lead is now a pussy. Akin to a kindergarten being run by a guy. Go figure.