"The agile folks luuuuurve them some dynamic languages, because it enables an incredibly short development cycle.
...
Academia luuuuurves it some functional languages, and with a few exceptions, academia is where functional languages live and die. (Some exceptions: Haskell, Erlang, Mathematica.)"
Unfortunately, while this is meant as a "witty" dig at some folk's supposed knee-jerk reactions, this is pretty much indicative of the level of discourse in this post.
no, it's not that bad. he was explaining how
he can't explain this to his nine year old,
data Item = Item { initial :: float,
acceleration :: float }
position time item = initial item + acceleration item * time^2
but his nine year old has no problems with this.
public class Item{
private final float _initial;
private final float _acceleration;
public Item(float initial, float acceleration){
_initial = initial;
_acceleration = acceleration;
}
public float getPosition(float time){
return _initial + time * time * _position;
}
}
Honestly, no. But the nine-year-old (at the time) understood explicit things, while not necessarily grokking implicit things. That doesn't make implicitness of less value.
IMO, seeing things makes understanding them easier at first - it doesn't mean you don't learn.
It's even worse because, while I agree with the premise that Java is more relevant than many think, the author never even attempts to make the case. There's no discussion of why Java is relevant.
I was going to write a scathing point by point rebuttal of this garbage, but--you hit it right on the head. It's so much more cost-effective to hit the "flag" button.
He has some points, a few of them are bad, but there is no 'dig at some folks knee-jerk reactions' here at all. His claim is functional languages are largely used and developed in academia. Oh and he says 'luuuuuuurve', but remember, he's not writing on HN so he doesn't have to adhere to the local standard of blandness in writing.
If you have something to say about how horribly confused this person is, go right ahead. He's too "witty" or talking about someone else's "knee-jerk" or whatever, that's hardly "discourse" either.
Magic incantations which you learn on the first day of CS101 and can reGoogle at will don't hurt your ability to read or write code. Besides, Eclipse will write it for you anyhow.
If you want to take a potshot at Java syntax, look at the among of cruft you need to accomplish common, trivial tasks:
Map<String, Object> cond = new HashMap<String, Object>();
/* do something with cond */
for (Entry<String, Object> entry : cond.entrySet()) {
System.out.println("Key : " + entry.key() + " => " + entry.value());
}
versus, e.g., ruby
cond = {}
# do something with cond
cond.each {|key, value| puts "#{key} => #{value}"}
What I want to know is: ignoring the vendor lock-in part (and yes, that's huge) and the very Microsofty way that you have to do everything once you go that route, how does C# factor into the discussion?
The CLR is clearly inspired by the JVM, and the latest iterations of the C# language itself have added a lot of syntax to achieve various dynamic techniques. Yet, sometimes, I feel like I'd be better off with the Java platform and a dynamic JVM language.
Yep, dynamic and functional languages will never succeed because of their complex syntax and features. That explains why nobody writes software in C++.
Computer Science rarely happens on blogs. It's a discipline with conference proceedings and journals. You can read those instead of some random person's blog.
You are right. Agreed. I take blogger's bait far too often. However, I continue to hope that this particular forum will attract more engineers, and fewer bloggers.
This might be an unpopular opinion but I would say that the preposition "Java is irrelevant" is incorrect immediately; it seems unnecessary to write articles refuting an opinion such as that.
Paul Graham wrote an essay about why Microsoft was irrelevant. We had the same discussion then. It seems there is relevance as far as market share and jobs in industry is concerned, and irrelevance as far as setting the direction for the future of the industry is concerned.
I think it is obvious that Java the language is perfectly relevant as far as market share and jobs are concerned. I would be surprised if Java the language is relevant in any way with respect to the future of programming.
Unlike the author, I do not make the argument that if Java the language is irrelevant, Ruby the language must be relevant. Just as Java can be popular while being irrelevant to the future of programming, Ruby may well become more and more popular while also being irrelevant to the future of programming.
Smalltalk showed us that the future of programming may be dominated for decades by the ideas in language with only modest success today.
Have at it with my blessing! While I wrote it, I had no idea it was a significant thing to say. I'd read your thoughts on the matter with avid interest.
I really can't reply to much of this without a wholesale repeat of things I wrote in my blog years ago, but one thing I wanted to point out is that to my knowledge, languages like Ruby were not designed to "replace" Java.
Like most disruptive technologies, they were aimed at specialized niches where "worse is better." Ruby seemed to start off as more of a replacement for shell scripting. If anything, it was aimed at Perl, not Java. Rails was aimed at replacing PHP, not J2EE. As they matured (Ruby was 11 years old when Rails was introduced!), they spread out organically.
Now that I say it like that, let's put hat over heart and spend a moment reflecting on the fact that Java followed the same path. It was designed to replace C for embedded applications, then to embed active content in web pages, then it gradually spread and mutated into the cubicle farm fertilizer it is today.
With a little creativity you can take the OP and change it so that the author is ranting about the drawbacks of Java and its dynamic memory management and why neophytes luuuuuurv them some design patterns. It would have been a fine comp.lang.C++ news post in 1991.
Quite honestly the subject of "Replacing Java with Ruby/Python/..." is so complex I think it's a minefield to argue either for or against it in less than an essay.
Which organization? Product or internal app? Consulting gig or internal development? Telephone book of specs or stakeholders iteratively refining requirements? &c. &c.
It's true that I'm not writing Java any more, but the Java apps I used to write are still there making money for their owners, and none of them have called me up to say they want to do all new development in Ruby.
It's more a case of there being new kinds of opportunities afforded by a different style of development. And this is perfectly in accordance with the theory of disruptive technology put forth in "The Innovator's Dilemma."
So what was my point again? Oh yes, I agree from time to time there is talk of replacing Java, but it is a little more complex than a wholesale project-for-project replacement with all other factors remaining fixed.
If I were pitching it, I would pitch the benefits of a new way of developing software, and only when that point is made would I point out that Ruby and Javascript are tools that suit the new way more than Java.
I'd rather do that than pitch the languages and spring the "gotcha" that you'll have to change the way you develop software to be successful with the new languages.
Rails != Ruby. Play (http://www.playframework.org) successfully replicates the Rails experience in Java (finally).
What Rails did was introduce a new way of thinking about pragmatic approaches to developing CRUD web apps. While ruby apologists (I once was one!) will argue that Rails couldn't have existed without Ruby, that's simply not the case. Rails was just there first...a trailblazer. But Rails could've been written in perl, python, or even, as Play shows, Java.
Nope. That's like saying cycling pretty much is riding around on the street on sub $200 machines just because that's what most people do with a bicycle.
To you there may be relatively little Ruby that isn't used in conjunction with Rails but that is not the same thing as saying that there is very little in an absolute sense. And surprisingly, the uses outside of Rails may be the most influential in terms of its direction and future as a language, thanks to the particular circumstances of Matz and what interests him.
To cherry-pick an example, he is loathe to work on things that would have the side-effect of slowing Ruby's startup time. This is a tradeoff that is good for long-running server applications like J2EE stacks, but bad for writing scripts.
Of course, there's JRuby which goes in the other direction. We'll see what happens with that kind of thing.
Saying java's "more relevant than [we] think" is sort of a straw man. It's relevant, it's just many developers don't like java: its syntax, its limitations, the java "culture" that surrounds it, the fact that many of us must know and use it to be relevant in the marketplace.
As for the argument that it's worth it because it's just not that complicated so you can explain it to a ten year old in an elevator... is that really what we're supposed to aim for? Do we really want to give java a 3rd grade gold star because it's in that sweet spot between assembly (hurts brain) and scala (hurts brain).
I don't know. I sort of like to go for the epiphany that comes with finally getting scala (like really getting it) or Lisp macros or monads or etc. You're right that the "cool kid" mentality that attaches itself to the new shiny language is annoying, but I'll take it over the very average mentality that attaches itself to java in that article.
40 comments
[ 3.0 ms ] story [ 44.6 ms ] thread"The agile folks luuuuurve them some dynamic languages, because it enables an incredibly short development cycle.
...
Academia luuuuurves it some functional languages, and with a few exceptions, academia is where functional languages live and die. (Some exceptions: Haskell, Erlang, Mathematica.)"
Unfortunately, while this is meant as a "witty" dig at some folk's supposed knee-jerk reactions, this is pretty much indicative of the level of discourse in this post.
I couldn't find it.
It's just a long rant about languages the writer doesn't understand and won't even try to.
> A dynamic language is one which – if you’ll pardon the really poor definition – is able to change at runtime.
Really, it does not deserve much attention.
IMO, seeing things makes understanding them easier at first - it doesn't mean you don't learn.
If you have something to say about how horribly confused this person is, go right ahead. He's too "witty" or talking about someone else's "knee-jerk" or whatever, that's hardly "discourse" either.
One man's lack of blandness is another man's low grade school level mocking.
If you want to take a potshot at Java syntax, look at the among of cruft you need to accomplish common, trivial tasks:
versus, e.g., rubyIt just happens the Java version will have twice as many lines.
Many languages seem to be converging on using the jvm as a runtime, which makes java pretty damn relevant.
The CLR is clearly inspired by the JVM, and the latest iterations of the C# language itself have added a lot of syntax to achieve various dynamic techniques. Yet, sometimes, I feel like I'd be better off with the Java platform and a dynamic JVM language.
Had the author made a cogent point, the article might be relevant. Maybe it's entertaining to some.
I think it is obvious that Java the language is perfectly relevant as far as market share and jobs are concerned. I would be surprised if Java the language is relevant in any way with respect to the future of programming.
Unlike the author, I do not make the argument that if Java the language is irrelevant, Ruby the language must be relevant. Just as Java can be popular while being irrelevant to the future of programming, Ruby may well become more and more popular while also being irrelevant to the future of programming.
Smalltalk showed us that the future of programming may be dominated for decades by the ideas in language with only modest success today.
That idea all by itself is worth a blog post.
Like most disruptive technologies, they were aimed at specialized niches where "worse is better." Ruby seemed to start off as more of a replacement for shell scripting. If anything, it was aimed at Perl, not Java. Rails was aimed at replacing PHP, not J2EE. As they matured (Ruby was 11 years old when Rails was introduced!), they spread out organically.
Now that I say it like that, let's put hat over heart and spend a moment reflecting on the fact that Java followed the same path. It was designed to replace C for embedded applications, then to embed active content in web pages, then it gradually spread and mutated into the cubicle farm fertilizer it is today.
With a little creativity you can take the OP and change it so that the author is ranting about the drawbacks of Java and its dynamic memory management and why neophytes luuuuuurv them some design patterns. It would have been a fine comp.lang.C++ news post in 1991.
Which organization? Product or internal app? Consulting gig or internal development? Telephone book of specs or stakeholders iteratively refining requirements? &c. &c.
It's true that I'm not writing Java any more, but the Java apps I used to write are still there making money for their owners, and none of them have called me up to say they want to do all new development in Ruby.
It's more a case of there being new kinds of opportunities afforded by a different style of development. And this is perfectly in accordance with the theory of disruptive technology put forth in "The Innovator's Dilemma."
So what was my point again? Oh yes, I agree from time to time there is talk of replacing Java, but it is a little more complex than a wholesale project-for-project replacement with all other factors remaining fixed.
If I were pitching it, I would pitch the benefits of a new way of developing software, and only when that point is made would I point out that Ruby and Javascript are tools that suit the new way more than Java.
I'd rather do that than pitch the languages and spring the "gotcha" that you'll have to change the way you develop software to be successful with the new languages.
C# and .NET were designed to replace Java. The result is that it's mostly confined to Windows.
What Ruby did is to beget Rails. Rails does replace Java (and PHP, and .NET) in a lot of scenarios with many advantages.
Ruby was not designed to replace Java the same way Java was not designed to replace COBOL.
What Rails did was introduce a new way of thinking about pragmatic approaches to developing CRUD web apps. While ruby apologists (I once was one!) will argue that Rails couldn't have existed without Ruby, that's simply not the case. Rails was just there first...a trailblazer. But Rails could've been written in perl, python, or even, as Play shows, Java.
Play, while impressive, still retains most of the ugliness of Java. It's hard to compare it to a DSL like Rails.
Nope. That's like saying cycling pretty much is riding around on the street on sub $200 machines just because that's what most people do with a bicycle.
To you there may be relatively little Ruby that isn't used in conjunction with Rails but that is not the same thing as saying that there is very little in an absolute sense. And surprisingly, the uses outside of Rails may be the most influential in terms of its direction and future as a language, thanks to the particular circumstances of Matz and what interests him.
To cherry-pick an example, he is loathe to work on things that would have the side-effect of slowing Ruby's startup time. This is a tradeoff that is good for long-running server applications like J2EE stacks, but bad for writing scripts.
Of course, there's JRuby which goes in the other direction. We'll see what happens with that kind of thing.
As for the argument that it's worth it because it's just not that complicated so you can explain it to a ten year old in an elevator... is that really what we're supposed to aim for? Do we really want to give java a 3rd grade gold star because it's in that sweet spot between assembly (hurts brain) and scala (hurts brain).
I don't know. I sort of like to go for the epiphany that comes with finally getting scala (like really getting it) or Lisp macros or monads or etc. You're right that the "cool kid" mentality that attaches itself to the new shiny language is annoying, but I'll take it over the very average mentality that attaches itself to java in that article.
Lamenting the fact that #3 has happened is what's irrelevant because most languages never even make it to #2.