Ori Peleg's Blog

Firebug 1.2b1 is out!

2008-05-22T10:20:00.001-07:00

http://www.getfirebug.com/blog/2008/05/22/firebug-12b1

Yay!

Regular Expressions Are Fun

2008-04-30T11:37:00.000-07:00

Miriam and I were debugging a regular expression, and it was an educational experience.

The platform is Java, and our problem is:

Input is a long string
We want to replace occurrences of "PRE[SEARCHSTRING]POST" with "PREreplacedPOST"
"PRE" and "POST" are patterns
"[SEARCHSTRING]" is a string that contains a lot of special regex character like "[", "\", and "$".

We found java.util.regex.Pattern.quote to help with the special characters in "[SEARCHSTRING]":

String quotedPattern = Pattern.quote(searchString);

Now, how do we match "PRE" and "POST" without losing them? They disappear if we try:
return input.replace("PRE" + quotedPattern + "POST", "replaced");

After some fiddling we came up with:

return input.replaceAll("(PRE)" + quotedPattern + "(POST)", "$1replaced$2");

This matches "PRE" and "POST", but references the captured subgroups with "$1" and "$2" so they don't disappear.

But we then tried the following instead:

return input.replaceAll("(?<=PRE)" + quotedPattern + "(?=POST)", "replaced");

"(?=POST)" is a zero-width positive lookahead, which is an incredibly cool technical name. It matches a pattern that does appear ahead ("positive lookahead") but this pattern won't be regarded when checking what parts of the string matched the regular expression ("zero-width"). "(?<=PRE)" is, similarly, a zero-width positive lookbehind. There are also negative lookaheads and lookbehinds that make sure the pattern doesn't appear.

Is there a more elegant way to do this?

Sorting time spans with jQuery Tablesorter

2008-04-23T14:47:00.000-07:00

I've been working a little with Christian Bach's nifty Tablesorter plugin for jQuery, and I'd like to share some cool stuff I've learned.

I wanted to sort a column of time spans formatted like this: "2 days 15:11:06". I wrote a custom parser and ended up with this:

$.tablesorter.addParser({
    id: 'timespan',
    is: function(s) { return false; }, // don't auto detect
    format: function(s) { return s.replace(/\D/g,""); },
    type: 'numeric'
});

And the usage:

$("#mytable").tablesorter({
    headers : {
        2 : 'timespan' // the 3rd column is a time span
    }
});

All it's doing is removing all non-digits and asking for a numeric comparison. It should even work equally well for "0 days 02:30:00" and for "02:30:00", since leading zeros don't affect the sorting :-)

Dead-simple portable JavaScript logger

2008-04-14T10:56:00.000-07:00

window.console = {
  log : function (message) {
    if ($('#logpane').length == 0)
      $('body').append("<ul id='logpane'></ul>");
    $("#logpane").append($("<li></li>").text(message));
  }
};

This requires jQuery, and should work on any browser and on most pages.

It intentionally uses the name 'console.log', so it overrides logging to Firebug's logger.

To use it:

<script type="text/javascript">
console.log("foo");
console.log("bar");
<script>

It's not very pretty - just appends a list of log messages at the bottom:

Firefox + View Source Goodness

2008-04-09T13:01:00.000-07:00

This is incredibly cool!

In about:config:

Set 'view_source.editor.external' to true

Set 'view_source.editor.path' to ... whatever! In my case, '...\gvim.exe'

Thanks Brian!

Huh?

2008-03-12T01:11:00.000-07:00

This book title cracked me up :-)

"My Feet Hurt"

2008-03-09T13:36:00.000-07:00

If you want to get physically active, there's only one thing really stopping you:

(Courtesy of Lift Like A Girl)

Who's afraid of dynamic typing?

2008-02-13T14:02:00.000-08:00

If you're afraid of dynamic typing, stop. Take some time to learn a good dynamically-typed language, then take some more time to learn how some people build big production systems with it, and how they manage to do it with less effort and increased safety and reliability vs. equivalent implementations in popular statically-typed languages. Regardless of your conclusions, I can guarantee you'll increase your breadth as a developer and that your new insights will improve your effectiveness in any programming language.

So why are people afraid of dynamic typing? Maybe it's the way most people approach dynamic languages:

skim through some tutorials
write some toy code
reach a final verdict about their applicability to large-scale development

These verdicts are usually based on gut instinct and second-hand stories rather than on actual experience developing real systems with guidance on proper ways to use the language.

I'll finish with a story: One time a good C++ developer got excited about a dynamic language. He used it extensively for scripting and was familiar with all of its features, and he convinced the necessary parties to develop a real upcoming system in this language. But when writing the system he threw every one of his development practices out the window and half-assed the whole thing, writing incredible spaghetti code, not testing, and cramming in as many language features as he could. The project was not a complete failure, but the "obvious" conclusion was that this language wasn't appropriate for these tasks, whereas my conclusions are:

Be responsible. You may also use a dynamic language for scripting, but when you're building a real system you're not scripting.
Don't rely on static typing - it isn't there to rely on. You have to unit-test.
Use your language's idioms and good shortcuts, avoid the evil ones. Seek experienced guidance on this issue.
Don't get in over your head - before applying a language feature in production, become familiar with it. Don't worry, it'll wait for you!

Some articles I love on the topic:

Python Is Not Java, by Phillip J. Eby. A great quote from it is:

"... if you've been using Java for a while and are new to Python, do not trust your instincts. Your instincts are tuned to Java, not Python."
Java Is Not Python Either..., also by PJE
Strong Typing vs. Strong Testing, by Bruce Eckel

Boo and TiddlyWiki

2008-02-11T16:47:00.000-08:00

I'm now learning Boo (as part of learning Brail). One of the most helpful Boo sites I've found is The Book of Boo - and it's a TiddlyWiki, no less!

Inversion of Control and Dependency Injection for dummies

2008-02-09T17:50:00.000-08:00

I'm a dummy.

I've been hearing about IoC and DI for several years, but every time I tried to figure out what they were the explanation was either too complicated or so trivial it didn't make sense (i.e. what is it good for?)

Now I understand. Thanks, Simone! Even more accessible than Martin Fowler's explanation, and that's saying a lot!

Here's the way I get it:

I. IoC happens when you use code that calls your code, such as whenever you use any framework. That means it's just a buzzword to fling at friends, but a really cool one. (Why do people insist on giving cool names to simple techniques? Oh well, Eddie Bravo does it too.)

II. You often program against interfaces instead of specific implementations.

interface Foo { ... }
interface Bar { ... }
class Alpha : implements Foo { ... }
class Beta : implements Bar { ... }
class Charlie {
  Charlie(Foo foo, Bar bar) { ... }
}

Charlie c = new Charlie(new Alpha(), new Beta())

DI happens when instead of choosing the concrete classes yourself you let a repository, called a "container", handle it for you.

// register implementations for Foo and Bar (could
// be done in a config file)
container.register(Foo, Alpha)
container.register(Bar, Beta)

// Create a Charlie - the container detects it
// needs Foo and Bar implementers for the constructor
// and chooses Alpha and Beta
Charlie c = container.createInstance()

When I needed to interchange different implementations I used to write it by hand, but no more - these containers are much better! Since they're general and easy to use, I have a feeling I'll be using them in cases I didn't bother with before.

Distributed version control

2008-02-09T13:44:00.001-08:00

(I'm still trying to figure out DVCS)

I love version control. I started with CVS and moved to Subversion. I loved having Pragmatic Version Control using Subversion when I was making the move. If you write software and you don't use version control, c'mon!

I don't know my way around distributed version control systems, though.

I became interested in distributed version control a few years ago when a good friend recommended darcs. I've played with it and other systems including Mercurial and Bazaar, and I've read a lot of blog posts and opinion pieces, but I've never actually wrapped my head around how to effectively use them in the contexts I'm used to. Maybe I'm just stuck in the wrong contexts.

If anyone's reading this and can help me, I'm all ears.

Linus's great tech talk on git made me feel I understand distributed version control a little better, but I still don't see the relevance. To make it clear, I'm not claiming my ignorance is a virtue. I guess I'm just slow on this.

I have been able to discern the following benefits:

No required master repository, all branches are equal
Trivial branching, easy merging (including cherry-picking)
Can work offline
Performance for local work isn't affected by the network

Am I missing anything important?

What I find interesting is that most of these issues are irrelevant for the corporate environments I'm used to, where everybody's working on a LAN, committing to a central trunk is fine (constant integration, and good unit tests prevent breakage), and the branching model is intentionally simple and reduces merging because in many cases merging will be hard regardless of the tools (think heavy refactoring).

More good links:

Distributed version control and git

2007-12-08T11:43:00.000-08:00

There's a great tech talk by Linus Torvalds on git and distributed version control in general. I'm trying to wrap my head around the topic, and this talk helped me quite a bit.

Cheap Turpentine

2007-12-01T15:41:00.000-08:00

"When art critics get together they talk about Form and Structure and Meaning. When artists get together they talk about where you can buy cheap turpentine."

- Pablo Picasso, quoted in "Code Complete" by Steve McConnell

This quote nailed it for me. I still love philosophizing about software and technology, but I know it isn't real so I don't take it too seriously.