I've seen several proposals, such as making patents non transferable, shortening their life time or not allowing cases to go to court unless you can prove your business depends on that patent.
> Circles are ok to set up at the beginning, but many people belong in more than one circle and it gets cognitively tiring to sort people appropriately into one-and-only-one circle.
A person can belong to more than one circle (that's why you have a list of checkboxes, one per circle).
Look at the position of Javascript. It's fair to say it's used exclusively for web development (node.js is quite marginal) and it still tops the job chart.
Ruby on Rails would be there as well if it were mainstream.
entries = new ArrayList<Integer>() {{
add(3);
add(4);
}}
But yes, certainly not as elegant as Scala. Having said that, you don't encounter literal collections very often (except maybe in tests).
6) Named parameters are pretty easy to emulate:
new Window().width(100).height(50)
although the builder pattern is safer:
Window w = new Window.Builder().width(100).height(50).build();
7) No more checked exceptions: celebrating this is like saying that your code is shorter because you no longer bother checking for errors.
8) You can only omit parenthese in Scala when there is exactly one parameter:
x.foo a <-- legal
x.foo a b <-- illegal
x.foo(a, b) <-- legal
One of the many syntactic quirks that Scala suffers from
9) Comprehensions are neat but they suffer from a crippled performance limitation that forces you to revert to imperative loops, even in optimized mode. This technical problem is serious and there is no solution in sight at the moment.
There are genuine reasons to be excited about Scala but this article makes me think that the author just discovered Scala and they haven't really dug very deep yet. When you do, you start realizing that Scala's nice features are offset by quite a few annoying limitations that will probably doom this language to a niche.
All the frameworks "are growing up", this is nothing to be proud about. The real question is: is the framework becoming mature?
Because RoR has this tendency to reinvent itself every 18 months or so, the answer to the question is a resounding no. It's being used mostly to explore new ways to create web sites, but RoR is more and more becoming a framework you really want to avoid if you need to create a production site that you are planning to work on for years to come.
While the system might need some revisions, it's certainly not as broken as a lot of abolitionists are depicting. Some things are working fine, and innovation is happening at a very fast pace in the US.
Software patents can be abused but they can also be a force that encourages people to actually innovate instead of just copying what's already out there (which is pretty much all we are seeing from countries that don't have software patent laws).
There is really no reason to feel embarrassed because you use a GUI. A terminal is a terrible vehicle to display the complex information that git needs to show you, especially `status`, `diff`, etc...
To me, git GUI's are like IDE's: they make you more productive, so you'd be a fool to ignore them.