Rails 3 : Vaporware To Awesome
slideshare.net
slideshare.net
Some day, Rails 3.0 will be old news and I'm sure he won't appreciate it when some young kid gets on stage saying "Rails 3.0 sucked, how could they have been so stupid?! Look how much better my code is!"
Give credit where credit is due -- and remember we all stand on the shoulders of giants, show a little respect, eh?
This statement was made in comparison to merb, which succeeded in getting more mindshare than the other 'Rails competitors.' This was largely because merb attempted to do much the same things that Rails was trying to do, but to do them in a much better way.
He was indirectly positive about Sinatra throughout his talk, and when covering router changes, kept describing how you could mount Sinatra applications inside of your Rails3 app.
The "prototype sucks comment" was made along with a very tongue-in-cheek "everyone will move to jquery" comment. He was laughing when he said it, and I got the impression that he was simply making a joke as the author of jquery.
He never once said anyone was stupid. Actually, that's not entirely true, he was pretty critical about some of the code found in Rails 2.x. He backed his criticism up by showing the code, and I certainly didn't think he was out of line.
Or maybe because Merb was done by people already hooked into the Rails community, and so could more easily get the attention of developers who don't otherwise seem interested in exploring other frameworks?
Nitro, for example, predated Merb (it came out at the same time as Rails) and was doing many things better than Rails (multi-threaded, easy to swap out ORMs, no boinking of built-in classes, Rack-like app request processing pipeline before there was Rack; much faster overall), but got almost zero traction. And I don't think it was because people tried it and didn't care for it, but because all the noise was (rather deliberately) about Rails.
There is a "winner takes all" mentality among some Rubyists that leads them to dismiss anything that isn't the clear leader. Sort of like high school kids who are afraid to be seen talking to the nerds because people might think them uncool.
This means that generally I've shifted from the thinking "this other person's code is shit" to "I'm betting there was a reason they did it this way." As it turns out, there almost always is. With the benefit of hindsight, those reasons can sometimes seem foolish, but that's the thing about hindsight. More often than not though, once I take the time to understand them, the decisions of the original author turn out to be better than my knee-jerk response.
When your overall attitude is still in the "everyone else's code sucks" mindset it leaks out through your language, and I think that's what is happening here, however slightly. There is no reason to use the word "failed" or use the word "sucks" when talking about another person's work, particularly when it's work that people are using in production for free and work that is open sourced, like Sinatra or Prototype. Even moreso when you're promoting an iteration of improvements on a platform that benefits from the work and experience of many man-months of volunteers, an iteration that is still not even released yet.
Agreed. That's apples and oranges! Rails and Sinatra are different tools for different problems, IMO.
Actually no. With rails3, rails will just be a meta gem. If you install rails-core you'll get something like Rack plus not much more which is basically what sinatra is.
I'm very interested in the talk but it's near impossible to understand him and the warbling noise gives me instant-headache. No way for me to consume it as it is.
Having said that, I don't really know much about Rails. This comment is not about Rails. I just have to tell people because I keep thinking about something and almost no one seems to get it and realistically I am probably never going to follow through with it so if I can't communicate this idea it might not go anywhere. And with all of the positive progressive things Rails developers are doing, maybe, just maybe someone reading this will get what I am talking about.
Basically, I keep thinking, especially just now when I was looking at that Rails code in his slides, the way everything is so well abstracted and so _structured_, and how he keeps going to the model with the circles connecting, and how we keep repeating keywords all over the place, and how no one ever wants to look at unsyntaxhighlighted code anymore, I have to say _again_, one-dimensional non-interactive (or two dimensional if you insist on calling it that) textual representations of software are outdated and unnecessary now.
Sure, we do still have to type a lot of text in, and I am not trying to throw out my keyboard, or stop thinking or something. But there just really isn't any reason we have to be limited to text on a daily basis anymore. People just have a cognitive bias towards the status quo which is preventing them from taking the step to add a layer of two-dimensional widgets or something over the code. I am talking about code generating widgets, or intentional software, or a generic interactive graphical representation for function calls, control flow, model development. Things like that.
Because basically a lot of code, even the things that involve a lot of abstractions with embedded textual mini-languages in them, are mostly mapping from one thing to another. Doing transformations on structures. Code-completion is a start, but what we really want are more useful iteractions with the models and algorithms. The way forward is things like code generation, projectional editing, live coding, dynamic evaluation and representation (widgets) etc. Anything that provides more interactivity to the software development process is where we should be going.
And the next big step is to get out of the limitation of using textual code as the default editing level. Often times we are basically configuring/connecting functions/components, editing models, or using text to generate two dimensional features like tables/grids, UI forms, sometimes mathematical functions, or dynamic systems that we really need to interact with at runtime with dynamic graphical editors to manipulate and comprehend properly. So we should start on the two-dimensional, graphical level. Also, downloading open source projects whose claim to fame is completeness and ease of integration and then reading documentation which amounts to what commands to enter on the command line and then cutting and pasting and editing configuration text files in terminal windows is not cutting it anymore. There are these things called (graphical?) components. We can accomplish this with things like projectional editors, or even more simply by interacting with widgets that generate code. And yes, I know what LabView is, and no, that tool and other attempts at visual programming systems haven't proven anything. Its just hard to get these types of tools to be as generic as text-only systems, especially fully integrating keyboard and text use, AND, the number one hindrance, I believe, is status quo bias like loss aversion.
While often excellent, these frameworks usually disappear (or morph to new incompatible forms) within a decade leaving behind cast-off skeletons, the underlying code they generated, to be maintained for decades to come.
Programmers seek security in a lingua franca, a common level of coding/specification that they are comfortable with and that they believe will remain useful as long as possible. The programming language level seems to be the sweet spot today. It is no accident that most frameworks generate code at the programming language level.
I'm not sure I have ever really sought security in any particular programming language or version. Also, when you say "the programming language level" -- some languages evolve very quickly, and from one project to the next, even though it is basically the "same" language sometimes requires developers to learn very different ways of doing things. C (from procedural to object-oriented) or C# and its rapid changes are examples.
Since we are starting with the machine hardware level there must be some route from the representation closest to the problem domain to that level. So we generate code for the next lowest level. A 4GL editor generates 3GL code and 3GL compiler generates 2GL code and a 2GL assembler generates 1GL (machine) code.
I guess I don't feel like the 4GL (or call them 5GL if you want) tools have the capabilities we need to be able to throw out the 3GL, and I want to throw it out, or at least use it much, much less.
Is there an online multiuser environment for coding/interacting with widgets? http://news.ycombinator.com/item?id=670228
I was wrong.
How does that compare to your vision?
Also, I am not sure what the best approach is, but I think we can go beyond even the ability to connect properties on components. Not sure if it needs to be as complex as projectional editors like Intentional Software is creating or if maybe in some ways that might be more complex than we want. Here is one idea I had awhile ago. (Just an idea, certainly doesn't represent a vision or anything http://ilaksh.wordpress.com/2009/04/19/2d-programming-via-co...)
I also think that real-time collaborative environments are a huge boost.
I look forward to learning this new web framework that is also called ruby on rails ;-)
I also hope that Rails 3 will cut down some of the noise for newbies and oldies alike.
A lot of the complexity in Rails is hidden until you need it. If you don't understand Rails caching yet, that's no problem, you don't have to understand it until you actually have to use it. Ditto the more advanced ActiveRecord tricks like named_scope, or the deep rabbit holes in the general vicinity of templating engines.
IMHO, this is Apple's "secret sauce." Their hardware and software is just hardware and software, it can be mimicked. The thing that sets their hw/sw apart is its discoverability, and that is very, very hard to copy because it is a thought process, a concept, a zen.
Jason Fried makes this point in SvN: http://37signals.com/svn/posts/1561-why-you-shouldnt-copy-us... (with a recursive reference to HN http://news.ycombinator.com/item?id=469940 :-).
As for the release date: "[T]he Rails 3 release date will likely be in the first quarter of 2010, or even before Christmas 09 if things go really well." (http://railsnotes.com/745-rails-3-release-date-news/)