First of all, I'm glad Microsoft is getting involved in this space. They have a deep talent pool when it comes to language design and tooling and it'll be interesting to see where TypeScript goes.
Unfortunately, the arguments trying to draw some kind of monumental distinction between TypeScript, Dart and CoffeeScript are silly. They are all a response to the state of client-side development and are all applying essentially the same strategy (i.e., some syntax changes and a pre-compiler). It's great that TypeScript is a superset, which is what makes it pretty interesting to me, but it's still more similar to the other two than not.
Plus, what's so bad about being Microsoft's "answer" to something else? Windows was the response to Mac OS, Xbox was a response to PlayStation, .NET was the response to Java, ASP.NET AJAX was the response to Prototype (later abandoned for jQuery), ASP.NET MVC was the response to Rails, Entity Framework was the response to Hibernate/Active Record, NuGet was the response to Rubygems/npm. Each of these moved MSFT forward and several of them moved the industry forward. The ASP.NET team (of which Mr. Hanselman is a member) is doing a lot of great stuff inside MSFT, but a lot of is derivative. That's okay. It's largely the strategy MSFT has always followed, so why waste energy defending what has worked well in the past?
I agree with one point, however: It is disappointing when smart people display a profound ignorance of computing history.
> I agree with one point, however: It is disappointing when smart people display a profound ignorance of computing history.
Yeah, this was kind of an odd non sequitur that didn't go anywhere. I half-expected the article to actually give an illustration from computing history.
> essentially the same strategy (i.e., some syntax changes and a pre-compiler)
TypeScript and CoffeeScript, yes. Dart's a brand new C-like web language that is quite different, and has its own VM. Although, of course, you can still compile to JS. But unlike TypeScript and CoffeeScript, it isn't really an alternative syntax for JS, or annotations removed at compile-time.
The author's main point is that Expert's Exchange (EE) was very similar to StackOverflow (SO) until they needed to push up the S-curve from a profitability perspective.
It's a valid concern since SO has relied on organic growth to fuel the necessary returns in order to sustain its current business model and then, more recently, attract VC investment.
What the author doesn't mention is what makes SO slightly different. One is the licensing of the content, which the founders never fail to point out (and has already been rehashed here by several SO defenders). This is hand-waving, since they couldn't have achieved early success to drive organic growth without this license in place (this isn't the first time EE has been compared to SO).
The other more interesting difference is the StackExchange (SE) platform and accompanying business model, which basically seeks to expand into an unending array of fields and topics. SO & SE are likely to continue being pleasant to use, as long as the StackExchange strategy is working and growth can come from the platform extension. Should that strategy fail, SO will need a growth strategy that provides the returns VCs expect and the company may be forced into some inconvenient (to users) "monetization" decisions.
Essentially, when you're a for-profit company, it's easy to "do no evil" when you're rapidly growing organically. EE is only one such example, it's easy to come up with dozens of others: About.com, Mahalo, Digg, SourceForge, Google, Ben & Jerry's, etc. Unless it's a non-profit or maybe one of those new B-Corps, history provides much more support for skeptics. After all, company leaders aren't just acting out of greed, they are legally obligated to do what is best for shareholders.
That said, let's hope Mr. Spolsky hasn't forgotten about his rant on platform providers who don't realize they are platform providers (http://www.joelonsoftware.com/articles/Platforms.html). He should be able to make the case that treating users (which are like developers in a traditional software platform) fairly will drive more long-term shareholder value than tactics employed by those that came before SO.
Let's not conflate the French and Russian revolutions - they have absolutely nothing in common. And yes, the French revolution did work out very well for the poor, eventually. It was at the root of the development of modern democracy in the Western world.
Let's not conflate the French and Russian revolutions - they have absolutely nothing in common.
I have issues with the word "absolutely". They had quite a lot of common - both were about overthrowing a system of government based on birthright, and the participants in the Russian revolution certainly tried to learn from the French revolution.
(One could argue that the Russian revolution was actually better for the poor in the short term than the French. Serfdom was immediately abolished, and it got them out of WW1. War had the biggest impact on the poor)
Well, there's the part where the monarchy collapses but no one really knows who's going to take over, and then there's the part where radicals take over, murder the entire royal family, and enforce a bloody reign of terror, and then there's the part where all the other countries in Europe get anxious about all the unrest and go to war with the revolting country, and then there's the part where the country ultimately ends up under an imperialist dictator who tries to conquer their neighbors. They were quite different affairs, yes, but it's an exaggeration to say they had absolutely nothing in common.
> JRuby as a gateway drug to the Land of Ruby; _could_ end up being VM winner too.
I don't get the "could". JRuby is among the fastest, gives you access to a massive amount of OSS and infrastructure, and fixes Ruby's threading.
It's done these for years at this point.
In my mind the question is more along the lines of "why should I use anything _but_ JRuby on a new project?".
It's blasphemy I'm sure, but I just don't see the point in C-Ruby for new development at this point. It's legacy. JRuby, as the last-man-standing among the major Ruby VM implementations now that IronRuby is dead and everything else is vapor (Maglev) or niche (MacRuby) is the default modern Ruby implementation to my mind.
So let's assume Rubinius is great, and the GIL is clearly a major step forward. Is EngineYard's intent really to supplant YARV with Rubinius?
Because that sounds great to me.
I've never seen EY say that though (they might have and I just missed it). If that's the vision, I'd rather see them come out and say it. Having developers guess, and having any ambiguity at all around the future of these projects and the messaging surrounding them doesn't inspire confidence.
It's blasphemy in that your use of JRuby is inconsequential to rubinius. Not everyone uses JRuby, and the non JRuby using world would like the GIL thread locking abilities in their interpreters without java+JRuby.
Native c/c++ ruby isn't legacy in everyone's environments, just perhaps yours. Why does EngineYard need to justify both implementations? I don't use JRuby at all outside of occasional curiosity. But I'm also not calling it useless in the same way you're basically attacking any non JRuby ruby implementation, which apparently includes MRI. Which is arguably the "default" implementation. Language implementations aren't a zero sum game. Work on one doesn't mean we can't have another. I don't see the Python people complaining about PyPy and vice-versa, they both serve their purposes.
Well put. JRuby and Rubinius both have rich futures ahead of them, and they're going to be largely separate.
If you want to use C extensions, Rubinius will be a better fit since it matches the MRI process model better. Rubinius will also map more directly to underlying OS APIs and quirks than JRuby, since we have to either use the JVM's vanillified versions of APIs or do the hard work of routing around the JVM with our own native libraries. And if you're a Rubyist looking to hack on internals, Rubinius is certainly more approachable right now. We hope to implement more of JRuby in Ruby in the future, but we'd need a really good reason to throw out fast, working code to make a move right now.
If you want to run an entire Rails site in a single process, JRuby's going to be the best option for a long time. C extensions required for native Ruby impls to interface with databases, etc, will always force trade-offs in memory management, concurrency, and process models. Those trade-offs do not exist when running on JRuby and using Java equivalents of those libraries. As a rule of thumb, the more unmanaged code you have in your application, the more hassles you're going to have. Native impls do almost all their interaction with the outside world via unmanaged code (C exts for DB access or fast memcaching, C-accelerated servers like Thin or Unicorn, etc). That's a problem.
If you just want to run some Ruby code, both implementations are going to serve you well. You're going to need to evaluate all options before deciding, and both implementations are going to be excellent Ruby implementations first and differentially interesting platforms second. And therefore, as you say, it's not a zero sum game. We'll all bring different features and weaknesses to the table, and users will choose which impl fits their needs best.
JRuby is among the fastest, gives you access to a
massive amount of OSS and infrastructure, and fixes
Ruby's threading.
Being faster than MRI on some tests doesn't say much because from a performance standpoint MRI is a piece of shit.
If you're looking for a good reason for why Rubinius is important - JRuby cannot innovate and as Ruby will see progress, JRuby is bound to stagnate.
For example, continuations are really useful in many contexts, yet JRuby has no chance to actually implement continuations with decent performance overhead. Also, the Refinements proposal for Ruby 2.0 is a bitch to implement on JRuby. Even the Fibers in Ruby 1.9 come with a lot of overhead.
The reason for that is because JRuby inherits all the JVM's flaws. The JVM was designed for Java. The optimizations it makes function best in the context of Java. The type system is the one from Java and working around it is extremely painful. The garbage-collector itself is designed for Java. It has rough limitations on what it allows and what it doesn't allow. And when I'm saying Java, I'm saying Oracle's Java SE, or OpenJDK, not Android, not Java ME. And considering that Apache Harmony does not have the same JIT-ing characteristics of Oracle's Java SE, while I haven't seen any benchmarks I'm willing to bet the performance is much worse.
JRuby may shine among the current bunch of VMs, but that doesn't say much, because on top of the JVM in its current incarnation (including the invokedynamic additions) you'll never be able to achieve the performance Smaltalk was capable of.
If you care about Ruby as a language, caring about a VM like Rubinius is a no-brainer.
How can you say that JRuby can't innovate? JRuby is far from stagnating.
Continuations are almost never used, and in the rare cases where they are used they are almost always more straightforwardly replaced by non-continuation alternatives. FWIW, Rubinius doesn't support continuations either. It may some day...and so may the JVM.
Refinements will be easy to implement in JRuby. I've implemented prototypes of it in hours of effort. You don't know what you're talking about.
Fibers perform well in JRuby, but necessarily are implemented with native threads. There's work to add full VM-level coroutines in Java 8, and you can build versions of OpenJDK with coroutine support already. Once that's there, we will have substantially faster Fibers than Ruby 1.9.
JRuby supports all of Ruby's class structures and features atop the JVM. The JVM's type model does not hinder us implementing Ruby's class model.
The JVM optimizes calls; Ruby makes lots of calls. The JVM does an outstanding job of optimizing Ruby code in JRuby, and invokedynamic is already making small Ruby benchmarks in JRuby run within a few * the speed of an equivalent Java implementation. That's incredible. I've actually sat and read the assembly code Hotspot outputs and worked steadily to remove as much overhead as possible, with or without invokedynamic. I guarantee you the JVM is going to optimize Ruby like gangbusters. You don't know what you're talking about.
I'm not sure what Smalltalk performance you're talking about. No Smalltalk implementation has managed to approach the performance of current JVMs, and JRuby is starting to approach the performance of Java when using invokedynamic.
If you care about Ruby as a language, supporting many implementations and caring about all of them is a no-brainer. Slagging off one implementation you obviously have no correct facts about shows you don't care about Ruby as much as you harbor bigotry against one implementation.
Headius, you're awesome and I'm honored that you replied to my stupid rant.
My reply was meant for people that questioned a project like Rubinius when there is JRuby around. And you're right, I only have a very high-level overview of the problems you're encountering, mostly being just educated (or maybe not) guesses.
The reason for my rant is that Rubinius is awesome too and I would rather see Rubinius replace MRI as THE reference implementation - since it's a more flexible environment built from scratch, people will be able to experiment with features more easily.
I do however object to one thing you said - continuations are awesome and I'm sad they got pulled from Rubinius.
In general, Wall St tends to use this nomenclature (i.e., $X billion dollar company) when referencing revenues. For instance, Procter & Gamble is referred to as an "$80 billion dollar company" - which speaks to revenue, not market cap.
This gets murky with private firms, since revenue isn't typically shared, and even more so with startups where so much of the value is based on future, projected earnings.
In general, though, I'd say the nomenclature more commonly refers to revenues and not 'valuation'.
The government is doing this because the record labels are lobbying them to do so. While the incompetence of the agencies in question are laughable, the enemy isn't DHS as much as the lobbyists from the recording industry who are increasingly talking the government into spending tax dollars to enforce their civil rights, which they should have to continue funding on their own.
Writing this off as a government power grab is not seeing the forest through the trees.
> who are increasingly talking the government into spending tax dollars to enforce their civil rights, which they should have to continue funding on their own.
That doesn't excuse govt, or folks who think that govt should have such powers.
> Writing this off as a government power grab is not seeing the forest through the trees.
It's not a govt power grab so much as it is yet another abuse of govt power.
And to think that many people think that govt should have more power, apparently on the "if we just give them enough power, they'll start behaving" theory.
Not really, all this seems to be doing is programmatically adding spans with classes around letters/words/lines. The layout is still being specified in the CSS.
I don't think it's really violating any 'rules' as much as just providing a bit of convenience.
It's curious that so many of them are 70+ years old, which means they were the right age to benefit from the huge economic boom that occurred in the United States after World War II.
Seems to support the hypothesis that success is equal parts smarts, hard work and timing.
Sheldon Adelson 77
Carl Berg 73
Stephen Bisciotti 50
Leon Charney 72
John Paul DeJoria 66
Larry Ellison 66
Alan Gerry 81
Alec Gores 57
Harold Hamm 64
George Joseph 89
Kirk Kerkorian 93
Ken Langone 75
Ralph Lauren 71
Carl Lindner Jr 91
David Murdock 87
Thomas Peterffy 65
Howard Schultz 57
Kenny Troutt 62
Albert Ueltschi 93
Oprah Winfrey 56
This is exactly why systems like this never work out. One could argue that to-do apps like Remember the Milk would have cashed in on this if there was really a market for it. The problem is that, for most of us, our lives are the result of goals and objectives and a healthy dose of luck and randomness.
Like that old commercial pointed out, very few children say they want to "claw my way to middle management" despite the fact that's what happens to a lot of us.
I would expect a service like this to fail partly because people aren't that organized and partly because those that are would be underwhelmed by how things turn out. Nobody likes a service that makes you feel like a failure.
Unfortunately, the arguments trying to draw some kind of monumental distinction between TypeScript, Dart and CoffeeScript are silly. They are all a response to the state of client-side development and are all applying essentially the same strategy (i.e., some syntax changes and a pre-compiler). It's great that TypeScript is a superset, which is what makes it pretty interesting to me, but it's still more similar to the other two than not.
Plus, what's so bad about being Microsoft's "answer" to something else? Windows was the response to Mac OS, Xbox was a response to PlayStation, .NET was the response to Java, ASP.NET AJAX was the response to Prototype (later abandoned for jQuery), ASP.NET MVC was the response to Rails, Entity Framework was the response to Hibernate/Active Record, NuGet was the response to Rubygems/npm. Each of these moved MSFT forward and several of them moved the industry forward. The ASP.NET team (of which Mr. Hanselman is a member) is doing a lot of great stuff inside MSFT, but a lot of is derivative. That's okay. It's largely the strategy MSFT has always followed, so why waste energy defending what has worked well in the past?
I agree with one point, however: It is disappointing when smart people display a profound ignorance of computing history.