ronin

Leonard Lin: Internet Asshattery, Armchair Scaling Experts Edition

The hack for the iPlayer from last week was closed by the BBC, but only by more obsfucation. Therefore, there is a patch for last weeks script which fixes the problem.

Reading the comments there are a few people out there working on making this better, and it looks like there is a script to generate an RSS feed for the iplayer website.

BBC’s iPlayer is good, but this makes it better.

Found via

An InfoQ article on Ruby threading and the implications of the approach taken in YARV. Nicely written up. I think I would probably prefer an Erlang approach which seems much more high level and would suit Ruby more than native Threads.

Charles Nutter makes some good points about how he would change Ruby. It’s interesting to see the different perspectives of somebody actually trying to implement Ruby in a new environment.

Found this blog entry by Rick DeNatale about improving Ruby, I pretty much agree with everything said there.

I was going to add my own 2 cents but being the careful person I am(not) I actually went and read the original article and a couple of the different entries to the competition.

I found that this article by Jamie Macey pretty much says everything I was going too. Simplify the syntax, simplify the libraries, add unicode.

If there was one thing further I would say it would be related to what Avi Bryant has said before. Rewrite all of the Ruby libraries in Ruby, and then make Ruby fast enough to run them. IMO this is a precursor to making Ruby run on more platforms, much like Squeak has a small amount of C to bootstrap it and then the rest is all Smalltalk.

Btw, the Smalltalk class, metaclass, object relationships that Rick DeNatale was talking about in his post are(I think) encapsulated in the diagram below(which I lifted from the Bluebook).

Looks like the Rails scaffolding doesn’t like it when your model uses a different table name from the default mapping it expects(like when accessing a legacy database model).

So if you have a model like so:

class Thing < ActiveRecord::Base
    set_table_name "some_thing"
end

Then ActiveRecord will be expecting a table called “some_thing”, however the scaffolding generator is expecting the default, which is going to be “things”(or something like that since I can’t be bothered actually generating a model called Thing).

When running your generator you’re going to end up with an error like:

error  Before updating scaffolding from new DB schema, try creating a table for your model (Thing)

Annoying as this is, you can work around it by temporarily creating the table required by the generator. Then go ahead and drop it after the generator works.

create table things ();

I’m not sure what longer term effects this causes, and if there is a better way then let me know.

Blaine Buxton’s slides on scaling twitter.

Elliotte Rusty Harold: Type Inference: Another Bad Idea for Java 7

Type inference actually makes some sense in languages like JavaScript and PHP that are built around this, and had this feature from day 1. It makes no sense in a language like Java that’s built around the opposite. It makes Java look weakly typed, but it isn’t. In fact, if anything this is now more strongly typed…

Good analysis of a bad idea. I really dislike the idea of adding more and more language features that require new syntax or something like described in the above article. It just makes it confusing. Either create a new Java which has all the old crap tidied up, or go ahead and write a new language that can run on a JVM which has all the features and language constructs you need.

This is why I really like Smalltalk. There are very few reserved words, and the language is highly extensible so you can go ahead and implement new ideas without breaking anything old, requiring arcane syntax, or making the language less usable. Ruby struggles in this area also due to all the different ways of doing something.

Simplicity has a lot going for it.

Avi Bryant on implementing all of Ruby in Ruby:

To me, one thing that’s wonderful about both Smalltalk and Java is that all of their libraries, including basic data structures like lists and hashtables, are implemented in, respectively, Smalltalk and Java.

When Ruby is fast enough to implement most of it’s standard library in Ruby then it might lose the scripting label which seems to be hanging around it’s neck. There seem to be a few other efforts going on to implement the language, incluing JRuby, and they can only contribute to making Ruby better.

Also efforts like this wiki are a good idea as well.