Of Responsabilities

Yesterday, Mozilla Foundation announced that future versions of Firefox will have support for a DRM scheme called EME. By their own blog post — and by several news outlets around — it is not a decision they are happy with and feel they had to add to not force anyone to switch browsers.

(Just small note here: Yes, they don’t want people to switch browsers because that would mean less revenue for them, but at the same time, Firefox is one of the only major browsers that really cares about privacy and not just how their icon looks better in this version. Anyway…)

After the announcement, a lot of people start claiming some stuff like “hey, last CEO was called out for a lot less than this” and “we need a new ‘pure’ browser”.

Yeah, yeah, I get why you are angry. I just think your anger is misdirected.

Imagine this: there is this kid. The kid is bullied non-stop by richer kids, but he’s stoic. He takes the punchs like nothing. You root for the kid, because he never returns violence with violence. Then, one day, the kid kills himself. What happens?

1. You call the kid stupid for killing himself?

2. You go after the rich kids and show them what they did?

The right, moral answer is 2. The kid suffered enough and just saw no other exit. It was not a noble option (or smart, let’s say), but it was the only option he saw.

Now, that’s the same thing: Mozilla had to kill one of its morals because richer kids pushed something made to reduce your freedom just so you wouldn’t need to give up your other freedoms (privacy, for example).

And then people want full rampage on Mozilla for taking this decision.

A decision forced on them by richer kids.

Richer kids like Google, Microsoft, BBC and Netflix.

Now, there is absolutely no one going after Google for backing EME; there is no one saying “Microsoft, always fucking up with the user”; there is no one telling BBC to stick to news and stop messing with IT; there is no one willing to lose watching The Next Generation for the 11th time instead of supporting Netflix. Nope, everyone is against Mozilla decision.

Mozilla is not resposible for DRM on Firefox; Google, Microsoft, BBC and Netflix are.

So, if you’re pissed, go cancel your Microsoft account; delete your Gmail; forget about YouTube; stop getting your BBC news; cancel your Netflix account. Show the rich kids that you don’t accept their actions and don’t want to be around them anymore.

(But, in the end, it’s a lot easier to switch browsers than stop watching cat videos on the internet thanks to YouTube or watching your old series on Netflix. And, thus, it is easier to go after Mozilla than doing what’s right.)

When Chrome crashes…

[6666:6680:32113841705:ERROR:net/base/host_resolver_impl.cc(802)] Called HostResolverImpl::CancelRequest() after Shutdown().
	start_thread [0x27a96e]
[6666:6691:32113881274:ERROR:net/ocsp/nss_ocsp.cc(480)] No URLRequestContext for OCSP handler.
--2010-06-17 17:38:06--  https://clients2.google.com/cr/report
Resolving clients2.google.com...,,, ...
Connecting to clients2.google.com||:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: unspecified [text/html]
Saving to: `/dev/fd/3'

    [< =>                                    ] 0           --.-K/s              
Crash dump id: 5b50180e394484f6
    [ < =>                                   ] 16          --.-K/s   in 0s      

2010-06-17 17:38:08 (165 KB/s) - `/dev/fd/3' saved [16]

Damn Google: When you are going to learn to not hide stuff from users? What about stop being lazy and write a proper crash report tool and a proper update tool, instead of doing those things hidden from the user?

And yes, I’m tired of ksurl showing out of nowhere and basically killing my slow connection at home, with Chrome not saying a damn word about it.

Why Go feels like a balloon boy

One of my friends like to use the expression “balloon boy” to everything that gets a lot of attention but it turns to be a lot less interesting in the end.

Go is a new language created by Google that recently went open source and generated a lot of buzz in the interpipes.

As someone who have been working as programmer for almost 20 years and worked with almost a dozen languages and, on top of that, have a blog, I think I’m entitled to give my biased opinion about it.

One of the first things that got me off was the video pointing that the language is faster. Or the compiler is. Honestly, pointing that you become more productive because your compiler is fast is utterly wrong. If you’re aiming for a new language and you want people to be productive with it, make it so it’s easier to write code right in the first time. If you need to keep compiling your code over and over again till it does the right thing, you should probably check if there isn’t any impairment in the language itself that prevents right code to be written in the first place.

Which brings us to my second peeve about Go: The syntax, as presented in the tutorial. Syntax, in my opinion, is the biggest feature any programming language have to offer. If the syntax is straightfoward and easy to understand, it makes easier to have multiple developers working on the same code; if the language allows multiple “dialects” (or ways to write the same code), each developer may be inclined to use a different approach to write the code (which basically does the same thing) and you end up with a mess of a code where most developers would feel like rewriting than fixing a bug or adding a feature.

The first thing that caught my eye was the “import” statement that at some point uses a name before it and a block in the second example. Why two different ways (well, three if you count that one is probably optional — in the middle of the statement, nonetheless!) to import other packages with the same command?

Variable declaration also feels weird. “a variable p of type string” is longer to read than “a string p” (comparing var p string := ""; with C way string *p = "";). And that goes on. If you keep reading the statements in their long form (expanding them to natural English), all commands start to feel awkward and adding unnecessary cruft on the code, things that could be easily dismissed and force people to do less typing.

The “object” interface seems derived from JavaScript, which is a bad idea, since JavaScript have absolutely no way to create objects in the proper sense. And, because object attributes and members can be spread around instead of staying grouped together, like in C++ and Python, you can simply add methods out of imports. Ok, it works a bit like duck-taping methods in existing objects, but still can make a mess if you add two objects in one file and people decide to add methods just in the end of the file: You end up with a bunch of methods about different objects all spread your code, when you could “force” them to stay together.

So far, those were my first impressions of the language and, as you can see, it was not a good first impression. Focusing on compile speed instead of code easiness/correctness seems out of place for current IT necessities and the language seems to pick some of the worst aspects of most languages around.

OSDC 2008, day 1

Ok, first “real” day of the conference.

The opening keynote was made by Chris DiBona, Google open source manager and license extraordinarie (or something along those lines.) He made some points about the grown of Summer of Code in Australia (with the sad note that only 7 students registered, even with 68 tutors), the number of licenses used by Google, Google usage and contribution of open source code… And yes, suddenly, it start sounding like “Here, Google is a friend Open Source!” propaganda, but DiBona manage to point that most of what he was talking was to make a point to other companies and how they could make a step into and alongside open source. But, apart from the little propaganda side (I can guess that it was completely unintentional), the graphs he showed, like the number of students and tutors through the years of Summer of Code in Australia and the number of licenses used by Google and other small peals, where really interesting.

The first session I saw after the opening keynote was Michael Neale talking about “Rule based systems – using rules to manage business logic”, mostly because I worked with a system written in C where we had to write all the business rules and such. Well, I surely wasn’t expecting a talk about decision trees, expert systems and logical programming, but it was interesting nonetheless. The interesting bits to me were some talk about logical programming and how rule based systems approach that. Even more interesting was knowing that Clips can generate rules by analyzing other rules.

Then I went to see Nicolas Steenhout talk about “Web accessibility and Content Management Systems”, mostly ’cause I’m terrible annoyed by websites that force me to use the mouse (looong time memories of using Lynx/Links ’cause it was the only thing that run properly on Linux and because I’d like to be a “real nerd”) and ’cause I really dislike the way sites are built these days. He pointed the current state of WCAG (Web Content Accessibility Guidelines): 1.0 is too old and 2.0 is not finished yet. He also mentioned the problem that the Sydney Olympics 2000 website had due not having any accessibility (they were sued about that) and how Target was also sued for not providing accessibility in their website.

Third session was Tennessee Leeuwenburg and “Google AppEngine + ExtJS prototyping demonstration.” That was one presentation that didn’t went well. Because the wireless was down and everyone had no internet at all, there was no prototyping and, obviously, no demonstration. So we saw some nice screenshots about AppEngine and some ExtJS screenshots and… that was it. I’m pretty sure the 30 minute space to talk about a topic was also a problem.

Next was Thomas Lee and “Python Language Internals: From Source to Execution”, which was a pretty good demonstration of the Python code. And by Python code I mean the very core of Python. What he did was, using the trunk code of Python, add a new command, from the parser, to the very end of creating a bytecode for it. Really impressive and, honestly, a big surprise that Python code is clean even when it’s not written in Python (most of the changed code was C code.)

Then Andrew Bennetts and “Python’s Unittest module: an under appreciated gem”. I was expecting a lot of weird tricks with unittest, but it seems that after a whole year using it, there was nothing new I could get from it. On the other hand, I got some pretty good list of extensions for Unittest, which provide a few more things that I may use in the future. The canonical (pun intented, as you’ll see) of such extensions is in Pyunit-Friends project in Launchpad.

“Extending Nagios with Python Plugins” by Maneschi (whose name I managed to completely lose somewhere) was more about Nagios than Python which was completely my fault. Anyway, it was an interesting talk, pointing some code used to collect information to Nagios.

Lastly, I went to “Getting Your Average Joe to use Open Source Software” by Peter Serwylo. Nothing new, I know, but he pointed some “gentler” methods to make people use Open Source (like keeping the user files and such — something that I barely thought after being constantly annoyed by “technical support” calls from my parents.) I think the way he described his methods were more in the way of “show the users what they can do” than “convert them!”, which seems to be the most commom way of making people use free software.

And I completely skipped the Lightning talks, and the Dinner Keynote.

Google car

Google car, originally uploaded by Julio Biason.

I saw it a few days ago, but it was raining and there was a bucket on the camera thing.

Today, a sunny day, the car was there again, without the bucket. Maybe I’ll be on Google Maps in the future! :)