Heresy onoes!!shift!one

If the author of this article is a car owner, I'll burst out laughing.

Cuil got pwned

I had noticed that Cuil was choking when I tried it. It turns out that it indeed failed because of the flood of people coming in from press coverage articles from all over the net.

When Law gets messy

I think this was a crappy course of action, but it raises some questions about accountability as it relates to free speech, as well as privacy and reputation concerns and the ethics and shortcomings of the monetized damages system.

Capoeira

Cool, I just got home and there is a capoeira group practicing on the park accross the street. Don't see that very often :)

I like watching capoeira circles, it's a very unique and creative form of art. Its history is also fascinating.

An opinion on the Mojave Experiment

Here's an interesting opinion by Wil Shipley.

Not exactly sure if the rant is really valid though. I can run into problems-that-you'd-never-see-on-a-15-minute-test run under any operating system.

I think the point of this marketing gimmick was to break the word-of-mouth myth that Vista sucks. The myth that got tossed around was "I hear it sucks". It doesn't get into why Vista sucks or whether it even really sucks for what you do. And it makes sense that it doesn't go there because once you do, you'll realize that every OS sucks for one or another reason: hardware isn't supported, games don't work, Swiss cheese security, whatever. Marketing is all about the perception.

Now people can tell their friends "oh yeah, they had this clever experiment and it turned out Vista is actually kinda nice", with no zealotry-strings attached.

Remember when the iPhone was first announced and common people like you and me were like "wow that is so hot", without having ever touched one? That's the message that got tossed around. Never mind that the contract wasn't exactly sexy, that you could be getting hundreds of billing pages in the mail per month, or that you couldn't get a good signal depending on where you were. It was "so hot".

Anyways. There's something important about changing operating systems that people seem to ignore: changing habits is hard and annoying. Of course a lot of people go back to the old stuff while it still works for them. It's easy to fall into routine. But that's just looking at one piece of the statistical pie. A lot of people go and switch to Macs. And a lot go with Vista. In a continent with hundreds of millions of people, we can pretty much say "a lot of people this" and "a lot of people that", and chances are, we're probably right.

One point that is more specific to operating systems: adoption and compatibility. Of course 3rd party software isn't gonna run if the OS isn't supported. Of course it can fail to run even when it claims to be supported. Every programmer knows that bugs and cataclysmic turns of events happen. Scope creep, unreasonable deadlines, inept fresh-out-school barely-graduated juniors, the daily wtf, we all have stories.

All in all

I'm not going to say Vista rocks or sucks based on criteria that I can twist to bash/praise other OSes, because that's basically good ol' Microsoft-hating bandwagoning and zealotry. I'm not going to say anything based on personal experience, because opinions only amount to speculation and the only way to really make up our own minds is to go and try it ourselves.

If anyone wants to discuss the ethics of doing an "experiment" as a marketing gimmick, I think the bottom line is this: money drives the economy, programmers get paid and people can afford to spend time blogging about ethics. </opinion>

Lakes in Titan

With a hydrological cycle and everything. Wouldn't it be awesome if it turns out that there's life there too?

Native Canvas in IE

This sounds neat.

Mechanical Turk

Interesting. I wonder how they verify that workers are indeed doing their jobs and not just running some random script.

Mojave

The website.

I still think it was a clever marketing trick.

Stupid Filter

Agree, disagree, I think this is an awesome idea.

It doesn't catch the "first" comment, though.

Cuil

So everyone is talking about Cuil and how Google is not worried.

I tried a few searches and I think it's actually pretty neat concept. It's very categorical, which allows for easier exploratory searching than Google, and it uses the screen real estate evenly when returning results. It's too bad it doesn't have a quick Wikipedia link.

My critique is mostly from a usability perspective and goes to how they have images beside entries, which I consider distracting for anything but logos, and the somewhat arbitrary placement of things in the page. In a regular search engine, users expect items with the highest relevance near the top, so it's easy to develop spatial memory and just look at the first 2 or 3 links. In Cuil, there's no no-brainer way of figuring out which one is the highest relevance link without putting a bit of effort into actually scanning the page. Also, they could align the entries so that they are always the same width and height and so that they don't scroll off the page.

I've also come across many links within the UI that gave me no results. I get that in Google sometimes too, but far less often. Another thing that could be better is the page loading speed.

More on loops

Someone had asked me to redo my loop benchmarks a while back. Looks like I was beat to it.

It's not your fault

A quote from Johanna Rothman:

A salesperson should never have to apologize to me about the lack of user interface keeping me at the store longer than it should have.

via

MPAA to show us where to get things legally

Twas about time they did something like this. But then again, link, or it didn't happen.

Gender equality

Nice post that talks about policies about behaviour that wouldn't had been missed if they had died with the end of the last millenium.

Do no evil?

Well, how else would Knols not flop?

Microsoft to sponsor apache

Cool. Though 100k / yr doesn't pay for a whole lot nowadays.

On Programming

nice article. Pretty much sums up how I feel about programming :)

IE8 in '08

Or so the rumours say. I'm very excited about this: we will finally have full ACID 2 compliance across the board. Hello :before and :after :)

The only thing that worries me is that the relatively short beta period might leave a lot of bugs to be patched after the official release.

The death of software patents

Interesting.

Can you break your own software?

Schneier talks about Kaminsky's DNS cache poisoning attack. The last few lines are inspiring.

Would you be able to tell what parts of your systems are weak in terms of security? Remember, systems are not just code. You need to think in terms of what each user can do that could be harmful (to the code, to the data, to the infrastructure, and especially, with the trend towards web-based services, to other users). What happens if there's a power failure on your db server? What happens if I maliciously overwrite JQuery in my advertising code? Can I crawl your site and write a script to try people's publicly available data as their login passwords? Can I find this info by crawling other sites? (son's name is a good one to search for). Can I use Google Maps and IP locators in conjunction with the ability to link to off-site, dynamically-generated images as my forum avatar and find your physical location? Can I easily spoof your emails? Is your captcha broken?

There are so many things that could be vulnerable that even starting to look for them could be discouraging. But, as the old saying goes, it's better to be safe than sorry.

Do the test

On the link in the post about magic from yesterday, there was an video with basketball passes.

This one is so much better.

Impress your friends with fake ad-sense earnings

Using document.designMode and the printscreen button. Of course, you could just use Firebug, jash or, if you're just doing screenshots, Photoshop.

You could also import a library like Prototype (read the jash bookmarklet url to see how that is done) and write something like javascript:new Ajax.Updater(document.body, "myspoofingpage.html"); on the address bar.

document.designMode is what most web based WYSIWYG editors use to provide editability, except that editors usually enable it in an iframe rather than the actual main page. The advantage of using designMode over pure javascript is that the cursor manipulation is native with designMode, hence it's more responsive.

Anyways, the only thing I don't get is: why does anyone ever feel the urge to pretend they are richer than they really are? That's so lame.

Warning Forever

For those wondering what the heck is that link on "games" on my About me section, it's the download page for Warning Forever. Here's the wikipedia entry on the game.

Bascially, the main feature of the game is that you only fight bosses, and each boss becomes progressively harder, based on how you killed the last boss (i.e. more armor where you shoot more and more of the weapons that killed you before).

Another lawsuit blooper

This one seems to step all over the US constitution.

For life outside the (techie) bubble

Interesting article, especially if you know people like these. Techies, cringe in disgust.

Seriously, though, sometimes it's nice to remember that the world looks nothing like the Blogosphere: there are a ton of people who don't drool over the latest graphics cards and are not interested in whether you think Ruby is better than Java.

Nintendo, at least, seems to understand that.

Yet another example of people trying to use law to stop progress

Brought to you by Bridgewater Telephone in Minnesota.

Sigh. Does it ever feel like some lawyers act like corrupt communist leaders that censor and ban everything they don't like? Except that they are not leaders, but pawns.

A change of heart on cell phone radiation

I blogged about this issue before and I'm changing my mind about how worried I should be.

Pittburgh Cancer Center released an advisory to limit the usage of cell phones "to be on the safe side". As it turns out, there's still no conclusive evidence of links between long term cell-phone usage and cancer.

At least from this article, it feels Dr. Herberman (who released the advisory) is basing his conclusions on biased, not-necessarily-peer-reviewed research. Look, doc, I appreciate your concerns, but going around spreading fear, rather than information, is usually not an awesome way of doing things.

Google Knol is out

With a ton of medical content, apparently.

Magic and Psychology

I love magic, I had a site dedicated to teaching card sleights and tricks when I was in high school. Studying this art teaches a lot about how people think and connect ideas. The down side is that you end up being able to figure out how most tricks were done, but watching people's reactions is fun in its own way too.

First impression of Git

Maybe there's a better around this, but why in the world is there even a way to check out a repo that requires me to write the username and password in plain text?

Exploring Fonts

Interesting.

Slimmed down MySQL

Seems InnoDB is the big thing here. I'm wondering how it compares to SQLLite and if/how it can be made to work under Windows.

FBI

Funny... if you're not a concerned american.

Blogging failing?

This is a really nice piece of metablogging. I suppose we really just need to be honest and ask ourselves: for whose sake are we blogging, our own's or or our readers'?

Granted, I know I don't have a whole lot of readers, bite me.

Oldest Bible going online

Cool. Now I need to learn some greek.

A quote from John Timmer

Enterprises should think carefully before adopting open source solutions due to persistent security issues, according to a report by the security firm Fortify. The report arose from Fortify's efforts in the Java Open Review Project, in which it subjected open source Java projects to a full security audit. Fortify's concerns arise not so much from the bugs it identified as from the fact that it was difficult to identify anyone responsible for fixing them; many persisted for several iterations of the software.

via

Amazon S3 downtime

You may have heard that Amazon S3 was down for a fairly long time on Sunday (not sure how long, I hear between 3 and 8 hours).

It raises an interesting point: considering what 99% uptime actually means in terms of hours per month, should developers think about redundancy? And what is the best way to go about it? What if you have a partial lock-in by using Google app engine or Jaxer?

My guess is that the open source community will eventually catch up to offering PHP mashups that are similar to popular "cloud" APIs, and that numerous web hosting companies will start adding these mashups as features to remain competitive. It's happened with Fantastico, even Rails is now available in a number of hosts that didn't offer it a year or two ago.

As far as S3 goes, I'm not too familiar with the options. Perhaps one could consider Edgecast? Does anyone know of other providers?

AOP is popular now

A completely useless piece of trivia that just occurred to me: I think unobtrusive javascript is currently the most widespread and successful use-case of Aspect Oriented Programming.

Yes, I hear that HTML and CSS are not "real" programming languages, but hey they can make computers draw graphic user interfaces just like Swing, GTK or whatever is your favorite GUI API, so they must be programming languages, even if non-turing-complete ones.

If we take JQuery for example, we can easily correlate point-cuts to the "$()" function and advices to methods like "each()". Oh oh, there's also JQuery.fn which is powerful enough to change the behaviour of pretty much your entire environment. If that ain't the power of AOP at work, I don't know what it is :)

The latest on DOM vs innerHTML

Looks like DOM Fragments will be the way to go from now on.

Designing maintainable view code

This is something I've been meaning to talk about for a while but never got around to. As it turns out, there are a few gems scattered around the world of web development that I think can help designing view code in MVC frameworks that is not cryptic to look at.

De facto "tag soup" view code is primarily composed of three distinct types of markup:

• HTML markup: the tags that describe whether something is a title or a table cell
• variables:: the stuff that we populate on the controllers and that often look like a variation of <%=MyVariable%>
• actual code: if statements, for loops and formatting helper functions

So what makes tag soup messy?

The server-side angled brackets peppered everywhere can make things really difficult to read, because there's no good way to correlate code indentation with where tokens begin and end. You either end up with long lines with a ton of brackets:

<a href="<%=url%>"><%=text%></a>

Or you indent everything making opening html tags span multiple lines (and let's not get into what the output code will look like).

<a
  href="<%=url%>"
>
  <%=text%>
</a>

Language designers have seen this problem before: HEREDOC and WYSIWYG string notations are prime examples of how to deal with substrings that contain a different realm of logic than the rest of the source code. So let's do what they do: replace a common token with a not so common one.

We could turn this:

<a href="<%=url%>"><%=text%></a>

into:

<a href="{url}">{text}</a>

Much easier to read, no?

But there's a problem: it makes inline javascript impossible to parse unambiguously. Now the parser needs to know that "function() {a}" is server-side generated code and "function() {b}" is actual client-side javascript. This is a problem because we don't have any escaping rules. And the matter of fact is, people don't want escaping rules here. Who in their right mind wants to write "function() \{a\}"?

One way to deal with this dilemma that I saw in the D language and that I found incredibly clever is to use the grave accent symbol (`). It's not used by any popular web language, and it never appears as a standalone symbol in content. We can rewrite our code to look like this:

<a href="`url`">`text`</a>

Still clean and much less prone to ambiguity problems. We should still make the parsing engine also check for an escaping token, just in case you happen to be blogging about D (hey I'm doing it right now!).

But but...

Yeah yeah, I already hear some people cringing at this. It looks "weird". Whatever.

We're designing our view code, so if you don't like the traditional symbol-parsing-oriented approach, we can take the other route and go with conventions. Like so:

<a href="SS_URL">SS_TEXT</a>

If we start from the assumption that "SS_" is a prefix that can only appear before server-side variables, then the chances of colliding with javascript and content is minimal. You'll still need a mechanism for escaping, though. Never forget that you could be blogging about "SS_" conventions.

We could again define an escaping pattern, or you could take a risk and go lispy, i.e. have undefined symbols return the name of the symbols themselves. Basically:

//content
SS_MYVAR does <a href="SS_URL">SS_TEXT</a>
//pseudocode
if (SS_MYVAR == undefined) return "SS_MYVAR";

Of course, you could run into trouble later if you're going with the last approach, so make sure you understand your requirements before bashing the ` symbol too much.

What about code?

So we have a few ideas on how to make variable declarations easier to read, but what about code? It doesn't look incredibly clean when mangled with HTML in the view and it certainly doesn't go in the controller layer.

There are a few ideas that I think are interesting to explore:

XSLT or any home-brewed variation of it: XSLT is supported by most popular languages natively. For custom languages, assuming your framework can parse HTML, parsing a <foreach> tag or attribute and building your DOM programatically from these rules should not be hard. As a matter of fact, the so called "tag soup" does just that, except that it doesn't always respect the DOM rules (e.g. <<%=0 < 1 ? 'br' : 'hr'%> /> is not something you'll want to feed into an (X)HTML parser). The problem with leaving ifs and fors in the view is that some types of layouts create a lot of clutter: for example, when you need to add a class name to one in every 3 of a list, the simplest solutions usually involve either putting some of the view logic in the controller or peppering the view with counter variables and increment calls.

Unobtrusive code: if you do javascript, you must have heard of this - basically code is separated from the markup and functionality is attached via query languages, much like how CSS is applied to HTML. CSS selectors and Xpath are popular DSLs used to accomplish this. The beauty of doing things this way is that now your view is language agnostic (at least as far as if statements and for loops go) and you're free to use expressive language features on your DOM manipulation layer - if you have these features and can afford to use them. The down side is that now you have an extra step to think about: you need to declare variables in the controller, then reference them in the DOM manipulation code, then define conventions so that the manipulation layer knows what data goes in which tag in the view.

One can go a step further and eliminate the markup altogether. You could now abstract away the gory entrails of HTML (I believe that's what Objective-J is aiming to do, correct me if I'm wrong). The trade-off with that approach is that you risk running into leaky abstractions: you could get burnt by whitespace-related issues like HTML compression with white-space:pre in the CSS, IE bugs due to the CSS "display" rule or whatever.

Cook up your own language: this is an interesting choice. Perhaps the most famous example of this approach is HAML. DSLs can make code incredibly concise and expressive, but have arguably the steepest learning curve of the three and are not necessarily readable, if, for example, an intern needs to go in and translate an error message in a form. Also, again, abstraction brings about risks, so weigh them carefully.

You're stupid, my way is better

We've all heard that line when bringing up new ideas.

Designing stuff is hard, especially when other people actually have to use it. It doesn't make a whole lot of sense to even try anything here if you're in team of stuck-up zealots, and by no means are these suggestions supposed to be exhaustive.

Views are a specific domain, and view code is a domain specific language. Languages are tools and developers are their users.

Users are niches to be targeted, and at the same time, they have disparate opinions that you need to listen to. That is the tao of software development :)

update: fixing some typos

Lolcode

LOL THEY HAZ A WEBISTE KTHXBYE.

Color code firebug

With rainbow.

Don't instantiate this

Curious article about utility class best practices. I don't know about you guys, but I have a tendency to think that languages are not designed to provide safety against "stupid" programming: that's what things like code planning and reviews are for.

"How do you know all this stuff?"

Disclaimer: I'm not here to toot my own horn, my intention is to make this post an introspective analysis.

A couple of days ago a coworker came to me asking me for some advice on a javascript related problem he was having. He said he "had been beating his head against the keyboard for the whole afternoon" on a issue where calling Element.scrollIntoView() on a <div> with overflow:scroll caused the entire document to scroll as well as the intended div, causing the whole page to "jump" awkwardly.

After listening to him describing the problem, I almost instinctively suggested to save document.body.scrollTop, call the function and then reassign the saved value back to document.body.scrollTop. I noted that there is also the little quirk of having to sniff between document.body and document.documentElement, and once that was ironed out, the code worked beautifully.

I've had this same developer asking me other fairly hairy questions before, and somehow I actually knew how to solve his problems, often by just looking at the page. This last time, he just expressed how impressed he was with how promptly I could come up with working solutions to problems and asked me the question: "how do you know all of this stuff?"

Indeed, where the hell did I learn about all of that stuff?

I wished I could have given a short insightful answer that would genuinely help him improve his skills, but I couldn't. I ended up just saying that I read a lot, all the time, from a lot of different sources. But something about that question made me think: I can't possibly know how fix incredibly strange and unintuitive bugs just from reading random articles (most of which aren't even about bugs), can I?

On one hand, yes, a large class of problems can indeed be fixed quickly, if one takes 2 seconds to do a google search for them. But on the other hand, there are bugs that are extremely application-specific, for which a google search would do no good.

Once, I came accross an incomprehensible bug (an element would redraw strangely after an Ajax call), and the solution I came up with was equally quirky, involving assigning a DOM element property to itself (i.e. element.innerHTML = element.innerHTML). What drove me to think "well innerHTML is ultimately handled as a setter, so there must be an internal redraw call within the browser native code, and maybe I can force it the underlying function to kick in correctly by calling it this way."? I don't really know.

But I think that the ability to think of completely non-intuitive ideas that can ultimately serve a purpose is something that a lot of people possess. Good quality assurance professionals are constantly thinking about new "what ifs", and the whole infosec research industry revolves around the ability to look at what everyone looks at and see what no one has seen before.

Bruce Schneier often speaks of this so called "hacker mindset", and according to him, it's supposedly a hard skill to develop. I don't have a degree in psychology or pedagogy, so I wouldn't really know if that's really the case, but I do wish sometimes that the abiliy to think critically was easily teachable, because I think it helps in many aspects of life, not just programming.

Digressing a bit

Anyways, at least as far as front end web development goes, I think there are a few ideas that can help one become better at problem solving:

• Maintain codebases on an ongoing basis: fixing those nasty bugs oughta teach you something :)
• Read source code: javascript library authors have already gone through the trouble of testing for browser inconsistencies and bugs, and their code reflects that experience. Reading their code not only gives more insight into how the underlying DOM works but also reveal obscure gems in the libraries themselves.
• Programming is a hobby too: spend some time working on your own project. Try a new language. Contracts. Macros. Annotations. AOP. Static. Dynamic. Porting. Bindings. Plugins. There's a lot of cool stuff out there.
• Read about crazy mashups and unorthodox ideas: they often use little-known browser features that may be useful to you someday. Don't be shy to delve into the code.
• Listen to Confucius: he said "choose a job you love and you'll never work a day in your life". You can see bugs as challenges just waiting to be defeated, or you can dread them and curse them forever. Zen aside, I think it's very hard to get distracted or lose interest when there's something you're itching to dive head first. If fixing javascript bugs is not your thing, maybe you'll be happier working on back-end stuff with static typed languages. Know your enemy and know thyself. (ok I'm done with chinese quotes)
• Sleep: I kid you not. Letting your head rest helps your brain re-organize ideas and create new correlations between concepts.

Damn, that's a lot of work

Unfortunately, I don't have a simpler formula, but hopefully this is helpful or inspiring to someone.

Polar bears to the south pole

What a dumb idea. They might as well feed the polar bears with the money they plan on wasting for this.

Paretto, people. If it's that much of a lost cause, let it go and focus where matters.

CSS on GTK+

Interesting. I wonder if it can compile the stylesheet into a binary format.

Lisponomiwhat?

For those of you wondering what the guy in the daily wtf cartoon said today, that evaluates to (TI NY UR L. CO M/ MF D2 8 P T2).

That second cartoon is a lot more obvious and evaluates to (1 2 3 5 8 13 21 34 55 89), i.e. the first 10 numbers in the fibonacci sequence.

Facebook is ebil, I tell you!

Well, not really. Just wanna link to two articles relating to Facebook that I saw today.

Thoughts on the authority vs people debate

A few people were discussing a post talking about monkeypatching over at Coding Horror. The article touched on the aspect of how much things should be dictated by the so called experts and how much power the masses should have.

I see two different cultures at clash here: the open-source-minded one, where experimenting and randomly writing code that does cool things is good, and the corporate goal-oriented one, where experimenting and randomly writing code that does cool things will likely blow up the budget of the project.

I think both sides have perfectly valid arguments: on a higher level, you want innovation, and giving all developers free reign over your language helps them quickly express what they want the program to do, and just like in the infinite-monkeys-on-infinite-typewriters experiment, something good is bound to come out. But when you consider monetization, especially as projects require more people, you need to take into consideration that doing things unusually will almost always cause a lot of (not-necessarily-brilliant) people to waste their time trying to figure out what was done, when it comes to maintainance, testing, bug fixing, whatever other cycle.

So where is the middle point of all this? I suppose it's talking to your team.

Penny wise, dollar fool?

I don't know about you guys, but I abhor cars.

Defenders favicon

Sweet, but not for the myopic.

San Francisco officials locked out by disgruntled employee

I wonder what Schneier thinks of this.

Something to ponder: what's your face worth

This came to me while I was writing a website proposal, in light that I meet a ton of people that seem to think that a custom-made website / web app will somehow cost in the range of the hundreds:

If your ass is worth $500, how much is your face worth?

What I mean is: a decent office chair goes for around $500. A website is basically your face to the world.

You wouldn't want to have your 2-year old toddler to shave your face for you, so why would anyone want to save money on their website by hiring a web development newbie who charges $200 for a complex site, claiming to provide a Web 2.0 experience and a CMS and SEO an all the rest of the buzzwords?

Can people really be so gullible that they somehow believe they found the website development deal of the century? Often, from the very first consultation from a friend of the aunt of the girlfriend that just happens to know a bit about programming? Come on, people!

Back from vacations

In which I did nothing but sleep, play games and work on my hobby compiler project. Fun times.

<menu>

I just noticed that the <menu> tag got "undeprecated" in HTML5. I never understood why it was deprecated in the first place.

* is evil

Did you ever use * {...} to create some sort of CSS reset? I have, and let me tell you it's bad.

Font styles

The first problem you'll probably come across is when you use font styles. This rule will override all sorts of desirable cascading styles:

* {font-size:12px;}
.menu a {font-size:10px;}

This seemingly inoffensive snippet will break as soon as you need to emphasize text with a em or strong tag. Need a span inside the link? Tough luck, it'll break too.

Spacing

The following looks convenient:

* {margin:0;padding:0}

but it's pretty easy to see that you'll need to add extra styling to deal with ul, ol and form elements.

Other side effects

There are many other things that can break out of what you would normally expect the default CSS to do: adding a "reset" background color would break your ability to cascade transparency down in inline elements. Setting borders to zero will make your forms look strange. etc.

I've committed the sin, now what?

There's no sure-proof way to remove * references while having a guarantee that yoru site won't look broken, but I find that changing it to the code below solves 99% of the headaches.

div,h1,h2,h3,h4,h5,h6,p,li {...}

3-strikes-out failed? Let's try bigger!

They're apparently pushing for an amendment that could affect the entirety of Europe.

PDF, the non-religion

Remember all the whining when OOXML became a standard? Well, Adobe's PDF is becoming one too. Moral of the story: stop bandwagoning on the Microsoft hating train :)

Bug detection - a real life case study

Hallvord Steen from Opera talks about why browser sniffing is bad, and suggests a much more robust way to write future-proof cross-browser code. Well worth reading.

Someone explain me how business works

So everyone and their dogs are talking about how Google will supposedly going to have to give Viacom some 12 TB worth of users' private data.

I'm not entirely convinced that this whole 1 billion dollar lawsuit is going to work out in favor of Viacom. Wouldn't it be better if the two just made an agreement to put Viacom ads on the so called copyright-infringing videos? I mean, seriously, if you don't want people to see your content, don't publish it <_<;

Sockets in HTML5

This is big: HTML 5 will have a sockets mechanism for all our Comet needs.

Pluribo - Amazon review summarizer

This is a cool plugin.

I think the idea of summarizing user-generated content has a ton of potential. Imagine a service that allows you to search for any topic under the sun and that returns a summary of the current discussions in the cloud, as well as links to points of high relevance and/or authority. Can I say Wikipedia meets Google meets the blogosphere?

XML or not XML?

If you haven't already, go read Jeff Atwood complaining about XML and Dare Obasanjo defending it.

Did anyone notice that there are a whole lot of DSLs being mentioned? JSON, CSS, XPath, XQuery...

I suppose in the end Paul Graham was right on the ball when he said a choice of language will depend on the amount of code that will be needed to complete the task at hand.

On the one hand, having a ton of tools can make things easier for you, but on the other, is the code really terse if you're developing all of that XML processing code in Java? Or does a mix of Yaml and Ruby produce results faster and more concisely?

A start-up might feel that Yaml is terser, but what if integrating with a gigantic Java code-base is a requirement of the project?

Do you ever get tired of reading and reading arguments and counter-arguments only to come to the same old conclusion that your choice of tools depend on your requirements? :)

Sockets in the browser

I like when people build stuff backwards: implementing an old API on top of newer technology, and this seems to be just that.