Dare Obsanjo‘s article, Brendan Eich on Mozilla and the Future of AJAX, has some interesting points, but this note won’t be commenting on those (although I may do so later on).
However, in the entry, the following snippet is found:
open_source + open_standards != user_driven_innovations;
Now, while I don’t have any trouble understanding Dare’s point, there’s just one little thing that annoys me with this approach: It doesn’t really make sense, from a programming perspective.
First of all, declaring the sum of two variables isn’t possible in any language I’ve ever heard of (think about it — what would be the value of each variable?). But more importantly, you can’t negatively declare a variable, meaning, you can’t define what it’s not. != is used in comparison only.
I see this rather often on IRC and such. The thinking seems to be that you can define what a value is, thus you can also define what it’s not. But that doesn’t make sense. It’s a smart ass way of intermingling programming with your writing, but makes you seem like you’re really not (smart, that is).
By all means, do define what things are not. Just don’t put in some hot shot mathematical formula, trying to look cool. You don’t.
(But again, this doesn’t have anything to do with the article itself — that’s a whole different story. Again, maybe more later.)
I saw a documentary some weeks ago, about David Beckham going to LA Galaxy, and what it would take for him to succeed. There was also an interview with a guy — I don’t recall his name, but I think he was a journalist — who was confident that Becks would fail, mainly due to all the problems Americans seem to have with soccer:
- There aren’t a lot of goals. Americans like lots of goals.
- Soccer is played with the feet. Americans like to use their hands.
I think there was one more, but I don’t remember it, and what I want to do is focus on his second point: Americans like to use their hands. And then it struck me, only in America can a game where the only foot-to-ball contact is the field goals (and the rare use of the foot to kick the ball forward), be called football.
Since html2css is built upon Beautiful Soup, it is relatively easy to monkeypatch it. (Especially since there is a shortcut in the code, that lets Soup objects be used directly, achieving greater speed.)
Monkeypatching BS to use html2css is as easy as this:
>>> from beautifulsoup import BeautifulSoup
>>> from html2css import html2css
>>> setattr(BeautifulSoup, 'toCss', lambda soup: html2css(soup).display())
>>> soup = BeautifulSoup('<html id="foo"><body></body></html>')
>>> print soup.toCss()
html {}
body {}
html#foo {}
html#foo body {}
There you go. (This also illustrates an advantage of Python’s explicit self declaration, in that toCss actually takes an argument (soup), which is then used as a self-declaration, meaning that toCss can be called without arguments — otherwise, it would have been soup.toCss(soup), which really isn’t optimal.)
“Catch a man a fish, and you can sell it to him. Teach a man to fish, and you ruin a wonderful business opportunity.”
I tested today, and found that you can actually extend a class, on itself. Not just by using setattr(), but also by creating a new class:
>>> class bar:
... def monkey(self):
... print 'neat'
...
>>> class bar(bar):
... def horse(self):
... print 'sweet'
...
>>> bar().monkey()
neat
>>> bar().horse()
sweet
Again, this might be in the manual, I just didn’t know of it until some ten minutes ago.
It’s liberty for all
‘Cause democracy’s our style
Unless you are against us
Then it’s prison without trial.
It worked for Zeldman, so I’ll have a shot: Why isn’t apple.com/osx/ pointing to a relevant page? I mean, sure, apple.com/macosx/ works, but it would make sense that /osx/ did so as well.
But that’s just my opinion.
A friend in need’s a friend indeed,
A friend with weed is better.
I just started my first project at Google code: html2css, a project I’ve been working on for some weeks now.
html2css has one simple function: Turn an HTML file into a CSS file. This is a functionality I’ve become increasingly aware that I need; I often find myself in a situation where I’ve mocked up the entire HTML document, and then have to perform the tedious task of applying it all in my CSS file, which often leads to a disorganized mess.
It uses the incredible Beautiful Soup library, meaning that it can tolerate even the worst piece of HTML — it manages to produce a valid representation of a Google search.
There are two files of interest in the project (discarding the bundled beautifulsoup.py). The first one is html2css.py where most of the magic happens. The other is writecss.py which is a useful extension of html2css. It allows you to turn your HTML into CSS, respecting earlier generations from html2css. This means you can generate a CSS file for one HTML structure, add some CSS rules, modify the HTML, regenerate the CSS, and your rules will still be present, given that you haven’t modified the element they’re attached to.
This is a 0.1 release, but it should be pretty stable. Comments appreciated.
Revolution, the only solution.
