Ryan Tomayko

Pull Requests 2.0 —

I’ve been working with kneath on this pretty much since the day we started at GitHub almost a year ago. Not full time but whenever we could steal time away from other projects. We’re both stoked to have finally shipped it.

I wrapped the original blog post draft with this sentence:

Pull requests elevate the collaborative aspects of development to creative works in their own right. We can’t wait to see where you take them!

We ended up striking it — a little too floaty for a product/feature announcement. I believe every word of it, though.

Your Code Sucks —

Story of my career; superbly told. I still hate on code, but now I take it as a sign that there’s probably something interesting I don’t understand.

3 shell scripts: Kill weasel words, avoid the passive, eliminate duplicates —

I can’t think of anything I like better than the intersection of writing and shell hacking.

Beej's Guide to Unix IPC —

A gentle introduction to the world of UNIX IPC. Covers fork, signals, pipes, FIFOs, file locking, POSIX message queues, semaphores, shared memory segments, memory mapped files, UNIX sockets. Not a ton of depth, but that’s okay – you can read all of it in about 15 minutes and have a good feel for the pros and cons of all the different types of IPC.

Check out Beej’s Guide to Network Programming and Beej’s Quick Guide to GDB too.

It’s Faster Because It’s C —

That argument debunked for most real world applications.

I liked the way different types of boundedness were presented:

• I/O-bound. Completing a unit of work earlier just means waiting longer for the next block/message.
• Memory-bound. Completing a unit of work earlier just means more time spent thrashing the virtual-memory system.
• Synchronization-bound (i.e. non-parallel). Completing a unit of work earlier just means waiting longer for another thread to release a lock or signal an event – and for the subsequent context switch.
• Algorithm-bound. There’s plenty of other work to do, and the program can get to it immediately, but it’s wasted work because a better algorithm would have avoided it altogether.

As much as I agree with the thrust of the article, C programs really are faster in real life, but I think it’s because people who program in C are more likely to be familiar with common performance problems and tradeoffs. It’s hard not to be at that level.

Building Filesystems the Way You Build Web Apps —

Interesting concept. Layer the routing guts found in modern web frameworks over Linux’s FUSE userland filesystem stuff and you get a nice model for developing custom filesystems.

The small example (~30 LOC) shows how to build a simple GitHub filesystem, which gives you this:

opus:~ broder$ ./githubfs /mnt/githubfs
opus:~ broder$ ls /mnt/githubfs
opus:~ broder$ ls /mnt/githubfs/ebroder
anygit      githubfs     pyhesiodfs  python-simplestar
auto-aklog  ibtsocs  python-github2  python-zephyr
bluechips   libhesiod    python-hesiod
debmarshal  ponyexpress  python-moira
debothena   pyafs    python-routefs
opus:~ broder$ ls /mnt/githubfs
ebroder

Pretty awesome.

pocco —

Python version of Docco, the quick-and-dirty, hundred-line-long, literate-programming-style documentation generator:

8888888b.
888   Y88b
888    888
888   d88P  .d88b.    .d8888b  .d8888b  .d88b.
8888888P"  d88""88b  d88P"    d88P"    d88""88b
888        888  888  888      888      888  888
888        Y88..88P  Y88b.    Y88b.    Y88..88P
888         "Y88P"    "Y8888P  "Y8888P  "Y88P"

All together, we have Docco, Rocco, shocco, and now Pocco. Jeremy observes, “It’s a whole little adorable family of midget programs now…”

bcat -- pipe to browser utility —

I’m pleased to announce the first public release of a small project I’ve been working on: bcat is a command line utility that streams text or HTML input to a web browser. Input is unbuffered and displayed progressively as it’s read from standard input, so bcat works great with programs that generate output over longish periods of time like build tools, tail(1), etc. It’s also useful for previewing HTML output when working on Markdown, Textile, AsciiDoc, Ronn, DocBook, etc. source files.

The plan is to bring as many of TextMate’s excellent HTML output capabilities as is feasible to the shell and to editors like vim or Emacs.

Always ship trunk —

Paul Hammond’s recent Velocity talk on managing different code-paths for beta features, A/B testing, staff-only features, etc. in web apps. I’ve been interested in tools and techniques for doing percentage-based feature deploys for a long time. This is the first time I’ve seen someone talk about it in any detail.

HTTP Status Code Drinking Game —

Use this to get kicked out of the party.

unix-jun72 —

I love stuff like this:

The unix-jun72 project has scanned in a printout of 1st Edition UNIX from June 1972, and restored it to an incomplete but running system. Userland binaries and a C compiler have been recovered from other surviving DECtapes.

There’s also a mirror on GitHub.

Heroku Ships Experimental Node.js Support —

Boom. It looks like long running connections aren’t completely baked yet but this is really promising.

Introducing Jake: A Build Tool for JavaScript —

Looks great. Really glad to see file tasks, too. Code is here. I’m dying for a real JavaScript project so I can start playing with all the great looking stuff these guys are putting out.

Higher Order Mustache —

Mustache is my favorite template language by far. By far. This is a great example of why. It solves every problem simply and elegantly, or it doesn’t solve it all. Here’s the syntax in its entirety. In his post, Chris talks about how adding very simple lambda support solved the cache block problem. It’s just as suitable as solution for embedding Markdown in templates.

A Note About Git Commit Messages —

Great advice for commit message formatting. It’s absolutely vital that the first line not exceed 65 characters (50 is suggested and good practice). Browsing around github.com, I see a ton of commits with an entire paragraph on the first line and it drives me crazy. This destroys git log, tig, git format-patch, and a lot of other commands that use the first line as a short message — even git pull shows it when the HEAD moves.

Staying the hell out of insert mode —

Ctrl-C goes to normal mode when in insert mode. Amazing.

Named Gem Environments and Bundler —

Yehuda lays out some of the history and rationale behind Rubygems’s multi-package-version design and also takes a look at how a few recent tools (Bundler, Rip, rvm, etc.) are using different approaches to develop concepts around multiple “environments”.

I’ve never been a fan of Rubygems multi-versioned, directory-per-package approach to organizing packages. There’s a few different reasons, but mostly it forces a lot of unnecessary complexity into runtime that could (I think) be handled more simply at install time. I do like the convenience of installing a bunch of packages into a single Rubygems environment without having to think about it, but those benefits are outweighed by the subtle differences in runtime behavior, some of which can be extremely annoying (e.g., “already activated” errors). I’d rather be aware of and be forced to deal with those issues at install time. It’s great to see so much experimentation on new tools and alternative approaches.

Sweet Justice —

New JavaScript based text justification library looks promising. The default HTML/CSS text justification built into every browser has always sucked, due mostly to lack of word hyphenation.

One of the places I’d really like to have good justification is in Ronn’s HTML based man pages. It uses text-align: justify currently, but I’ve been considering making it non-justified because it’s so horribly bad. Compare it to the proper justified / hyphenated text generated by groff when viewing manpages in a terminal. It’s night and day.

Never trust a programmer who says he knows C++ —

Classic.

man.cx —

This is probably the nicest manpage site I’ve come across:

I haven’t heard of it. They imported 98,660 manpages from all available Debian packages plus some from other sources. The type is clean. URLs are short and sweet. Manual sections are presented in a nice TOC on the left. They have some other novel features like comments on each manpage.

I planned to do something very similar. I even registered mancutter.org. A great number of manpages are distributed under a liberal license. I wanted to throw up a nice and simple site and then ship a tool anyone could run to bomb roff up to the server for all manpages on a machine. You should be able to gather all Linux and BSD manpages fairly quickly with such a system. Or, you could push up a specific set of manpages so project maintainers could publish directly to the site. I might still but man.cx is a huge chunk of what I was looking for.

man what —

Chris Wanstrath makes the case for UNIX man pages and tours through a bunch of tools for creating, finding, and reading them.

docco —

Okay, this is the project used to generate the previously linked CoffeeScript documentation. It’s a “quick-and-dirty, hundred-line-long, literate-programming-style documentation generator.” It pulls out comments, applies markdown, and then runs the code through pygments for syntax highlighting.

Beautiful.

Annotated CoffeeScript Grammar —

I don’t believe I’ve ever seen code annotated like this before:

It’s perfect.

The HTML is <table> based. Each segment is an anchored <tr> with the left cell holding the annotations and the right cell holding the code. I’d probably flip them around but the overall effect is wonderful.

alandipert's ncsa-mosaic —

The sources for NCSA Mosaic v2.7 — one the first graphical web browsers (1993) and certainly the one that led to the World Wide Web as we know it — can now be found on GitHub.

You can even run it on a modern Linux. Here’s what the GitHub homepage looks like:

The team that built NCSA Mosaic (Marc Andreessen et al) would go on to create Mosaic Communications Corp., which eventually became Netscape Communications Corp., which open sourced the Mozilla browser, leading to Firefox.

I wonder if any of the original NCSA Mosaic code still exists in any form at mozilla.org.

The Mosaic Wikipedia entry has a thorough history.

gem-man(1) -- view a gem's man page —

Perfect. This was a huge piece missing from Ron and I had no clue how to address it. Chris’s gem extension adds a gem man command that brings up the man page for any gem and works with any gem that includes normal roff man pages.

Smack a Ho.st —

Tim Pope registered smackaho.st and pointed the wildcard at 127.0.0.1 so you don’t have to futz around in /etc/hosts every time you want another local hostname.

try visiting dontmakeme.smackaho.st:3000

Brilliant.

Introducing GitHub Compare View —

It’s a commit list (git log --online --reverse <start>..<end>), a rolled up diff + diffstat (git diff --stat <start>...<end>), and commit comments all on one page. Here it is in action showing all changes between the Sinatra 0.9.4 and 1.0.a releases:

Dogfood never tasted so good. We’ve been incrementally using and developing and using and developing this thing for a few months now. It’s become a core part of our code review process. I’m extremely happy with how it turned out.

CDN Catalog —

We should be doing more of this:

If you’re building a modern website then you’ll be needing some javascript libraries and css.

Rather than hosting these common libraries on your own server, you should Use a Content Delivery Network. Lucky for you Google, Microsoft and Yahoo host a range of popular javascript and css which you can directly link to for free. This saves your bandwidth and speeds up your website load time.

The great thing about the shared CDN approach is that the resources are cached once and reused across all sites, often without even making a validation request.

I’d seen the JavaScript libraries before but I’d never considered using this approach with CSS. The YUI CSS reset is a perfect example of where a shared CDN provides the most benefit. If every site that employed the basic CSS reset used this URL, it would effectively be baked into the browser with no overhead after the first request.

Node.js, redis, and resque —

Interesting use of node.js as a sort of HTTP reverse proxy. It uses redis based queues to communicate with backends instead of establishing a direct socket connection and doing HTTP:

This spike uses node to put messages into a (redis) queue. Ruby background workers read from the queue, process the requests, and respond on a different queue. When node receives the response from the background worker, it sends the response back to the waiting user.

I assume this adds a not insignificant amount of latency to each request but would also make possible a bunch of long-running connection features. For example, the response (or portions of the response) could be delivered from separate worker processes. This style of architecture, where the client connection isn’t tied to backend web process, looks promising. The nginx_http_push_module is another example that gives the same types of benefits.

Running Processes —

Dustin Sallings lays out a nice list of simple, non-pid-polling process supervision techniques available on various Unix and Linux environments. Great reference. I’m pretty sure the /etc/inittab respawn directive is one of the most underrated utilities in Linux server environments.

Twitter / OpenSource —

Big list of open source projects Twitter developers contribute to. I really like the way this page presents things. It would be really cool if every user on GitHub automatically had a page like this somewhere.

Hot swapping binaries —

The technique in a nutshell:

The basic idea of what’s going to happen is that we will create a pair of pipes and then fork(). The child process will hold the pipe that does the writing and the parent the one that does the reading. Now, the parent will exec. This is a bit odd. Normally when you fork, then exec, it’s the child process which does the exec. However, here we really want the new version of the program to have access to all of the old file descriptors. Luckily, execl preserves these. As an added benefit, the program gets the exact same process ID.

Boom. Nice.

Garbage Collection Slides from LA Ruby Conference —

Looks like Aman and Joe knocked one out of the park with this presentation on Ruby’s GC:

I wish RailsLab or PeepCode or somebody would team up with those guys and do a series of screencasts. You can learn a ton just by watching over their shoulder while they work.

My take on the GitHub process —

I’ve received a lot of positive feedback on this blog post length comment left on Rafe’s recent post about GitHub’s process, or lack thereof. In it, I try to address some of the common objections people have when they hear how things work inside GitHub.

Scott Chacon on The Geek Talk —

Working with Scott is such a huge honor. I don’t even have words to describe it, really. He’s a class act. You get a glimpse of it in this interview.

He even lets loose some GitHub secrets:

At GitHub we don’t have a project tracker or todo list – we just all work on whatever is most interesting to us. No standup meetings, burndown charts or points to assign. No chickens or pigs. It’s sort of the open source software style of business – everyone itches their own scratch. Inexplicably, it works really well and keeps everyone engaged, new features appearing quickly and bugs fixed rather fast. No managers, directors, PMs or departments – and it’s the most agile, focused and efficient team I’ve ever worked with. Maybe we should write a book about it.

Do whatever you want. Do it now. Don’t fuck around.

A Hidden Cost of Javascript —

Interesting set of results from a series of JavaScript parse and load benchmarks on Safari, Chrome, Firefox, and Opera presented with pretty graphs and tables. I’m convinced browser-side JavaScript profiling and optimization—including this kind of parse+load and GC profiling—is going to occupy more and more of my time in the future.

How to upgrade plugins to Rails 3.0 —

Using Rack::Cache as an example. Nice!

The fighting's been fun and all, but it's time to shut up and get along —

Benjamin Pollack — one of the guys that helped build Fog Creek’s Mercurial based source control system, Kiln — pleads for Git and Hg folks to stop bickering over stupid shit and team up to go after the massive number of Subversion/CVS holdouts.

I can confirm one of his points:

It’s easy, in the yin/yang of Hacker News and proggit, to forget that most developers are not even aware of what DVCSes are or what they do. Yeah. Sounds crazy, I know, but trust me on this.

This is true. My second day on the job at GitHub was spent at the Zend PHP conference. Maybe 10% of the people we talked to had any awareness of DVCS at all, and a big chunk of that 10% hadn’t used DVCS seriously on a project. This was six months ago.

For most popular programming language communities, I’d put the percentage of developers that really understand DVCS under 1%.

How do we kick our synchronous addiction? —

Eric Florenzano asks why modern web frameworks insist on a synchronous programming model and gives some answers with possible alternatives. The article is dead on, IMO, but I’m not sold on his conclusion:

We need to look at these alternative implementations like coroutines and lightweight processes, so that we can make asynchronous programming as easy as synchronous programming.

For Ruby, this is all about making Fiber robust and widely available. There was a time when I too thought this would solve all problems by hiding the underlying async model but retaining its benefits. That’s the dream. I don’t believe in it anymore. Having experimented with such an approach on a small team, I’m fairly confident that everybody working on an event-based/async program needs to understand the underlying model or blocking code will inevitably be introduced and destroy everything. And once everyone’s comfy with async, you’ll find that the sync façade is annoying and unhelpful. Embrace it.

Performance Retrospective in PEP 3146 -- Merging Unladen Swallow into CPython —

Shame:

Our initial goal for Unladen Swallow was a 5x performance improvement over CPython 2.6. We did not hit that, nor to put it bluntly, even come close. Why did the project not hit that goal, and can an LLVM-based JIT ever hit that goal?

Here’s the performance comparison itself. Most gains were under 1.5x and memory usage grew significantly in every benchmark. Startup time also suffered.

As mentioned in the Performance Retrospective, they had to divert a lot of energy from performance work to fixing LLVM bugs and axe grinding on debugging/profiling tools. I have my fingers crossed that they can pull off the 5x gains in the next round. Let’s hope so, I’d demand at least that much to justify this:

In order to use LLVM, Unladen Swallow has introduced C++ into the core CPython tree and build process.

Slipperyest of slopes.

A rant about PHP compilers in general and HipHop in particular —

Paul Bigger, author of the phc PHP compiler, explains why Facebook’s HipHop is interesting and why the translator/compiler technique might be a better design than a JIT or something more… elaborate. Good article all around, even if you don’t care about PHP.

There’s some salt in there too:

I’m also slightly annoyed that people all of a sudden care about PHP compilers. I worked on one for 4 years and I could not convince anyone to give a shit. But now that its got the Facebook logo on it, all of a sudden PHP compilers are the greatest thing ever. Bah.

Lesson in marketing. Merit is not conducive to mass appeal.

Sayre's Law —

More general version of Parkinson’s Law of Triviality (AKA “bike shedding”):

“In any dispute the intensity of feeling is inversely proportional to the value of the stakes at issue.”

Via this HN comment thread discussing the tendency of both Ruby and Python hackers tend to favor their chosen language with vehemence.

HipHop for PHP: Move Fast —

Wow, okay, so it translates PHP into C++ and then compiles it with gcc. That’s… interesting. Here’s what’s more interesting, if you ask me:

We are proud to say that at this point, we are serving over 90% of [Facebook’s] Web traffic using HipHop, all only six months after deployment.

That’s pretty damn fast, and super impressive if true. I can’t imagine the amount of infrastructure that would need touching for this kind of transition. You have to work with the backend devs and the sysadmins and pretty much everyone. That’s no small feat at a company the size of Facebook. Kudos.

Book Review: Coders at Work —

A quote from Brad Fitzpatrick:

I find that is the best way to start a conversation. If you get on a mailing list and you are like ‘hey I want to add feature X’ the maintainer is probably going to be like: ‘ Oh fuck, I am so busy, go away, I hate feature X’. But if you come to them and you are like ‘I want to add feature X. I was thinking something like the attached patch’ which is totally wrong but you say, ‘But I think its totally wrong. I am thinking the right way might be to do X’ which is some more complex way, generally they will be like ‘Holly crap, they tried and look, they totally did it the wrong way. Maybe that pains the maintainer. They are like ‘ Oh man, I can’t believe they went through all that effort to do it. Its so easy to do the right thing,’ and then they reply.

This is the secret to being productive when contributing to open source. It’s very rare that you should approach a mailing list without a patch of some kind.

Sinatra 1.0 FAQ —

We pushed out a Sinatra 1.0 pre-release. The FAQ includes some info on what the 1.0 release means and how to prepare for it.

HANDY ONE-LINERS FOR RUBY —

Nice list of Ruby one-liners when working at the shell. e.g., emulating nl(1):

# number each line of a file (left justified).
    $  ruby -ne 'printf("%-6s%s", $., $_)' < file.txt
# number each line of a file (right justified).
    $  ruby -ne 'printf("%6s%s", $., $_)' < file.txt
# number each line of a file, only print non-blank lines
    $  ruby -e 'while gets; end; puts $.' < file.txt

Unlike some other things, the -p and -e switches are something I’ve always been glad ruby adopted from perl.

In praise of git’s index —

Aristotle explains how he uses git’s index and how it makes git unique among VCSs. I’ve raved about git’s index before in The Thing About Git. It’s great.

How would you serve 100,000 simultaneous comet requests with Node? —

Simon Willison throws down a C100K problem for node.js. That’s a tough order for a single machine. To get even close, you’re going to need lots of system tuning way down below node.js.

WTF - Haml —

I love this so much:

… one way or another it seems I need something called EMACS.. WTF..!!!!! I dare you to install it and see how many WTFsss you will say…. it’s like some text editor that is so smart that you dont use the mouse dont even use the cursor keys..if you want to go back one character you hit control then B!!! Brilliant!!! two random keys instead of one with an arrow!!!! WWWTTTFFFF!! ok I might not need this crap…. lost a day learning to use the Rubik cube of text editors.

It’s easy to pfft and blow off this kind of … criticism, but if you can look past the make believe grammar and punctuation you really do get a sense for how hard it is for newbies to wrap their heads around even very basic set of tools needed to build things on the web. Maybe what we do is just hard and complex and there’s nothing we can do to make it simpler. I’m just always surprised when I get to peek through someone else’s eyes and see just how fucked up everything must seem.

Node.js For My Tiny Ruby Brain: Keeping Promises —

Rick documents his progress a week into node.js. Nice look at some of the basic concepts underlying the system, like async everywhere and promises.

Highcharts - Interactive JavaScript charts for your webpage —

Nice looking pure JS charting library:

I’ve been seeing more and more of these charting libs lately and they all look great.

/dev/fort —

A master plan:

Imagine a place of no distractions, no IM, no Twitter — in fact, no internet. Within, a group of a dozen or more developers, designers, thinkers and doers. And a lot of a food.

Now imagine that place is a fort.

They’re serious:

Rack 1.1 released —

Lots of needed fixes and some new features in this release, including new Config, ETag, Sendfile, and Logger middlewares, Carl and Yehuda’s rackup to Rack::Server conversion, multipart fixes, and a bunch of optimizations by Eric Wong.

Huge props to Josh Peek for putting his head down man'ing the patch queue on this one.

The Maximal Usage Doctrine for Open Source —

I like the way Yehuda first lays out his motivations and goals as an open source developer and then evaluates the MIT/BSD vs. GPL licenses based on those goals. That’s how you pick a license. No one can tell you why you write a given piece of free / open source software, so no one can really tell you how it should be licensed.

Like Yehuda, I tend to lean heavily toward MIT/BSD style licenses these days but I can imagine situations where the copyleft stipulations included in the GPL would be extremely important to me.

Things UNIX can do atomically —

Insanely useful when you’re trying to avoid thread and process synchronization primitives — mutexes, flock, etc. — in concurrent code, which should basically be always. Rack::Cache’s file stores use some of these techniques to allow multiple backends to work against the same filesystem without file locks or a separate central writing process.

Doing It Wrong —

Tim Bray on the state of Enterprise tech:

This is unacceptable. The Fortune 1,000 are bleeding money and missing huge opportunities to excel and compete. I’m not going to say that these are low-hanging fruit, because if it were easy to bridge this gap, it’d have been bridged. But the gap is so big, the rewards are so huge, that it’s time for some serious bridge-building investment. I don’t know what my future is right now, but this seems by far the most important thing for my profession to be working on.

That’s what led me to start (the now defunct) lesscode.org almost five years ago. Things actually seem to have come a long way since then, when the idea of using open source, dynamic languages, or web protocols would get you laughed out of the room. That’s not the case anymore.

I’ve given up the idea that advocacy can have an impact, though. Everyone has something to pitch The Enterprise. You get lost in the noise. Useful tech wins eventually.

Optimizing Optimizing HTML —

Oh neat. You can drop the type='text/javascript' from your <script> tags, type='text/css' from your <style> (and/or <link rel='stylesheet'>) tags and the browsers won’t care. Also, in 2010, <b> and <i> are cooler than <strong> and <em>, and trailing slashes on self closing tags are lame.

Personally, I like these little tricks for making HTML more human readable but I can’t believe people are actually doing stuff like this in an attempt to compress HTML to gain network/browser efficiencies. I dare someone to actually benchmark those optimizations. Cutting your sucky EULA page in half and trimming away all that shit in your header/sidebar would be much more productive (but still barely worthwhile).

Debian/Ruby Extras - Dear Upstream Developers —

Tips for Ruby project maintainers on increasing the changes of getting your stuffs packaged for Debian. Most are just good sense. Use setup.rb, don’t explicitly require rubygems in your libraries and tests, use the most portable shebang (#!/usr/bin/env ruby), and provide a man page. Ron can help with that last one.

Server-Side Javascript: Back With a Vengeance —

Nice to see Narwhal, Jack, CommonJS, and node.js getting some love on ReadWriteWeb. Javascript on the server is breaking out.

hub: git + hub = github —

defunkt’s hub is a command line utility that adds GitHub knowledge to git. Sweet. It expands GitHub repository references so you can do stuff like: git clone defunkt/gist, git remote add bmizerany, etc.

ron(7) -- the opposite of roff —

I’ve released a tool for authoring UNIX manual pages using a markdown-ish source format:

Ron is a humane text format and toolchain for creating UNIX man pages, and things that appear as man pages from a distance. Use it to build and install standard UNIX roff man pages or to generate nicely formatted HTML manual pages for the web.

It still needs some work but can produce useful output for both roff and HTML. The sources are on GitHub.

Clarity in log files —

Tobi’s log tail and grep app is precisely what I’ve wanted on every single syslog machine I’ve ever had to deal with. And the code has some great examples of using EventMachine features to do real async HTTP stuff.

Video: Node.js by Ryan Dahl —

ry’s talk from JSConf.eu. The leading paragraph says it all:

Node.js might be the most exciting single piece of software in the current JavaScript universe. Ryan received standing ovations for his talk and he really deserved it!

Wow. JavaScript is pretty damn big universe right now.

Node.js is genuinely exciting —

I agree. I played with it for a couple days and now I can’t shut up about it. That’s basically all I talked about at RubyConf :)

ANN: node.js (JavaScript) BERT-RPC implementation: node-bertrpc —

I’ve released a bertrpc library for node.js. If you haven’t play with node yet, set aside a night and dig in. Hacking async server-side stuff in JavaScript is every bit as awesome as I’d hoped: easy to install, good docs, fast VM, clean and simple event idioms. I’m impressed.

TURN - Test::Unit Reporter (New) —

Tim Pease’s unit test runner and reporter is sexy and has some really interesting features I’ve never considered when running unit tests. Here’s a piece of the README:

To use the solo runner.

    turn --solo -Ilib test/

This will run all tests in the test/
directory in a separate process.
Likewise for the cross runner.

    turn --cross -Ilib test/

This will run every pairing of tests
in a separate process.

Now that’s interesting. I’d love to have something like GNU Make’s -j option when running unit tests.

Writing good documentation —

Jacob Kaplan-Moss:

It’s really tempting to use an auto-documentation tool like Javadoc or RDoc for reference material.

Don’t.

Auto-generated documentation is almost worthless. At best it’s a slightly improved version of simply browsing through the source, but most of the time it’s easier just to read the source than to navigate the bullshit that these autodoc tools produce. About the only thing auto-generated documentation is good for is filling printed pages when contracts dictate delivery of a certain number of pages of documentation. I feel a particularly deep form of rage every time I click on a “documentation” link and see auto-generated documentation.

Hate that shit.

You know what I want? Man pages. For everything. Wouldn’t it be cool if you didn’t have to write roff?

rtomayko's dotfiles —

I recently started a repository for my dotfiles, shell environment, vim config, and utility scripts. As of right now, I’m about 25% through all of the stuff in my $HOME — it should all fill in shortly.

"In practice, nothing works." —

From the apparently just published, Coders at Work (Apress, 2009), Brad Fitzpatrick Talks About Programming:

In practice, nothing works. There are all these beautiful abstractions that are backed by shit. The implementations of libraries that look like they could be beautiful are shit. And so if you’re the one responsible for the cost of buying servers, or reliability – if you’re on call for pages – it helps to actually know what’s going on under the covers and not trust everyone else’s library, and code, and interfaces. (…)

They should have titled the book, “In Practice, Nothing Works”. Anyway, you can grab the — ick — PDF ebook for $20 on Apress.

Resque —

Really excited to see Chris release the shiny new Redis-based work queue that’s been running GitHub for the past couple of months:

It boils down to this: GitHub is a warzone. We are constantly overloaded and rely very, very heavily on our queue. If it’s backed up, we need to know why. We need to know if we can fix it. We need workers to not get stuck and we need to know when they are stuck. We need to see what the queue is doing. We need to see what jobs have failed. We need stats: how long are workers living, how many jobs are they processing, how many jobs have been processed total, how many errors have there been, are errors being repeated, did a deploy introduce a new one?

I’m still getting my feet wet with the jobs system but I can’t wait to get my hands dirty in the guts of this thing.

Notes on using NetBSD’s pkgsrc on Mac OS X —

I’ve dumped MacPorts for pkgsrc. This quick tutorial helped me get going and this package browser is awesome.

dtach —

Not sure how I never heard of this program before:

dtach is a tiny program that emulates the detach feature of screen, allowing you to run a program in an environment that is protected from the controlling terminal and attach to it later. dtach does not keep track of the contents of the screen, and thus works best with programs that know how to redraw themselves. dtach does not, however, have the other features of screen, such as its support of multiple terminals or its terminal emulation support. This makes dtach extremely tiny compared to screen, making it more easily audited for bugs and security holes, and also allows it to fit in environments where space is limited, such as on rescue disks.

GitHub has rake tasks that use dtach to manage redis and maybe some other things.

$ cheat rdebug —

Need more rdebug?

ruby-debug in 30 seconds (we don't need no stinkin' GUI!) —

I sometimes forget how useful a debugger is for coming up to speed on a new codebase. This bare-bones HOWTO on rdebug was everything I needed and nothing I didn’t.

memcache-top —

Nice little self-contained perl script that shows a basic memcached top display for a list of servers.

$ curl http://memcache-top.googlecode.com/files/memcache-top-v0.6 >
  ~/bin/memcache-top
$ chmod +x ~/bin/memcache-top
$ memcache-top --sleep 1 --instances memcache1,memcache2,memcache3

That gives you this:

Nifty.

Gemcutter to replace Rubyforge —

Gemcutter will become rubygems.org and Rubyforge will eventually go away entirely:

So, what does this mean for RubyForge? The Ruby-specific functionality and data will be moved into RubyGems.org, and the parts that other hosting sites (GitHub, Google Code, SourceForge) can do better will be pruned away. Migration paths for those projects will be provided, we’re not throwing any switches without warning. RubyGems.org will not be gaining any “bloat” from rewritten RubyForge features.

Wow. Congrats to @qrush and the Rubyforge team for pulling this off so quickly. Also, it’s pretty cool to see Heroku hosting a major/official piece of Ruby community infrastructure.

Installing Varnish with nginx, Passenger, and Monit on Ubuntu 8.10 intrepid —

Nice stack.

tigrc(5) —

Turns out tig, the ncurses front-end to git, is all kinds of customizable. Quick tip: set the author-width to 5 or less and author names are abbreviated to initials:

$ cat <<E > ~/.tigrc
set show-date = no
set author-width=3
E
$ tig
RT harmful specs - disable them
KN [defunkt/master] I shine the shoes around here
CW don't let daemon serving ruin the public / private flow
CW ensure the listeners are notified, just in case
CW add "open sourced" event
CW Turns out we're still stuck on 1.0
CW let's try this again
CW allow overriding of the queue during job creation

Boom.

Why I like Redis —

Simon Willison on using Redis with the Python REPL to get complex shit done quick. Insightful piece, as always.

SORT in Redis —

Redis’s SORT does a lot more than just sort stuff. Something clicked when I first saw this. I always wondered if/how more complex relational operations could be accomplished with key/value stores.

Rubular: a Ruby regular expression editor and tester —

I usually don’t like these web based regular expression editors but this one’s just right. Best part is that you can create a permalink for regular expression + text combos.

rtomayko forked defunkt/github —

It’s with great pleasure that I today announce:

I’ve taken a full-time engineering position with GitHub! It starts today.

[ANN] Rack 1.0.1 —

Maintenance release that fixes a bunch of issues under Ruby 1.9, some multipart form problems, and various other minor bugs.

The C++ FQA —

“Frequently Questioned Answers,” that is. A big list of why C++ sucks, basically. Also, here’s some solid C++ bashing by notable programmers. All of this and I’m only half-way through Eli Bendersky’s recent essay on C++ hate.

Gem Bundler is the Future —

Nick Quaranto shows why you need to start thinking about bundler.

PeepCode: Meet Sinatra —

Brand new PeepCode screencast on Sinatra by Dan Benjamin. The production on this thing is really exceptional and they get into some meaty topics. Highly recommended.

Everything is Unix —

Jeremy Zawodny takes a look at the * is Unix thing and throws in some additional goodness: more on fork(2), the benefits of copy-on-write, and atomic file operations.

Unicorn! —

GitHub documents the how and why behind their Unicorn setup. Also, for the record, the fork(2) + shared accept socket technique described in my Unicorn is Unix piece was first explained to me by Chris and Tom.

CodeRack —

The CodeRack Rack middleware competition has begun. All entries get a $30 credit from Heroku and the top three pieces of middleware get special prizes (to be announced). You should submit something. I want to see it :)

Unix is C —

@paulsmith’s simple preforking echo server in C.

Perl is Unix —

Aristotle Pagaltzis comes through with the simple preforking echo server in Perl.

Books by Richard Stevens —

Unix Network Programming, volumes 1 and 2, and Advanced Programming in the UNIX Environment. Yes.

Slides from Stefan Tilkov's HTTP Caching talk @ JAOO —

Warning: PDF. This is probably the best high-level, everything about HTTP caching all in one place resource on the web at this point. Good stuff. I’m kicking myself for not being a part of his track at JAOO now.

Python is Unix —

Jacob Kaplan-Moss does the prefork echo server example from my Unicorn is Unix piece in Python. Awesome. Let’s see some more of these. Where you at, Perl?

Thin vs. Unicorn —

Chuck presents the results of a few ab runs against Thin and Unicorn. Surprising, even if the benchmarks lack rigor. I’d like to see good autobench runs for all of the backends on same hardware/network.

An Engineer's Guide to Bandwidth —

It’s a rough world out there, and we need to to a better job of thinking about and testing under realistic network conditions. A better mental model of bandwidth should include:

• packets-per-second
• packet latency
• upstream vs downstream

Densely informational piece. Don’t miss the part where they generate packet loss using a microwave and a cup of tea :)

Full Stack ETag Support —

This is how I am using Rack::Cache, Sinatra, and CouchDB … Sweet ascii diagram there. I’ve seen this ETag chaining technique twice just this week. The other one is gemcutter. They store gems in S3 and pass the S3 provided ETag along in their responses, so it’s like the web app is more of an intermediary sometimes. Weird and cool and interesting.

hurl —

Chris Wanstrath and Leah Culver’s submission for Rails Rumble ‘09 finally has its own permanent hostname. Hurl makes HTTP requests and then shows you stuff about the response, like headers and a syntax highlighted body. Hurl’s have permalinks, too, so you can link to them from email threads, IRC, technical documentation, etc. See the about page for more info and a screencast.

Tornado on Twisted —

Dustin Sallings proofs out an implementation of the recently released Tornado web framework but builds on top of Twisted. The result is -1,297 fewer lines and all the benefits of having the Twisted framework underneath. I’ve been waiting for someone from the Ruby community to announce a port — we’re good at stealing. Using Dustin’s fork as a reference and basing a Ruby implementation on EventMachine might be the way to go.

Toward a new self-definition for open source —

Ian Bicking’s talk from DjangoCon 2009. Stimulating. I’m sure a nice comment thread will develop here over the next few days as well.

Prime-Numbers.org —

Prime number browser and generator for all primes smaller than 10,000,000,000 (so called “small” primes). Enter a number and find the prime that follows it — super useful in a variety of server administration and manual cryptography tasks. Also, “there’s totally 455,042,511 prime numbers.” Neat.

Common HTTP Implementation Problems, W3C Note —

Interesting W3C Note from January 2003 that I don’t remember ever seeing:

HTTP and URIs are the basis of the World Wide Web, yet they are often misunderstood, and their implementations and uses are sometimes incomplete or incorrect. This document tries to improve this situation by providing a set of good practices to improve implementations of HTTP and related standards (Web servers, server-side Web engines), as well as their use.

The information here is relevant to people who build web apps, not HTTP server implementors — the title is a bit misleading (not actually but practically). I especially like this bit about why short, less meaningful URLs are better than verbose, descriptive URLs. Shortness has become the most important characteristic of URL design in most apps I’ve built recently; SEO be damned.

Detecting HTML 5 Features —

Mark has published the second chapter in his upcoming book, Dive Into HTML 5. I still can’t get past the typography. It’s so pretty.

Snakes on the Web —

Jacob Kaplan-Moss somehow pulls a bunch of interesting contemporary web development issues into a coherent essay. This bit on what happens when web apps begin to mature is especially well stated:

This is an impossible situation for framework developers: by optimizing for a quick start, by focusing on common needs, we’re essentially guaranteeing future failure. Remember the “Rails doesn’t scale” pseudo-controversy last year? I guarantee it’s only a matter of time until there’s an angry “Django FAIL” moment.

Frameworks ought to gracefully fade away as you replace them, bit by bit, with domain-specific code. (This is what I meant, above, that inter-op is also a scaling issue.) Right now, they don’t.

I wish more people would write about their experiences growing out of the general purpose web framework. It’s a totally natural thing but most people seem hesitant to talk about it because it’s interpreted as an attack on the framework or community.

Circle of death —

Nice diagram. I’m way too familiar with this process.

Things you didn't know you can do with a heredoc —

Matt Todd and Mike Perham show off some nifty Ruby heredoc fu. It’s a gist, so fork it and add your own craziness.

Unicorn's signal handling —

Unicorn is a newish Rack-based HTTP server that’s kinda sorta like Mongrel but comes packed with some insane process management features. The main link is to the SIGNALS file, which documents the master/worker process model, supported signals, process replacement, failover, etc. See the README for a high level description of features.

This link brought to you by @defunkt, who explained Unicorn’s unique approach (repeatedly) over the course of a week.

Threaded Awesome —

Joe Damato and Aman Gupta show why and how Ruby (MRI)’s thread implementation sucks. Great presentation with lots of useful examples of using tools like strace and gdb to figure out where a process is spending time. Warning: you will be depressed and embarrassed after reading this if you currently target Ruby MRI.

Blocks (from the Ars Technica review of Mac OS X 10.6) —

I didn’t know about this:

In Snow Leopard, Apple has introduced a C language extension called “blocks.” Blocks add closures and anonymous functions to C and the C-derived languages C++, Objective-C, and Objective C++.

They go on to list code samples in each language. The syntax is … not what I expected. Check out the section on LLVM and Clang also.

On Rake —

John Barnette with a must read piece for anyone that’s ever written a Rakefile.

How to Build Sinatra on Rails 3 —

Kudos to everyone hacking on Rails 3. This is a great demonstration of how far they’ve come in making it possible to pull in only the bits you need, without gem hell and activesupport spewing all over everything. Also, if you have an opportunity to see Yehuda’s “shit that’s happening in Rails 3” presentation, take it.

Hijack: Get A Live IRB Prompt For Any Existing Ruby Process —

Only requires that gdb be available on the box. No requiring libraries or listening on sockets to get the console. Rad.

Programming and Minimalism —

Jonathan Dahl talks about minimalism and clarity in writing and how to use these principles in programming. Great talk. He uses a lot of analogy and audio/visual stuff at the beginning, which (in my experience) typically means that the presenter has no fucking idea what they’re talking about. Not here. Excellent, well-rounded talk.

40 years of Unix —

Amazing, the way these things happen:

… in August 1969, Ken Thompson’s wife took their new baby to see relatives on the West Coast. She was due to be gone for a month and Thompson decided to use his time constructively – by writing the core of what became Unix. He allocated one week each to the four core components of operating system, shell, editor and assembler.

Constraints are powerful things.

Let's make the web faster —

Big giant list of articles, essays, tutorials, and tech talks on making the web faster. This is part of a larger Google Code project that asks, “what would be possible if browsing the web was as fast as turning the pages of a magazine?”

Dive Into HTML 5 —

My God the typography is stunning. There’s currently only a single chapter — on Canvas — but I imagine the others will fill in rather quickly.

Why's (Poignant) Guide to Ruby —

I’ll admit, I’ve been holding out, hoping that _why’s disappearance was just a big misunderstanding. But at this point, I don’t think he could come back even if it were a big misunderstanding. Here’s a mirror (thanks mislav + GitHub Pages) of the Poignant Guide – the canonical reference for how to be. It’s our GOF; our SICP. I don’t think I’ve ever been so in awe of a piece of technical literature. Now it just makes me sad.

Dropping Django —

This seems to be a trend in Python and Ruby web circles. Frameworks present developers with a choice: accept these constraints, give up a little control, and I’ll make you more productive. Longer-lived apps start to evolve out of the framework at some point, though. You need more control over a piece here, or aren’t satisfied with the way something works there, and so you refactor and pull stuff out until the framework begins to slowly fade away. Maturity is a part of the web app development lifecycle we have precious little data on.

This comment nails it:

Maybe it worked out exactly like it should have. Django bootstrapped your app to a certain point. Got you further faster than you would have if you implemented everything from scratch. Then from there, you identified the things you considered inadequate and replaced them. If it all goes away who cares. You have learned something, shared it with us and moved on.

I think that’s just fine. Unexpected maybe, but fine.

GFS: Evolution on Fast-forward —

A discussion between Kirk McKusick and Sean Quinlan about the origin and evolution of the google file system (GFS). Really good interview. They’re fairly critical of the original design and how GFS is being used today. There’s also some discussion of an entirely new and incompatible version of GFS, designed from the ground up for the types of workloads GFS is being used for today.

Monk —

Nice looking Sinatra + Redis web framework with some novel concepts. Comes with a generator-like system as well: Skeletons are public git repos that are cloned into your local work tree. I’ve always wondered why this kind of project template system never took off before. Absolutely elegant.

sinatra-sequel —

Sequel has become my ORM of choice for Sinatra apps backed by a SQL database. This is a quick Sinatra extension I threw together to remove some of the boilerplate required to get a new app setup. It includes a simple single-file migrations framework and some other stuff. See the README for examples.

gemcutter - awesome gem hosting —

This is an interesting idea. Publishing gems on rubyforge is complicated but the gem source is everywhere and gems have sane file names. Publishing gems on github is dead simple but the filenames include a username prefix, which is just kind of weird. Publishing gems to gemcutter is simple enough and the gems have sane filenames. This could work.

PostgreSQL, Rails, and why you should care —

Nice short list of PostgreSQL features everyone should be thinking about when choosing between MySQL and postgres (and each with a link to more detailed information). Then a wrap up that talks a bit about the licensing situation:

One of the major reasons for trying out PostgreSQL, regardless of it’s feature set, is it’s license and community. This can’t be more true these days, when MySQL AB was consumed by Sun Microsystems, which in turn recently got acquired by Oracle. While I doubt that the product itself may die off, the fact that the copyright to the code, and the direction of the database system itself may and will be dictated by a company like Oracle is a deal breaker for me.

I suppose it’s a bit on the FUD side but those are my feelings exactly.

Do it Later With Delayed Job. —

Koz on Delayed::Job’s lesser-known send_later and handle_asynchronously methods. Sweeet.

Traffic Server Proposal —

Yahoo!’s proposal to open source their “fast, scalable and extensible HTTP/1.1 compliant caching proxy server” as an Apache project:

Traffic Server fills a need for a fast, extensible and scalable HTTP proxy and caching. We have a production proven piece of software that can deliver HTTP traffic at high rates, and can scale well on modern SMP hardware. We have benchmarked Traffic Server to handle in excess of 35,000 RPS on a single box. Traffic Server has a rich feature set, implementing most of HTTP/1.1 to the RFC specifications.

Rad. I know Yahoo! runs a custom build of Squid as well so I’m curious to understand where this thing came from. The proposal states that it was originally acquired from Inktomi and has been in use for some time.

Backlogs and Request Time —

Adam takes a look at how long requests and backlog interact. The sleep example runs concurrently under Mongrel but Thin and WEBrick will backlog.

RabbitHub - RabbitMQ PubSub-over-Webhooks —

Tony’s simple HTTP interface to RabbitMQ. Somebody get this running as a service on EC2 so we can hook Heroku apps up to it on the private network.

Rails Envy: RailsLab: Load Testing - Part 2 —

“… learn how to use httperf load testing with sessions, how to automate our httperf testing using autobench, how to graph the results from autobench, and lastly we talk briefly about a few other load testing tools you might want to be aware of.”

This is the second time Gregg has beat me to a great screencast :)

Rip: A Next Generation Ruby Packaging System —

There’s a nice combination of old and new concepts in here.

What to Look For in a HTTP Proxy/Cache —

mnot on how to evaluate different proxy cache options for your needs.

Why Events Are A Bad Idea (for high-concurrency servers) —

I want to believe!

It's the Latency, Stupid —

Another classic on latency vs. throughput. This one gets into the limitations of speed of light fairly quickly :)

Relationship between latency and throughput —

Interesting reading if you found Nick’s handling of latency vs. throughput (in the gogaruca talk) intriguing.

Stefan Tilkov's REST Book: References —

Whoa. How do I get my hands on an english copy?

Sinatra Rack And Middleware —

Amazing! I put Ben under the table that night. Tucked him into bed and gave him a kiss.

3 Reasons Why Heroku is a Game Changer —

We’ve been getting a decent amount of PR-ish type coverage since the commercial launch but I still say blog posts like these are infinitely more interesting:

Remember when microwaves first hit the scene and people couldn’t believe how fast they could ‘deploy’ a meal? Yah me either, but the microwave changed the game big time.

And, unlike the microwave, Heroku doesn’t make your apps taste like cardboard :)

The Web vs. the Fallacies —

Tim Bray evaluates the web’s basic design from the perspective of the Fallacies of Distributed Computing. Reminds me of TimBL’s Axioms of Web architecture a bit. This stuff is essential to understanding why the web succeeded where other systems failed and why the web seems quirky in some ways compared to other distributed computing systems.

An easy way to run many tasks in parallel —

Nice. The xargs(1) switch -P N will run up to N separate processes in parallel. Combine with the -n M switch for a quick and dirty process pool.

The Git Parable —

tl;dr — that’s why it’s awesome.

djng—a Django powered microframework —

Simon Willison is working on python web microframework based on Django. This will get interesting. Fast.

Fixing Threads in Ruby 1.8: A 2-10x performance boost —

Must read.

HTTP's Best-Kept Secret: Caching —

Here’s the slides from my RailsConf 2009 presentation on HTTP caching. I doubt the general info will make much sense without me talking over it but the diagrams should be fairly useful.

When Formality Works —

Coda on why Rack has had so much success within the Ruby community and modeling projects after it in the future. I couldn’t agree more.

Devil's RailsConf 2009 Dictionary —

Christian Neukirchen’s RailsConf 2009 wrap up. I had a pretty amazing time at the conference but sharing a Hookah with Chris was definitely a highlight.

Mechanical Analogies To Web Stuff, Part 2. —

Really interesting analogy between web architecture and a car crash. This is the piece that’s missing from almost every conversation about whether any given web framework or component “scales”. (via @jperkins)

message threading —

Jamie Zawinski (1997): “In this document, I describe what is, in my humble but correct opinion, the best known algorithm for threading messages (that is, grouping messages together in parent/child relationships based on which messages are replies to which others.) This is the threading algorithm that was used in Netscape Mail and News 2.0 and 3.0, and in Grendel.”

When celebrity programmers attack: Guido on tail calls —

“Almost all non-functional programmers are unaware that tail calls facilitate a programming paradigm that they have never seen. The ability to tail call to functions that are not statically known is the foundation that makes many combinators useful. This is a style of programming where functions are composed in order to create a pipeline for values to flow through. Without tail call elimination, every stage in the pipeline would leak stack space and the whole approach becomes unusably unreliable.”

TDD Anti-Patterns —

James Carr’s classification system for unit test smells and anti-patterns. This is almost three years old but still extremely relevant judging by the test suites I’m working with today. I’m guilty of more than a few of these. Via @coda.

Bunny - a synchronous Ruby AMQP client —

Nice. Probably more appropriate than tmm1-amqp in threaded/synchronous environments or when you don’t want to deal with EM. Then again, I believe tmm1-amqp has a synchronous interface. If not, it wouldn’t be hard to put one together with fibers.

Rack 1.0 released! —

We made it.

Heroku Pricing —

I’ve been staring at this screen for two sleepless weeks now. Really glad to have it wrapped. James Lindenbaum (CEO/founder/bad-ass) did most of the conceptual design work. seaofclouds did the fucking amazing illustrations and took the design to completion. Pedro Belo did the HTML/JavaScript and server side stuff. Definitely one of the best teams I’ve worked on.

Deploying Ruby Web Applications to Heroku —

Remi’s kick ass screencast on deploying to Heroku.

Mark Nottingham's HTTP Status Report presentation at QCon '08 —

Protocols are hard. Nobody understands this.

RabbitMQ - A Fast, Reliable Queuing Option for Rubyists —

I had a chance to hang out with Rabbit’s Tony Garnock-Jones last week. Awesome guy. Knows his shit. We use RabbitMQ prettyy all over the place at Heroku — big fans.

RackDAV - Web Authoring for Rack —

Matthias Georgi’s framework for building DAV servers in Ruby with Rack. Could make building apps that mount into a local filesystem quite simple.

ruby gc tuning —

Great ideas for tweaking Ruby’s GC after applying Stefan’s Kaes’s GC patch. By the way, that patch has been an option on the ruby port in FreeBSD for years. It works. Apply it.

Bigcurl: Running Sinatra apps on Google AppEngine (Java) —

This is why simple is better. Sinatra probably runs well on any compatible ruby with a Rack handler.

Dive into history, 2009 edition —

Mark Pilgrim: “Anyway, I now realize that there were some hidden assumptions behind my design decisions in 2000. Some of those assumptions turned out to be wrong, or at least not-completely-right. Sure, a lot of people downloaded dip, but it still pales in comparison to the number of visitors I got from search traffic. In 2000, I fretted about my ‘home page’ and my ‘navigation aids.’ Nobody cares about any of that anymore, and I have nine years of access logs to prove it.”

I don’t think most people realize how little site navigation matters anymore. Your site’s navigation is google, topic sites, blogs, and feeds. The “website” is dead. Long live the individual useful resource.

Slacker databases break all the old rules —

Good writeup on the rise of document and columnar databases, including Amazon SimpleDB, Apache CouchDB, Google App Engine, and Persevere.

rack-cache 0.4 released —

Get it while it’s hot.

Gay People, Come To Rails —

Well said. It appears PHP’s culture of stupidity isn’t limited to technology. What a bunch of assholes.

Delve into UNIX process creation —

It’s important to understand how fork(2), pipe(2), and exec(2) work. I don’t want to hear anymore of this “fork is a hack” shit from any of you :)

JSONQuery —

XPath-like syntax for expressing selection queries against JSON data structures. Interesting concept. I’ve always wondered why the basic concepts behind XPath were never borrow and applied to other types of structured data — it’s so insanely useful. I suppose jQuery popularized using CSS selectors for querying HTML but why not take the same basic concept and apply it to problem domains outside of SGML-inspired markup languages and their data models.

Rack::Test released: Simply test any Rack-compatible app —

Nice. This is very similar to the Sinatra::Test module but with a few additional features (i.e., the session/cookiejar thingy). If this gets traction (and it will), we’ll deprecate Sinatra::Test and recommend people use Rack::Test instead.

Deploy Merb, Sinatra, or any Rack App to Heroku —

I worked on this a bit. Jazzed to see it announced. Actually, they pretty much had everything working when I got there. I wrote some docs and tightened things up a bit is all.

Now go deploy something – it’s free!

An in-depth interview with Steve Bourne, creator of the Bourne shell, or sh —

I <3 sh(1).

Heroku - How it Works —

Things are starting to get interesting around here. James pulled together some (fucking sexy) high level architectural diagrams and annotated them just so. We can start talking about what we’re up to a bit more now that this is out. I’m jazzed.

Why It's Worth Fixing HTTP Authentication (and How to Do It) —

Why browser UI for HTTP auth is so horrible has always baffled me. This could be improved significant without any changes to HTTP whatsoever.

Twitter's Varnish config —

John Adams posted a bunch of details of the Varnish configuration they use in front of search.twitter.com to the varnish ML. Great stuff and nice to see the Twitter devs continuing to share their experiences with the community.

Twitter / sinatra —

Harry Vangberg put together a Twitter relay bot in #sinatra (nick: nancie) so a bunch of the cool cats there are keeping the @sinatra twitter feed lit up with a stream links, tips, and announcements.

Scaling Rails - Episode #11 - Advanced HTTP Caching —

I haven’t actually had a chance to watch this yet but I’m sure it’s great if it builds on the talk Gregg gave at acts_as_conference 2009. Also, I love this slide: “Reverse Proxy Caches – WTF?” :)

Gregg Pollack presents Rack::Cache at acts_as_conference 2009 —

The RailsEnvy guys presented on a bunch of recent innovations in the Ruby/Rails community in their acts_as_conference 2009 talk. Go to 24:00 where Gregg gives a really tremendous overview of using Rack::Cache, the benefits of HTTP caching in general, and how to use all of this stuff in Rails 2.3.

Enterprise static files —

This reddit comment makes me wish lesscode.org was still around :)

How to setup and use Rack::Cache with Rails 2.3.0 RC 1 —

Huge thanks to christian for getting this up. I’ve been meaning to get something on the Rack::Cache site for some time now.

bash 4.0 NEWS file —

Big list of new features in bash 4.0.

Shotgun: Because reloading always sucks —

This has been sitting in the back of my brain for months now. I finally got a chance to throw something together last night:

Shotgun is an automatic reloading version of the rackup command that’s shipped with Rack. It can be used as an alternative to the complex reloading logic provided by web frameworks or in environments that don’t support application reloading.

The shotgun command starts one of Rack’s supported servers (e.g., mongrel, thin, webrick) and listens for requests but does not load any part of the actual application. Each time a request is received, it forks, loads the application in the child process, processes the request, and exits the child process. The result is clean, application-wide reloading of all source files and templates on each request.

Sliding Stats: Rack Middleware to keep an eye on your traffic —

Another interesting use of Rack middleware.

Ryan Tomayko on the Ruby on Rails Podcast —

Geoffrey Grosenbach interviewed me yesterday for the Ruby on Rails podcast. We had a nice chat about Python/WSGI, Rack, Sinatra, Rack::Cache, Heroku, and other random stuff.

The Future of Deployment —

I started full time with Heroku last Wednesday. This is why.

Fibers implemented for Ruby 1.8.{6,7} —

Aman Gupta and Joe Damato have implemented Fibers for the 1.8.6 and 1.8.7 MRIs. They’re patches now but will hopefully go into a 1.8.8 release. I had a chance to see these guys give a quick talk on their work at a local Ruby meetup — it was a hit.

Easy client-caching with RestClient and Rack::Cache —

This is one the amazing benefits of having an insanely simple but well defined SPEC (Rack) around the edges of your library. It makes it trivial to hook things up in new and interesting ways.

Ruby `sendfile(2)` Interface —

“This module allows Ruby programs to access their OS’s native sendfile(2) system call from any IO object. Your kernel must export a recognized signature for the sendfile(2) system call to use this module. Currently, that includes Linux, Solaris and FreeBSD.”

Stop picking on alias_method_chain —

“Not to mention ‘overrideable’ is not a real word.”

bloat.rb —

Pat Nakajima’s script to measure the amount bloat you’re adding by requiring libraries. Generates a report on the number of methods added, along with a list of names. Interesting metric.

Ruby 1.9.1 (NEWS) —

Ruby 1.9.1 is out. Here’s the final rev of the NEWS file. Nice, condensed list of everything that’s new or changed.

virtualrb —

Christian Neukirchen’s utility for managing multiple virtual ruby installations.

Sinatra —

We gave the Sinatra website a major face lift. Check it out. Don’t leave without subscribing to the feed.

Taming Perfectionism —

Real artists ship.

A Well-Tempered Pipeline —

A lost art, indeed.

Javascript, it's Python with braces! —

Guyon Morée shows how JavaScript 1.7/1.8 have been moving more and more toward Python with a few side-by-side examples. List comprehensions and generators would definitely be extremely cool to have in browser land.

Classy Web Development with Sinatra (Screencast) —

The Prag’s have published two screencasts in a new series on Sinatra.

Integrity - The easy and fun automated continuous integration server —

Ruby based continuous integration server that rocks. Built on Sinatra and DataMapper. Painless setup, beautiful web UI, hooks up to GitHub. I wish I’d went and looked at this earlier.

When in Doubt, Turn to _why —

Magnus Holm disects a couple of implementations for parsing nested form parameters (e.g., “person[name]=Joe&person[zip]=55555”) in Ruby. _why’s is the most interesting (as always). We just added this to Sinatra and I’m fairly confident we’ll see something like it land in Rack before 1.0.

Multiple Sinatra .90 applications in one process —

Tanner Burson talks about one of the larger accomplishments of the Sinatra 0.9.0 release. We definitely need more docs on using Sinatra in this fashion.

It's OK for GET Requests to Update the Database —

True! A lot of cargo-cult types get this wrong.

Conceptual Algorithms (Presentation) —

Tom Preston-Werner shows you how to think.

Intro to Caching, Caching Algorithms and Caching Frameworks —

Nice overview of caching from 1000 feet. Lays down some useful terminology, like “Cache Hit”, “Cache Miss”, “Storage Cost”, “Retrieval Cost”, “Invalidation”, “Replacement Policy”, etc.

[ANN] Sinatra 0.9.0 released! —

I put a lot of work into this release. Really happy to see it out :)

Woonerf and Python —

Ian Bicking explains the connection between modern traffic planning and modern programming in dynamic languages.

Dan Webb - 8 minutes on Rack —

Quick presentation on Rack by Dan Webb. Covers a lot in eight minutes.

Painless commit splitting in git —

Aristotle Pagaltzis shows a pretty crazy technique for splitting a single git commit into multiple separate commits using an interactive rebase and successive checkouts on the same branch. Interesting approach. I usually pop the commit off into my working directory with git reset HEAD^ and then use multiple iterations of git add --patch + git commit until my working directory is clean again.

Video of Matt Todd's Rack Presentation @ ATLRUG —

Matt Todd did a nice presentation on Rack to the Atlanta Ruby Group (ATLRUG) and they were nice enough to put video of the slides + audio of Matt’s narration online.

Gem Weight —

Adam Wiggins: “gemweight.rb is a script to calculate the memory use and load time of a given gem.”

I’ve run numbers (very adhoc) on various gems before and I’m always surprised at the results. Libraries you’d think would be small are sometimes big and libraries you’d think would be big are almost always big :)

Rack::Cache implementation annotations on RFC 2616 —

I’ve annotated RFC 2616 Section 13 with details on where Rack::Cache is and isn’t compliant. Anything not highlighted should work as described in the RFC. I think I’ll be using SharedCopy more in the future.

“By installing Java, you will be able to experience the power of Java” —

Funniest thing I’ve seen on Joel on Software in quite some time.

No More Secrets —

Ian McKeller shows how easy it is to find web API “secret keys” when the user has access to the (network) client code. It’s actually a nice little crash coarse in how to write cracking software (here “crack” means warez scene type “crack”). That crazy shit like this is possible is why I got into software in the first place. Completely

Extension/Scripting language comparisons - comp.lang.scheme —

“While I do consider the adjective ‘baroque’ to be a compliment, I must point out that Perl is actually more of a romantic piece, with allusions to various classical motifs. My favorite composer is Mahler, which should surprise no one.” — Larry Wall

Ruby 1.9 - What's new? What's changed? —

Markus Prinz with a nice review of important Ruby 1.9 changes.

rack-esi —

Christoffer Sawicki has started in on a partial implementation of ESI (Edge Side Includes) as a Rack middleware component. Put something like this in front of Rack::Cache and things get real interesting real fast :)

Sanitize: A whitelist-based Ruby HTML sanitizer —

Finally, a sane looking sanitization lib that doesn’t try to do too much.

Resourceful —

Interesting looking HTTP client library for Ruby with support for HTTP caching (with pluggable backends), basic and digest auth, intelligent redirect handling. It’s been around for a while and looks like it could eventually become similar in feature set to Python’s httplib2.

cachet —

Nick Kallen has started a project to implement a HTTP cache in Scala. Seems like an excellent idea given Java’s extensive collection of stable HTTP server libraries and Scala’s strengths in concurrency and performance.

Rails and Merb -- Why Merge At All? —

A much more sober but constructive take on the plan to merge Rails and Merb.

RUBY-STYLE —

Christian Neukirchen’s Ruby styleguide. The best I’ve seen.

Google Groups: rack-cache —

Mailing list for Rack::Cache users and hackers. Come on in, the water’s warm.

CloudKit via cURL —

Jon Crosby’s RESTful JSON-based data store with OpenID and OAuth support. It does versioning and produces HTTP cache friendly responses all in a Rack middleware component. Jon’s been working on this for some time and it shows in the code and docs. Awesome.

Concluding Remarks —

Jean-Jacques Dubray: “How do the RESTafarians work? They take Roy’s REST, they try to use it for anything in their day to day activities, and then when they stumble upon a problem, they try to find a more or less ‘RESTful’ solution and post it on a blog.”

Precisely!

Sinatra: 29 Links and Resources For A Quicker, Easier Way to Build Webapps —

Peter Cooper: “Lots of awesome articles about Sinatra, Sinatra apps, and various links and resources have cropped up over the past few months. The remainder of this post links to the best we’ve found – most of which you should find useful as you start to explore Sinatra in detail.”

Introducing Rails Metal —

David Heinemeier Hansson: “Rails Edge adopted Rack a while back and we’ve been exploring ways to expose that better. The first thing we did was to make it really easy to hook up any piece of Rack middleware in front of a Rails request. In your config/environment.rb file, you can do: config.middlewares.use(Rack::Cache, :verbose => true)”

Oh hell yes.

Rails Metal: a micro-framework with the power of Rails: \m/ —

Rails riding on Rack is going to be a big deal.

A Collection of Rack middlewares —

It’s really starting to come together, isn’t it?

Introducing Cache Money —

Bad-ass ActiveRecord extension that does read-through and write-through caching to memcached in a way that’s fairly transparent. This is one of the strategies the Twitter folks put in place recently to improve their response time and availability.

What’s Ruby’s future —

Rafe Colburn: “On the other hand, I find programming in Ruby enjoyable and educational, so it’s not like I’m looking to give up. It’s just that even after a couple of years of doing it, I still feel like we’re dating rather than married.”

It seems like a lot of people are down on Ruby at the moment. Odd. I’m actually more excited about Ruby than I’ve ever been. Things seem to be moving along nicely, especially on the web tooling front.

ETags And Modification Times In Django —

Nice look at caching idioms in Django and why you need to generate HTTP cache validators up-front and efficiently.

More Developers, Less Code —

I never put it together that the teddziuba that wrote at lesscode.org in 2005 was that teddziuba. This is a great piece.

RubyConf 2008: Lightweight Web Services —

Adam Wiggins and Blake Mizerany’s presentation on Sinatra and RestClient.

ncache —

An Nginx module that acts as a gateway cache. I haven’t tried it yet but it’s a really good idea.

cowsay(1) —

Best. Program. Ever.

Code for Christmas —

Xavier Shay:

Ticking off an amazon wishlist never really resonated with me, so this year here is what we are all doing instead:

1. Find someone’s pet open source project – I’d start at github
2. Contribute! It doesn’t have to be much – a spec or two, some documentation, or even just a “hey it works on my box”. Fork, commit, pull request.
3. Wish them a Merry Christmas!

Great idea. I feel like I finally have something worthwhile to give this year.

Building a iPhone web app in under 50 lines with Sinatra and iUI —

Nicely done. I have to take a serious look at iUI one of these days. It sounds like you can get really close to a native app experience.

Debug your shell scripts with bashdb —

“The syntax for many of the commands in bashdb mimics that of gdb, the GNU debugger. You can step into functions, use next to execute the next line without stepping into any functions, generate a backtrace with bt, exit bashdb with quit or Ctrl-D, and examine a variable with print $foo.”

Ruby on Rack #2 - The Builder —

Pratik continues his series on Rack with a deep dive into Rack::Builder.

Why specs matter —

I’ve linked to this before and I’ll link to it again.

Ruby on Rack #1 - Hello Rack! —

Pratik’s first in a series of pieces on Rack: how it came to be, why you need to understand it, along with some simple examples. Future installments will cover Rack::Builder and Middleware.

Smooth HTTP Caching With Rack::Cache —

Sebastien Auvray covers Rack::Cache at InfoQ. Thanks!

An Introduction to A/B Testing —

I’ve read about five extremely solid articles on this site (20bits.com) today; all thorough, easy to read, and cover interesting topics.

Rails vs Merb ¿drama? —

You’ve got to be kidding me.

How can C Programs be so Reliable? —

Laurence Tratt: “I had implicitly bought into the idea that C programs segfault at random, eat data, and generally act like Vikings on a day trip to Lindisfarne; in contrast, programs written in "higher level” languages supposedly fail in nice, predictable patterns. Gradually it occurred to me that virtually all of the software that I use on a daily a basis – that to which I entrust my most important data – is written in C. And I can’t remember the last time there was a major problem with any of this software – it’s reliable in the sense that it doesn’t crash, and also reliable in the sense that it handles minor failures gracefully."

The Road to HTML 5: getElementsByClassName() —

Includes a brief history of native support for getElementsByClassName in Mozilla and other browsers.

A critical look at the current state of Ruby testing —

Yeah.

Rack cache headers —

Interesting approach to setting cache related headers using a Rack middleware component.

minigems —

An interesting RubyGems mod by Fabien Franzen that seems to fix the memory hit a process takes on require 'rubygems'. Unfortunately, you have to code for it in your app and apply it to installed ruby commands explicitly. Fabien has submitted a ticket and patch to the RubyGems project, however. You should +1 it (after reviewing the code, of course).

Hofstadter's Terrible Law —

Adam Gomaa: “… this state of affairs doesn’t really help my general feeling of hopelessness when it comes to programming – I know that no matter how good I get, I’m still stuck at being just one person, and the code a single person can write is pitifully small.”

I’ve come to the same conclusion within the past couple of years. I take on much smaller projects now and try to contribute more to existing projects rather than playing mad scientist on massive works that will never see the light of day. I’ve also come to appreciate the idea of paying lots of attention to detail on one small thing rather than churning out large quantities of half-baked features.

Rack::Cache is a good idea —

Ryan King nails it.

Why Programmers Suck at CSS Design —

Stefano Mazzocchi: “I have a much simpler and humble goal here: give programmers some tricks and some advice in how to proceed to make their web pages look cleaner, more readable and, hopefully, more professional, elegant and original than before.”

Advanced Squid Caching for Rails Applications —

So, I got an email yesterday disagreeing with my remark about HTTP caching being wildly under-appreciated in the Ruby web community. I felt bad, a little. Then I read this article (posted the day after my remark), which talks about Scribd moving to a Squid reverse proxy setup to front their Rails deployments:

“But there was a problem – no one uses caching proxies in 2008 :–) So, we’ve got an idea – why can’t we place such a server in front of our application and make it cache content for all users in the world?”

The fact that Scribd had to “have this idea” on their own and had not previously been exposed to a ton of literature/tools on reverse proxy / gateway caching is completely fucking unacceptable. I’m back to agreeing with myself.

Creating a Rack Middleware for Minifying Your Javascript files —

Pretty good introduction to building pieces of Rack middleware and using Rack::Builder.

What's New in Edge Rails: Even Better Conditional GET Support —

Much nicer, IMO. I’m interested to see if someone can get Rails + Rack::Cache working together so that you can maximize the benefits of generating these validators.

Introducing ActsAsMarkup: A Markdown, Textile, Wikitext, and RDoc Plugin for ActiveRecord —

Interesting Rails plugin from Viget Labs that adds ActiveRecord attribute helpers for various humane markup languages. The markdown variation supports both rdiscount and rpegmarkdown. Cool. Not sure how I missed it when it was released in August.

Ezra's "Merb, Rubinius and the Engine Yard Stack" Google Tech Talk —

So I’ve been skeptical about Merb but I really like the world-view Ezra puts forth here: core framework code should be simple (no/little meta-programming), fast is good, Rack is awesome, etc.

What I Believe Roy Said —

Paul Downey translates Dr. Fielding’s REST APIs Must be Hypertext Driven into lay-hacker speak.

AJAX should not mandate HTTP —

Huh? In a sane world, “Ajax” would have been called “HTTP” (or, more elaborately: “JavaScript gets a mostly-standard asynchronous HTTP client library”).

At first I thought this was going to be one of those articles that confuses animated JavaScript effects for Ajax but it goes on to talk about how Ajax is bad because it breaks “Save Page to File” … or something. Save Page to File?!

Screencast: "I use Vim for everything" —

There’s so many great workflow hacks in here.

How I Turned Down $300,000 from Microsoft to go Full-Time on GitHub —

Tom Preston-Werner on how GitHub came into being and leaving Powerset after the Microsoft acquisition: “When I’m old and dying, I plan to look back on my life and say ‘wow, that was an adventure,’ not ‘wow, I sure felt safe.’”

Why Ruby is Not My Favorite Language —

Same here. I’m still looking for techniques that would make my Ruby libs and apps as simple to follow, debug, and maintain as equivalent Python versions are naturally. Ruby’s module system and cowboy shit (instance_eval, modifying Object, Class, Module, etc.) can go to hell. Python + blocks + class scope + large community and I’m sold.

Conditional classnames —

Using conditional comments to stick an “ie” classname on <body> so that you can target IE from a single CSS file instead of bringing in a separate stylesheet. Nice hack.

Varnish 2.0 released! —

Looks like a really solid improvement on 1.0. I haven’t had a chance to play with any of the betas but I’m anxious to see whether If-Modified-Since/If-None-Match validation made it in. There’s a note on “serving expired objects until we have a fresh one” but that sounds more like stale-while-revalidate.

The Programming Aphorisms of Strunk and White —

“Of course, Strunk and White, as the book is commonly called, has nothing to do with software (it was written in 1935) and everything to do with writing: grammar, composition, and style for users of the English language. But in its 100 short pages this book has more to say about the craft of software than many books you’ll find in the ‘Computing’ section of your local bookstore. All you have to do is replace a few key words throughout the text and presto! Pearls of software development wisdom, delivered in near-perfect English.”

An Introduction to REST —

Joe Gregorio’s 14 minute video introduction to REST and HTTP.

class='robots-nocontent' —

Apparently, Yahoo!’s indexer supports marking specific content on a page as “extraneous to the main unique content”. This lets you prevent headers, navigation, and other types of site-level crud from overwhelming the content and the search results will excerpt only content that’s relevant to the page.

From the Yahoo! Web Crawler FAQ: “… apply the robots-nocontent attribute to indicate to search engines any content that is extraneous to the main unique content of the page. Yahoo! Search observes the class='robots-nocontent' present on XHTML elements, such as div, span, and all others.”

The Web is Agreement —

This is really close to what “the web” looks like in my brain:

I try to stay in the general vicinity of the “principles mound.” :)

Don’t overuse instance_eval and instance_exec —

Ola Bini: “Using instance_eval changes the rules for the language in a way that is not obvious when reading a block. You need to think an extra step to figure out exactly why a method call that you can lexically see around the block can actually not be called from inside of the block.”

Having abused instance_eval in the past, I can say with absolute clarity that it’s usually The Wrong Thing. It can make DSLish code look really cool in controlled and scoped demos but it greatly increases cognitive complexity, making things hard to read and maintain.

"Air Budd Form Builder" meets "/admin Considered Harmful" —

Bill Burcham applies the technique of making form controls inherit style from their container in the Air Budd Form Builder Rails plugin. Cool.

FastHTTP —

… is a Ruby library suitable for use as a drop-in Net::HTTP replacement or with event frameworks like EventMachine and Rev.

Minima —

Alex Payne’s tumble-like blog on minimalism in coding and design. I didn’t realize @al3x was such a huge conscious follower of the minimalist aesthetic, although I’ve definitely noticed it in his work.

Google's undocumented favicon to png convertor —

I’m using this on all of my “linkings” index pages now (see here, for example). It works pretty well. I really like the idea of integrating a piece of the destination site’s visual identity instead of using a generic del.icio.us/bookmark icon. Some site’s with favicons don’t work properly, however, and I’d give anything to have another parameter that let me override the default globe icon (this one: ). It’d be nice if I could say, grab the favicon for this domain but if it doesn’t exist, give me the favicon for delicious.com ().

Managed Ajax - A New Approach to Ajax —

A horrible and misguided idea. I’ve personally never even liked the RJS/JavaScript generation stuff in Rails, and it’s actually well designed, thought out, and quite simple. “Managed Ajax” takes it to a whole new level, building from the assumption that “JavaScript is the new assembler,” and moves most types of interaction logic to the server. Reality seems to be moving in the exact opposite direction. Do yourself a favor and get real comfortable with JavaScript.

Subtree merging and you —

Very interesting alternative to git submodule, especially in “vendor branch” type scenarios. The other project is merged into yours at a specified prefix and can be updated with a simple git pull.

Latest iPhone Software supports full-screen Web apps —

“One unpublicized feature introduced by Apple’s latest iPhone software updates is the ability to save Web apps to the home screen and have them launch in full-screen mode without the Safari wrapper, essentially mimicking the experience of a native app.”

Cross Site XMLHttpRequest Design —

Oh, nice. Here’s a high-level design document that describes the new cross-site XmlHttpRequest (their calling it, “XXX”) functionality and ties the other documents floating around out there together. It seems that servers will be able to signal that certain resources are accessible from other domains using HTTP headers or (gasp!) XML processing instructions (PIs). Weird.

Bug 389508 – Implement Cross-site XMLHttpRequest —

Just landed on mozilla trunk a few days ago. See the draft spec for specifics.

A Big Change for Open Source —

Bruce Perens on the recent JMRI/GPL ruling:

“For a decade there’d been questions: Are Open Source licenses enforceable at all? Are their terms, calling for a patent detente or disclosure of source code, legal? Are they contracts, which require agreement by all parties to be valid, or licenses, which are binding even if you don’t agree to then? What legal penalties can a Free Software developer employ: only token damages, or much more? The court’s ruling makes the answers to these clear. Did such weighty questions come up in cases involving IBM, Sun, HP, or Red Hat? No, this is the quirky world of Free Software: it was a court case about model trains.”

Tap Tap Tap —

Looks like Paul Hammond is in the process of resurrecting his blog.

Varnish 2.0 beta 2 released —

Lots of good stuff coming in Varnish 2.0. GC, regexp based purge, custom hash funcs, backend load balancing based on health or other metrics, and the thing I’m personally most interested: what looks like support for validation based caching.

SHA-1 Pseudocode —

Pseudocode for the SHA-1 algorithm. Pretty straight-forward for being so insanely useful.

HTML5 Validator —

Highly experimental HTML 5 validation service. More info and bookmarklets available on the about page.

How to usurp PHP’s place: an outline —

Aristotle Pagaltzis on eating PHP’s lunch: “It will have to be more than just a programming language, because PHP itself is really more than a programming language. It includes a crude web framework (an invocation model reminiscent of CGI, with extensions) plus a crude deployment solution (just make all the libraries part of the language and let the sysadmin worry about it – who in turn often defers to his operating system vendor). This is PHP’s way of taking the worse-is-better philosophy to dazzling new depths …”

I was having this conversation at work the other day and came away with the conclusion that even if something were to reach feature / ease of use parity with PHP today, it would be many years before it actually surpassed the language in real deployments. PHP is everywhere.

Documents Reveal Django Pony, Caught In Tail Of Lies —

Aha!

The C10K problem —

Dan Kegel: “You can buy a 1000MHz machine with 2 gigabytes of RAM and an 1000Mbit/sec Ethernet card for $1200 or so. Let’s see – at 20000 clients, that’s 50KHz, 100Kbytes, and 50Kbits/sec per client. It shouldn’t take any more horsepower than that to take four kilobytes from the disk and send them to the network once a second for each of twenty thousand clients. (That works out to $0.08 per client, by the way. Those $100/client licensing fees some operating systems charge are starting to look a little heavy!) So hardware is no longer the bottleneck. ”

Looks like this is from 2003 but is still pretty accurate as far as I can tell.

UNIX —

Talk about a religious attachment…

Django’s cache framework —

All frameworks should approach caching the way Django does. The core app/origin framework does no real caching but provides utility/helper methods for setting standard RFC 2616 cache related headers on the response easily and correctly. A completely separate set of caching goo (“middleware”) sits between your app and performs the actual caching based purely on the headers set by the origin. The benefit to this approach is that caching is totally independent from the app framework and can be swapped out for a true gateway (“reverse proxy”) cache at any time.

Effortless Thread Dump for Ruby: —

Dump the stack trace of all threads in a running ruby process by signaling with -QUIT. Requires patching the ruby interpreter, which sucks because I need it for a process running right now.

Shaper_pmp explains the importance of pedantry —

“It also becomes a good-natured game. Think of it like golf. In golf you’re trying to hit the ball into the hole in fewer strokes than your opponent. In Pedantry Golf you’re trying to be more correct than your opponent, by correcting edge-cases, mistakes or assumptions in the previous post or statement (see also: Perl Golf).”

Dangerous Gems —

Yep. Rubygems’s system of security is really very lax compared to any Linux distro or other system-level package management system I’ve come across. I think the bigger problem, though, is that there’s a cultural acceptance to running gem as root. You don’t really think before installing a gem, you just “sudo gem install FOO”. There’s an attack waiting to happen any time you’re using sudo out of convention like that.

tcpdump for Dummies —

Alexander Sandler’s get-up-and-running guide to the tcpdump packet sniffer.

Text Transcript of Chris's Ruby Hoedown '08 Keynote —

Chris Wanstrath: “Side projects are less masturbatory than reading RSS, often more useful than MobileMe, more educational than the comments on Reddit, and usually more fun than listening to keynotes.”

Video of Chris Wanstrath's Ruby Hoedown '08 Keynote —

I just totally love this kid. Chris explains the future and past of, uh, everything that matters, and gives good, solid, practical reasons for why contributing to free and open source software projects is something worth dedicating a large chunk of your time to.

Explaining REST to Damien Katz —

Dare Obasanjo is a machine.

REST in the front, RPC in the back —

Assaf Arkin: “There’s also some back-end processing going on, and I think that part is using DRb for now. But maybe the next update it will switch over to RMI or UNIX pipes or whatever. I don’t much care because the library does the talking, and besides, it’s only distributed in the sense that we have two pieces of code running with different PIDs. Not particularly important what’s happening on the wire, as long as it’s fast.”

REST as an engineering discipline —

Bill de hÓra knocks one out of the park: “I think sometimes that the problem people have with REST is that it’s so well-defined; it’s not witchcraft, it’s not a cargo cult. You can’t argue with it on a relativistic basis or apply clever rhetoric or continuously redefine what it means. An architectural style isn’t ‘good’ or ‘bad’ – you have to decide if it’s the right fit for your problem space and if not, you have to come up with a more appropriate one.”

Don't Fear the URLs —

Adam Wiggins on Sinatra’s blasphemous approach to controllers and routing. AKA: the thing that makes Sinatra my web layer of choice (well, that and throw :halt).

What's New in Edge Rails: Simpler Conditional Get Support —

Still too much work but it’s nice to see some support for conditional GET making its way into the framework.

Minimalism Revisited Theme —

Jonas Arnfred: “This theme is a sleek and simple minimalist design for wordpress made to bring the content forward, and everything else out of view. The theme is designed with a focus on typography and effective whitespace …”

Web Development for the iPhone —

“You can specify CSS based on viewport orientation which you determine via javascript and update the orient attribute of the body element. Target the browser with body[orient=‘landscape’] or body[orient=‘portrait’]”

git-sh(1) - A customized bash shell suitable for git work. —

I threw this together a few weeks ago and now I’m not sure how I lived without it now. I know you people have cool bash/git hacks sitting in your ~/.bashrc — hand them over.

Timeplot —

Very nice and functional JavaScript based timeplot library. Looks good, shows data-points on mouse over, approachable API. Good stuff.

There’s More Than One Way to Skin a… Dataset —

This is why I have a really weird fetish for graphs. It’s not the colors and shapes, it’s the fact that any data has an infinite set of potential visualizations and some are vastly better than others, depending on your needs.

Patterns of Web Architecture —

An all around great post from Bill de hÓra. Wow.

beyond rest —

joshua schachter on Rabble/Kellan’s “Beyond REST?” presentation, with an interestingly simple HTTP-based callback system.

Building Load Resilient Web Servers —

Great look at varnish and concerns around putting a front-end reverse proxy cache in place.

Life after Bug Tracking Systems —

Sam Ruby on how DVCS + mailing list has removed the need for bug tracking systems on some projects. I’m feeling a similar pull in my own work.

blog.txt —

A minimalist’s WordPress theme. Focus on typography and simple markup. Various configuration options and a print stylesheet.

[ANN] Bacon 1.0, a small RSpec clone —

Christian Neukirchen announces Bacon, a ground up reimplementation of test/spec + test/unit. (EDIT: this is not test/spec as I had previously reported. Sorry.)

refactormycode.com —

Awesome idea. Nice syntax highlighting. (Via Simon Willison)

Ruby's $LOADED_FEATURES (Array of stuff that's been required) —

Not sure how I’ve never stumbled on this before. You can remove items from the list to cause require to reload a file.

Ruby on Rails: scaling to 1 billion page views per month —

“Jim Meyer, manager of LED says that Rails scales like any other web application: ‘That is to say you need to take into account all the components from the moment the request is received at the load balancer all the way down and all the way back again.’”

Minimalism —

Hilarious! What Mark doesn’t know is that much of my “minimalist redesign” was ripped directly from what he’s had in place for 2-3 years; “administrative debris” was just a convenient alibi.

You should be on ruby-talk (the mailing list) —

Agreed. I’ve been a lurker for going on a year now. Solid mailing list.

RDiscount API Documentation —

An initial version of RDiscount’s API docs just published on rubyforge…

OO C is passable —

Yossi Kreinin: “But I miss virtual functions. I really do. I sincerely think that each and every notable feature C++ adds to C makes the language worse, with the single exception of virtual functions.”

Reia -- Python/Ruby hybrid language syntax; runs on the Erlang VM —

Good idea. Solve the “concurrency problem” for dynamic/scripting languages and the “language syntax problem” for Erlang, without sacrificing the benefits of either. Someone needs to keep an eye on this.

Ruby 1.8.7 Release Notes —

There’s way more new stuff in here than I thought. 20%-30% of ActiveSupport’s core extensions, Enumerator support everywhere, Object#instance_exec, byte vs. char stuff, documentation, and more…

Scott Chacon's Git Talk at RailsConf (slides) —

If you move the slides quickly, it feels a bit like playing Desktop Tower Defense.

Processes spawn faster than threads? —

Sometimes! Or, fork(2) is a very fast operation on legitimate operating systems. I didn’t realize it could be as fast as spawning a thread, though.

Bill de hÓra on Tim Bray on Twitter —

“… the fact that [Twitter has] a nifty error page is a bonus really.”

Git Commits That Need to be Pushed —

Justin French: alias push?='git cherry -v origin' — beautiful.

Gittr: cschneid's weblog —

cschneid has been helping me get the collection of hacks I’ve come to call a weblog into shape for some kind of release. He’s also been writing a lot of great Sinatra tips and tricks here. Check it out.

Announcing AJAX Libraries API: Speed up your Ajax apps with Google’s infrastructure —

Interesting. I’ve been using the jquery-1.2.3.js hosted on google code for a few months now. Maybe I should have read the TOS…

Hanna - A Better RDoc —

This is the template used to generate the HAML RDoc. It’s a massive improvement over the default template shipped with rdoc. I can almost stomach rdoc with this — almost.

HAML 2.0 Release Notes —

Support for HTML4/HTML5 output, more control over whitespace, option for implicit HTML encoding, and now faster than ERB.

Git Management KernelTrap Thread —

Interesting thread wherein Linus describes the need for various types of Git workflows for leaf developers vs. maintainers. Lot’s of talk about the pros and cons of rebasing in different situations.

peg-markdown —

An implementation of Markdown in portable ANSI C that’s roughly 28.5x faster than the canonical Perl implementation on a 179K test file. Looks like a complete implementation; includes smarty and footnote extensions.

Counting Characters in UTF-8 Strings Is Fast —

Aristotle Pagaltzis: “Not exactly as fast [as SBCS strlen], but if you write it in asm, it only takes one extra instruction to count characters in UTF-8 vs those in an 8-bit encoding, per character.”

Apache 3.0 (a tall tale), Roy Fielding —

Nice ApacheCon EU ‘08 presentation (warning: video + slides, no transcript) covering various blue sky stuff on Roy’s brain for Apache and HTTP.

Mozilla Firefox 3 RC1 —

And I was just starting to get used to the Minefield icon… I’ve been running the nightlies for about three months now and FF2 is really feeling a bit like legacy software.

HOWTO think about problems —

“You (and I) suck. Plan for it. Expect it. Get over it.”

Dynamically created methods in Ruby —

Ola Bini on def vs. define_method vs. eval for defining methods in Ruby. There really ought to be a simple way of getting stuff like this from blogs and into the standard Ruby doc.

REST: Reducing Effort in Script-based Testing —

Boo! Horrible name collision imminent. Is REST really that unknown or do they just not care?

Google Doctype —

What Mark Pilgrim has been working on at Google for the past year or so: an encyclopedia of web development.

My Git Workflow —

Oliver Steele details his (and others’s) Git workflow with a bunch of illustrative graphs, emphasizing one of my favorite aspects of Git: There’s More Than One Way To Do It.

An Under-Appreciated Fact: We Don't Know How We Program —

“… in every one of these processes and diagrams there is a box which basically says ‘write the code’, and ought to be subtitled ‘(and here a miracle occurs)’.”

Just add scaling! —

“I still haven’t found anyone who knows how you implement Scaling in a language, so I guess that LRM will never have it… Anyone who care to enlighten me, please send me a detailed email with an implementation of Scaling.”

"All I need is a Programmer" —

Ethan Vizitei with a great piece on people’s misconceptions about what coders do and the difficulty with which they do it.

Burning the midnight oil —

Ethan Vizitei on the difference in productivity found in the middle of the night vs. any other time of day. Nails it, IMO.

Git Magic —

All manners of good stuff here.

Say hello to the (GitHub) Network Graph Visualizer —

Now this is the kind of direction I hope to see GitHub and Gitorious go in the future.

Multiprocess versus Multithreaded ... or why Java infects Unix with the Windows mindset —

Erik Engbrecht: “Java took cheap Unix processes and made them expensive. To compensate, it provided primitives for multithreading.”

Clouds Rolling In: The Google App Engine Q&A —

Stephen O'Grady with the obligatory Q&A, which is excellent as always.

Interactive Google App Engine Python Shell —

The Python REPL running on Google’s infrastructure.

App Engine and Open Source —

Ian Bicking: “Many people are excited about how far up you might be able to scale something based on App Engine, but I’m excited about how far it could be scaled down.”

commit-patch —

A nice solution to “The Tangled Working Copy Problem” for VCS’s that don’t allow you to pluck out portions of a working copy to commit. Allows editing the diff that’s about to be committed.

Git HOWTO Index —

There are some great tips for owning your local workflow in here.

My initial reaction to Google App Engine (in Simon Willison's comments) —

I’ve since went to sleep and reawakened. I’m typically fairly curmudgeony when I wake up but I’m still having the same reaction.

The Differences Between Mercurial and Git —

I can’t say whether this is an accurate description of hg but he nails a lot of the things that makes git interesting, IMO.

Google App Engine —

Christmas in Python land! Run Python/WSGI code on Google’s infrastructure. This is an incredibly H U G E win for the Python web community and further validates WSGI’s architectural awesomeness.

My rules of thumb for developers: less code —

Rafe kicks off a series detailing various aspects of his coding philosophy. The first is near and dear to my heart: less code

Ruby’s not ready —

Matt Chisholm evaluates Ruby against Python for an upcoming project and determines that it’s a big pile of doodoo. I can’t agree with the conclusion but he details a lot of Ruby’s warts really quite well.

Jason Blevin's on Moving from Bazaar to Git —

I’m a bzr refugee in Git-land, myself.

What a DVCS gets you (maybe) —

Bill de hÓra gives some reasons for using a distributed VCS even when the downstream repo is non-distributed.

highlight.js —

JavaScript based source highlighter with support for many languages in separate modules. Similar to the JavaScript Prettifier in that <pre><code> blocks are automatically detected and highlighted without an explicit language class.

Maintainable Programmers —

This was a really great lesscode.org piece by Aristotle. The follow-up discussion in the comments was superb as well. Being in the middle of everything really warped my view of what was going on back then, I think.

Why PHP is good but bad —

Not sure how I missed linking to this. Pretty much mirrors my feelings on PHP to a T, except more thought out.

The immediacy of PHP —

David Heinemeier Hansson: “PHP scales down like no other package for the web and it deserves more credit for tackling that scope.”

Agreed!

What Is the Open Web and Why Is It Important? —

Brad Neuberg (Google Gears): “Our historical closeness to the web creates a kind of myopia, where we can’t see how amazing it is. It’s a billion Library of Alexandria’s dropped into our laps.”

Mistaking Cons for Pros —

chromatic on million-line Java programs: “I can only imagine how much larger the Java code would be without all of those XML files.”

On software architecture —

Roy Fielding on the difference between architecture, architecural styles, patterns, implementations, and applications.

Consistent Hashing —

Superbly explained and with extremely useful circly diagrams. Bravo.

Scientists fight to save the last Java gibbons —

I thought this was a computer programming related article … buh-zing!

Martian Mindsets —

Sam Ruby filling in for Mark Pilgrim (and featuring Mark Pilgrim in the comments) skewers Joel Spolsky over his “Martian Headsets” piece on the IE8 standards-mode dilemma. I use the word “skewered” in the nicest way possible, of course.

BashPitfalls —

Most of these are relevant to POSIX sh(1). This one gets me every time: echo <<EOF :)

The Common Lisp Directory finally crashed after 823 days —

“So the CLD lisp process uptime experiment is now over and I will move the CLD to a better place than a simple server in my basement.”

Why your Flash website sucks —

Spot on.

I Can Haz Hardcore Forking Action —

More praise for GitHub from a small team of Django hackers that built a site in three hours on one night with a little help from git…

Dion Almaer's Home Page —

This takes “the use of code in weblog titles” to a whole new level. Hilarious.

HyperText.m - source to TimBL's first implementation of hypertext (Sept. 25, 1990) —

From the comments: “HyperText is like Text, but includes links to and from other hypertexts.”

jQuery evangelism —

I need to give jQuery a serious look. Prototype’s Ajax.Request stuff is crippled (no PUT or DELETE) to the point of being worthless; the jQuery selector magic looks a lot more intriguing than what you get with Prototype, too.

New Blog Name - { |one, step, back| } —

Patch accepted!

css_color.vim - CSS color preview : vim online —

Makes the background of hexadecimal color codes the respective color. So, background-color:#f00 will have a red background in the vim editing window. Nifty.

The Ten Commandments of Unicode —

“I am Unicode, thy character set. Thou shalt have no other character sets before me.”

The Ruby Programming Language —

Yukihiro (Matz) Matsumoto, David Flanagan, _why the lucky stiff, David A. Black, Charles Oliver Nutter, and Shyouhei Urabe: that’s what I call a writing team. Wow.

Vimperator —

Make Firefox like Vim. No, like, insanely like Vim. Not just h,j,k,l mappings but everything. Looks like it’s been around for awhile. I’m not sure how I missed it.

Csh Programming Considered Harmful —

Uggghhh. I just spent 30 minutes hunting some arcane tcsh bug caused by coreutils dircolors. This is my revenge. I don’t even know I had any csh code running on this machine. It turns out that MacOS X’s /usr/bin/which is implemented in csh. Dumb.

bzr2git —

A quick script I threw together to convert simple bzr branches to git repos. Requires git, bzr, and rsync.

The recursive implementation of /bin/true —

This is why I love Unix.

GitHub: mongrel_proctitle GemPlugin —

I repackaged mongrel_proctitle as a GemPlugin so that all mongrels on use it automatically. This is the first chance I’ve had to play with GitHub, too. Lovin' it.

Process title support for Mongrel —

Constantly updates the the process title ($0) with something like: “mongrel_rails [10010/2/358]: handling 127.0.0.1: HEAD /feed/calendar/global/91/6de4”. Let’s you monitor backends with ps and top.

A Nice Big Purple Reddit Stack Trace —

reddit.com is running Pylons-0.9.6, Paste-1.4.2, Routes-1.7, Beaker-0.7.5 on FreeBSD 6.2-RELEASE (amd64). Wow. Nice environment.

This is where you send new features into the ghetto so that they can 'battle it out' ... —

“The last features standing get re-integrated into another branch known as the ‘trailer park’ to try to find a new life for themselves. Note that ghetto is frequently called ‘trunk’, and the trailer park something like ‘releng’”

GitHub: rtomayko's Profile —

Huge thanks to al3x for the invite. I’ll be writing up my experience over the next week or so.

GitHub —

Seriously interesting web based git browser and collaboration tool from the folks at Engine Yard. If anyone has a spare invite laying around, hook me up: rtomayko@gmail.com. I have a bunch of stuff sitting in bzr repos that I’d like to flip over to git.

Single file Rails Application —

A “Hello World” Rails webapp in fewer LOC than a Java console app that System.out.println(“Hello World”). The routes and controller DSLs look pretty interesting as well.

9 Practical Ways to Enhance your Web Development Using the Firefox Web Developer Extension —

From the comments: “the only things i find [useful] in Web Developer Extension is the shortcut to clear cache… for other things i use Firebug…” — Me too!

The Magic of Web Apps is HTTP, Not the Browser —

An epiphany everyone needs to experience.

assert{ 2.0 } —

Nice Ruby assertion library that’s block based. Shows block contents when the assertion fails. Much cleaner than Test::Unit assertions and without the retarded RSpec non-sense. This really ought to be rolled into the stdlib Test::Unit, IMO.

RubyForge: cameltoe-0.0.1-released —

“Cameltoe is a set of utility functions for making Ruby objects more like camel toes.” — You’ve piqued my interest :) It looks like this adds a String#cameltoeize method, amongst other things…

Git User's Manual —

Finally: “this manual is designed to be readable by someone with basic UNIX command-line skills, but no previous knowledge of git.”

valgrind and ruby —

Evan Weaver: “These leaks tend to grow slowly. Your Rails app definitely has this kind of leak, especially if it uses the ActiveRecord session store.”

Wanted: Git Cheat Sheet for Collaboration —

There’s some good questions here. I’ve been running into a few of the same issues while experimenting with moving some of my bzr projects to git. Can one of the git pros out there have a look?

PostgreSQL 8.3 Release Notes —

I’ve been watching the weekly changelogs and there were a ton of performance tweaks. The FreeBSD port landed today as well.

SwitchPipe - Process Manager and Proxy for Rapid Web App Deployment —

Peter Cooper scratches the deployment problem itch.

Mercury is a new, purely declarative logic programming language. —

What PrinceXML is coded in, apparently. It’s like Prolog for large systems: declarative, strongly typed and type inferencing, module system, closures, currying, lambdas, and with a strong determinism system. Compiles down to C (as a portable assembler).

Printing a Book with CSS: Boom! —

Bert Bos and Håkon Wium Lie show off some of Prince’s more advanced CSS and HTML features, including styling page size, generating headers/footers, advanced use of the CSS content attribute, page numbering, cross-references, and table of contents.

The Technology Rejection Curve —

Joe Gregorio: “This is what I call the ‘Scooby-Doo’ phase of the technology rejection curve, where the rubber mask has been ripped off and the crook yells as he’s dragged off by the cops […]”

Dear IE6, I hate you —

“There comes a time in every old browser’s life to pack up shop and, well, fuck off. This time has come and gone for IE6 …” Also: “42% of global users are still browsing the web with IE6.”

Numb3rs —

Bill de hÓra making all kinds of sense on the topic of Android, mobile platforms, the cloud, and other things.

How I lost my faith (in lisp) - comp.lang.lisp —

“Between 1988 and 1991 I worked on the research program that led to the Mars Pathfinder rover […] All three of [the prototypes] were programmed not in Lisp, but in little mini-languages whose compilers were written in Lisp.”

James Gosling Supports Closures in Java —

“Closures were left out of Java initially more because of time pressures than anything else. Closures, as a concept, are tried and true – well past the days of being PhD topics.”

Microsoft Boy Announces His School Homework —

“What is catching users' eyes? Legibility, correctness, conciseness…. the list goes on and on. Simply put, this history essay is a significant release for me – one that builds on all of the great things that I was able to deliver last year […]”

“The Bug Count Also Rises” by John Browne —

“Hernando who worked down the hall and who was large with microbrews came to him and told him that the ship day was upon them but the bugs were not yet out. The bugs which were always there even when you were in Cafes late at night sipping a …”

Interview with Steve Yegge on Rhino on Rails —

Dion Almaer sits down with Yegge to talk about his JavaScript/Rails port. Nice one-on-one video, candid, and thick in technical detail.

Hypermedia WTF! —

“… there’s a sub-constraint that goes by the unwieldly name of ‘Hypermedia as the engine of application state’, which is arguably the most important constraint of REST in the sense that it alone provides the bulk of the ‘shape’ of RESTful systems …”

Perl as a Web Scripting Language —

No, but seriously, the only reason we’re not all using Perl for web development is because all the problems are already solved … and have been since around 1995 or so. (See Also: mod_perl, libwww-perl, Fielding et al.)

The Speed-up Loop [thedailywtf.com] —

“Nothing – and I mean nothing – in IT takes less than 80 hours, and whatever you think it’ll actually take, multiply it by 20, and tell management that. You see, 80/20.”

What should Microsoft do instead? —

Holy crap, this is insane. Just let people run IE6 and IE7 as separate standalone browsers side-by-side with IE8. As James said in my previous post, they can even rebrand it as “Intranet Explorer” :)

Code Rush (A PBS Special on Netscape circa 1998) —

“Code Rush follows the people of Netscape Communications during an intense period in 1998, when it was all but certain that Microsoft had already won control of the Internet user’s desktop.”

put a proxy in front —

“… even if you have a single server, a proxy in front can help performance significantly. Through the simple expedient of buffering, your heavyweight processes don’t waste time serving every request for the entire length of time the client is connected”

Django People —

Simon Willison’s latest project makes it easy for people developing in Django to hook up and get laid (since they have so much free-time due to developing in Django).

Websphere CTO Jerry Cuomo on REST & Project Zero —

Whoa. I apparently haven’t spent nearly enough time looking into IBM’s Project Zero. It seems to come down to REST + (Groovy|PHP) and sneaking practical technologies in the front door with a “SOA” label on it. Interesting strategy.

On: “working alongside some of the better developers” —

Why RedMonk is succeeding where other analyst houses fail: “Other analyst firms primarily target sell-side or buy-side. We really don’t see the world that way. RedMonk’s core constituency is ‘make-side’: the makers and doers, hackers and players.”

Programs on the scale of a million lines of code are getting more common. But how big is that? —

“A million lines of code is not ten times more than 100,000. It’s well-known that schedules grow faster than the code … so the schedule for developing a million lines of code is 22 times bigger than for 100,000 LOC.”

The problem with pixels —

“… anybody who’s ever built out a relatively complex design using ems will agree that at some point they wondered if the benefit was really worth the effort.”

The Algorithm: Idiom of Modern Science —

“The Algorithm’s coming-of-age as the new language of science promises to be the most disruptive scientific development since quantum mechanics.”

Do we need WADL? —

Ka-pow!

MapReduce: A major step backwards —

Rut-roh. The RDBMS crowd is none too happy about the recent MapReduce talk. This article suggests they’ve solved all these problems a long time ago and that MapReduce is basically retarded. This discussion will get interesting over the next few weeks.

In Unix, what do some obscurely named commands stand for? —

Dennis Ritchie: “There was a facility that would execute a bunch of commands stored in a file; it was called runcom for ‘run commands’, and the file began to be called ‘a runcom’. rc in Unix is a fossil from that usage.”

How Software Companies Die —

Orson Scott Card: “You can domesticate programmers the way beekeepers tame bees. You can’t exactly communicate with them, but you can get them to swarm in one place and when they’re not looking, you can carry off the honey.”

Myth: RESTful Web Services Don't Need an Interface Definition Language —

Dare weighs in on the usefulness of description languages in REST-based design and seems to conclude that Uniform Interface != Description Language and that simple discovery ( style) is the appropriate comparison.

Sun acquires MySQL —

What?!

Lying Through Their Teeth: Easy vs. Simple —

Steve Vinoski compares IDL as used w/ CORBA/DCOM with WSDL as used by WS-*. It’s interesting that IDL served as more than just a description for machines. Humans used IDL as spec text and built services accordingly, just like REST :)

ArchitectNotes - Varnish —

“I have spent many years working on the FreeBSD kernel, and only rarely did I venture into userland programming, but when I had occation to do so, I invariably found that people programmed like it was still 1975.”

Reverse proxy roundup —

Bob Ippolito wrote up some pros and cons to reverse proxy implementations in different servers a few months back. I don’t think much of it is out of date at this point but nginx isn’t represented.

What PHP Deployment Gets Right —

Ian takes a look at some of the attributes of PHP’s deployment model, why they work so well (for PHP), and why other environments have such a hard time duplicating them.

Shared Hosting is a Ghetto —

“The constraints, the instability, and the unpredictability of a shared hosting environment are a big part of the reason why the web hosting business is moving towards virtualization everywhere you look. Big kids need their own sandboxes to play in.”

The End of an Era - 6.001 is dead —

Gerry Sussman is teaching this year’s 6.001 SICP class – the last time the class will be offered at MIT. It sounds like Scheme is being phased out of MIT’s CS program completely. What a sad day.

Working Productively in Bash’s vi Command Line Editing Mode (with Cheat Sheet) —

“I am going to introduce you to bash’s vi editing mode and give out a detailed cheat sheet with the default keyboard mappings for this mode.”

PostgreSQL 8.3 Cheat Sheet —

Wonderful PostgreSQL cheat sheet with PDF and HTML versions.

I need a woman who is willing to raise a child with me in the method of Unix —

“Other than the fact our child will be bright, text-based and sarcastic, we will otherwise be a normal family.”

DNA seen through the eyes of a coder —

“Like with unix, cells are not ‘spawned’ – they are forked. All cells started out from your ovum which has forked itself many times since. Both halves of the fork() are identical to begin with, but they may from then on decide to do different things.”

Why I chose git —

Wherein Aristotle convinces me to seriously consider moving my experimental bzr projects to git. I’ve seen the content vs. file tracking argument before but never really understood what the actual impact of this difference was.

depressing —

“maybe try coding something in c”

moz-snapshooter.rb —

Like khtml2png but using the gtkmozembed Ruby extension library (which I haven’t been able to build yet).

Prince XML: Generating High Quality PDFs from HTML + CSS —

Simple print typesetting using HTML/CSS. Targets the 80% of common print tasks w/ HTML/CSS. I’m going to be looking into mozilla’s cairo PDF output abilities within the next few weeks so it will be interesting to compare.

A RESTful version of Amazon's SimpleDB —

That’s much nicer. Amazon should adopt it immediately.

Bazaar goes 1.0! —

New, faster repo format and a bunch of other tweaks make in during the RC process.

Freedom 0 —

Ahh, those were the days… What’s left to fight for?

In software, some developers take up residence on planet architecture, an otherworldly place where software is eternally planned and discussed but never actually constructed. —

Atwood’s had a great year.

Postgres for the win! —

Yep. I can’t think of a single piece of technology that’s been less of a PITA than postgres. In fact, when I think about “solid software,” postgres is the first thing that comes to mind.

The solution is quite clear: each browser tab should have its own thread, in which a separate instance of a JavaScript interpreter executes... —

I had assumed that was already happening today. I really have to dig into the mozilla codebase someday… Seems like it would be worth it to get a better feel for browser internals – even if you weren’t planning hacking on the browser.

A Brief Introduction to REST —

Stefan Tilkov’s latest InfoQ article covers all the key concepts…

Google Chart API Developer's Guide —

I would use this ASAP if not for the privacy requirements around the data I’m charting. There’s really no good general purpose graphing libraries that use nice and simple vector shapes and styles.

Python —

“Whitespace?”

Run Internet Explorer 5/6/7 Natively in OS X —

This trumps Leopard for most important Mac development this year as far as I’m concerned. Words cannot explain the hatred I’ve developed for booting up multiple Parallels VMs to get at IE.

Depressurize the priorities —

“Most of the time you should be working on The Next Most Important Thing. But there are times when it’s okay to depart. Times when you need to depressurize after completing a dive in the stressful, complex pool of Big Problems.”

PEP 3117 -- Postfix type declarations —

“After careful considering, much soul-searching, gnashing of teeth and rending of garments, it has been decided to reject this PEP.”

The Two Types of Programmers —

From IMil in comments: “Shocking statement #(n+1): 80% of the 80% believe that they belong to [the] 20%.” A recursively shocking statement! i.e., (0..Infinity).inject (0.8) { |x,n| x * 0.8 }

What if powerful languages and idioms only work for small teams? —

“What if closures and meta-programming and expressive type systems and annotations and all of the other tools that give us the power to build powerful abstractions actually don’t scale to larger teams?”

Bourne Shell Server Pages —

“Installation is left as an exercise for the reader.”

GNUpdf —

“The goal of the GNU PDF project is to develop and provide a free, high-quality, complete and portable set of libraries and programs to manage the PDF file format, and associated technologies. ”

Changeset 8180 - Rails Trac - Trac —

“Ousted ActionWebService from Rails 2.0 ” :)

Resources and the Kimball —

Patrick’s right: even if you never build a DW related application, Kimball’s articles on dimensional database design are enlightening and applicable to a million other tasks. Reading Kimball, for me, was not unlike reading Paul Graham or Richard Gabriel.

macvim - Google Code —

Absolutely beautiful new Vim port for OS X – sane GUI tabs, multiple windows, client/server mode, fonts look great. Stop building Carbon Vim from source!

WS-* is to REST as Theory is to Practice —

Dare talks about his transition from WS-* to REST proponent. This mirrors a lot of people’s experience, including my own.

Sinatra : Classy web-development dressed in a DSL —

something to dig into during a 1 hour conference call or whatever …

RESTafarian SOA killers? —

“We (the RESTafarians) are not stubborn zealots. We’re just right. Sorry :–)”

The Nerd Handbook —

“Whereas everyone else is traipsing around picking dazzling fonts to describe their world, your nerd has carefully selected a monospace typeface, which he avidly uses to manipulate the world deftly via a command line interface …”

Bwana —

Manual page URL handler for Safari (e.g., “man:bash”, “man:sort” in URL box). References to other man pages are hyperlinked very nicely and the pages themselves are formatted quite nicely.

Technical Debt —

“… coined by Ward Cunningham to describe the obligation that a software organization incurs when it chooses a design or construction approach that’s expedient in the short term but that increases complexity and is more costly in the long term.”

How to tell if a web page sucks —

Beautifully executed.

Shipping Means Prioritizing —

“No important software for the Mac depends on Java.”

Ian Bicking: Prism —

“… if all you can think of is reasons why the web is stupid and awkward, and you think it’s some giant step backward (from what?), then you haven’t thought very deeply about what’s happened in the world of technology and why.”

Mr. Peabody Explains fork() —

Brilliant!

Programming - You're Doing It Completely Wrong —

I know! Seriously.

http://xkcd.com/327/ —

“Did you really name your son Robert'); DROP TABLE Students;—?”

The ESB Question —

This is a scary description of a small chunk of my tech career: “In a previous life, I helped develop ESBs. I’ve written about them and I’ve promoted them. But somewhere along the way, I lost the religion.”

Defanging the Multi-Core Werewolf —

“… where’s the harm in spawning another process? Let the two halves of the program communicate over some IPC mechanism. That model is well known, well tested, well-understood, widely deployed and has been shipping for decades.”

USING COLOR IN INFORMATION DISPLAY GRAPHICS —

Color theory for computer interface designers.

Why Programmers suck at Picking Colors —

“Let me repeat this because it’s very important: contrast is the basic building block of UI design.”

Software Is Hard —

“Talking about a software development schedule more than a year out is like talking about where we go after we die. Everyone has some idea where we’ll end up, but those ideas differ wildly, and there’s a lack of solid evidence to support any of them.”

Good Shell Coding Practices - Handling Command Line Arguments —

Very nice look at different methods (good and bad) for handling the command line in sh scripts.

The Rule of Least Power - W3C TAG Finding 23 February 2006 —

“There is an important tradeoff between the computational power of a language and the ability to determine what a program in that language is doing.”

Rails 2.0: Preview Release —

“… Rails has picked a side in the SOAP vs REST debate. Unless you absolutely have to use SOAP for integration purposes, we strongly discourage you from doing so. As a naturally extension of that, we’ve pulled ActionWebService from the default bundle.”

r2check.rb —

Checks pre-Rails 2.0 apps for compatibility.

What nine of the world’s largest websites are running on —

Linux, Apache, PHP, and memcached are the big winners. Nice to lighttpd represent.

Advanced Python (or Understanding Python) —

Thomas Wouters covers a ton of ground (quickly) on lots of Python’s interesting features. This may be the quickest way for newbies (or refugees) to come up to speed with the language.

sane_transactions.rb —

Brings ActiveRecord’s transactions toward sanity and adds savepoints. The methods added to Object must go! — transaction, commit!, and rollback! will clash with existing libraries. e.g., PDF::Writer and Transaction::Simple.

The Mythical Business Layer —

“It was as if its architects were given a perfectly good hammer and gleefully replied, ‘neat! With this hammer, we can build a tool that can pound in nails.’” — that is THE SINGLE FUNNIEST SENTENCE ever assembled in the history of english language!

Rails, the 15 minutes is Almost Up. Meet Erlang. —

“Every time some Rails fanboy starts peddling their hype, the approved thing to do is to respond with Erlang.” – Brilliant idea! That will bring some real substance to the argument.

Ola Bini on Java, Lisp, Ruby and AI: Rubinius is important —

“I’m getting more and more convinced that for the people that don’t need the things Java infrastructure can give you, Rubinius is the most important project around, in Ruby-land. More than that, Rubinius is MRI done right.”

Immature developer attitudes revealed in flames regarding CDBaby at Pervasive Code —

“What matters a lot more than choice of programming language is the ability to get the project done, meaning tested and correct and launched. Apparently for Derek, PHP is the way to get that done, and Rails ain’t.” — it really is that simple. Period.

7 reasons I switched back to PHP after 2 years on Rails —

“But at every step, it seemed our needs clashed with Rails’ preferences. (Like trying to turn a train into a boat. It’s do-able with a lot of glue. But it’s damn hard. And certainly makes you ask why you’re really doing this.)”

CSS 3: A Giant Serving Of FAIL —

“… CSS 3 is a joke. A sad, sick joke being perpetrated by people who clearly don’t build actual web apps…”

Sun’s Ruby strategy - Engage and Contain? —

“Maybe I’ll start to believe when they start promoting Ruby on Rails at JavaOne, as opposed to promoting JRuby on Rails at RailsConf.”

unix domain sockets vs. internet sockets —

Pretty much what you thought but with great detail :)

Ruby on Rails Security Guide —

Comprehensive look at common Rails security concerns with links out to in-depth articles.

The Rest of REST —

Slides from the presentation Roy will be giving in about an hour at RailsConf Europe.

A little REST and Relaxation —

How long has this been floating around? Roy Fielding on building the web… (via Aristotle Pagaltzis on rest-discuss)

Joe Gregorio | Projects [bitworking.org] —

Aww man, Joe’s real project list looks like my wish-i-was-hacking-on list.

Programming Can Ruin Your Life —

“You will avoid taking care of simple things because the solution is inelegant or simply feels wrong. Time to think will no doubt yield a better result, you’ll say.” Aye!

Twitter API Traffic is 10x Twitter’s Site —

Do not try to measure APIs vs site traffic… that’s impossible. Instead, only try to realize the truth… There is no APIs.

Less is more for Ruby on Rails, inventor says —

“We’re not trying to bend Ruby on Rails to fit the enterprise, we’re encouraging enterprises to bend to Ruby on Rails,” he said. “Come if you like it, stay away if you don’t.”

Go away Ruby [bill.burkecentral.com] —

Bill Burke is an idiot. Wow. And then, after being an idiot, he actually calls someone “gay” in the comments when they dare suggest that Ruby is a strongly typed language. Huh? I thought Red Hat had better taste.

Java Native Access + JRuby = True POSIX [headius.blogspot.com] —

Java becomes 100% more viable. So simple — why didn’t someone do this in the very beginning?

Hiring Programmers and The High Cost of Low Quality —

“There’s no one programmer who does the work of ten other programmers. One uber-programmer does just as much work as one ordinary programmer. It’s just that the results solve ten times as many problems.”

David Heinemeier Hansson says No to Use of Rails Logo —

I must say, I’m a bit bummed that we’re having this conversation at all.

Bug 332174 – Drop SOAP support [bugzilla.mozilla.org] —

RESOLVED FIXED

Java's Overton Window [blog.case.edu] —

Oh, wow. Have we come that far, then?

A look back: Bram Cohen vs Linus Torvalds [wincent.com] —

“…. But after closely studying Git I’m a little bit awestruck; Torvalds is a frickin' genius, a true visionary, and somehow managed to just "get it” and instantly, in a flash of insight, come up with “the solution” for version control."

Bill de hÓra: Design for the web —

“… on Java, too many web frameworks – think JSF, or Struts 1.x – consider the Web something you work around using software patterns. The goal is get off the web, and back into middleware…”

Understanding Engineers: Feasibility [fishbowl.pastiche.org] —

Programmer definitions of impossible, unfeasible, trivial, non-trivial, hard, very hard, and distinctly non-trivial.

SSH for iPhone —

You had me at “SSH”.

Words to Live By —

“Always code as if the person who will maintain your code is a maniac serial killer that knows where you live.”

Philosophy of numbers —

“So there you have it — lack of units in programming languages and the war in Iraq have a common cause: the lack of correct philosophy on numbers taught in schools.”

JRuby 1.0 Released! [headius.blogspot.com] —

Rock on.

Ruby Unroller: A Ruby script execution tracer [rubyinside.com] —

Nice. This is going to save me some serious time.

HTML Entity Character Lookup —

Oh wow. I’ve been trying to find a single page that has every unicode character on it with its hex counterpart but this is pretty fantastic.

Evolution of a Python programmer —

“Web designer” is dead on :)

Relevance: Silverlight, the DLR, and thee —

“The general thrust of this argument is that having a full-fledge rich-windowing experience in the browser is going to put a stop to all that amateurish mucking around with JavaScript and the DOM. … that’s hogwash.”

Charles Nutter - Big Plans [headius.blogspot.com] —

“And yes, I’ve seen the Microsoft news … If Sun did something like this I’d resign.”

HTTPanties [thinkgeek.com] —

“413 Requested Entity Too Large”

Does JavaFX Spell The End Of AJAX? —

Is anyone actually falling for this crap? “‘The goal is to make it so people never have to see code’, said Gosling.” — Gag Me!

A Chat with Aaron Swartz —

Q: Are you working for Reddit as full-time programmer? A: No, I left reddit several months ago. Q: Why did you leave? A: My boss asked me to.

Silverlight trumps Web Standards (and Flex)… —

“As for me, I’ll take some more Microsoft kool-aid, please.” — I said almost exactly those same words in 1997 regarding Microsoft’s OS/Browser integration (I’m quoted in an article on C|Net as proof). There’s nothing I regret saying more.

A New Way to look at Networking —

PARC’s Van Jacobson (traceroute(8), tcpdump(1)) on, well, everything that matters. Hands down best talk I’ve seen in years. I’m going to watch it again tomorrow.

Fielding’s Dissertation [docunext.com] —

Section by section interpretation and notes on Fielding’s Disseration on REST.

Did Microsoft just patent sudo? —

What’s next? which(1)?

Silly season [diveintomark.org] —

“Sigh. I used to have the strength to argue against such foolishness. Nowadays I’m reduced to nothing more than Grey’s-Anatomy-esque catchphrases. Seriously? Seriously? Do I really have to explain why this is a bad idea?”

Squid is My Service Bus [mnot.net] —

Bingo!

Coprolitic Programming [thecodist.com] —

‘The next time you think to sigh, “this code is such a pile of crap” imagine what your grandchildren will say some day when they work on it.’

Comment j'ai expliqué REST à ma femme [pompage.net] —

“How I explained REST to my wife” in French!

Rake CHANGES —

Rake ChangeLog

Running Ruby in the browser via script type="text/ruby" —

I no longer think applet support should be dropped from all major browsers. I’ve got links for anyone who produces a Jython version.

Type Inference: Another Bad Idea for Java 7 [cafe.elharo.com] —

“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 that’s built around the opposite. It makes Java look weakly typed, but it isn’t

Translation From PR-Speak to English of Selected Portions of Rails Developer David Heinemeier Hansson’s Response to Alex Payne’s Interview [dive into mark] —

Pppkkkeeeewwwww.. The happy universe explodes. This is turning into one hell of a discussion.

The Truth About Lisp —

“Paul Graham originally wrote reddit, in lisp, on the back of a napkin while he was waiting for a coffee. it was so powerful that it had to be rewritten in python just so that ordinary computers could understand it.”

Koranteng's Toli: Crawl Before You Walk —

On JSF: “Waiting 5 years before you adopt the native architecture of the web is almost inexcusable. The web won’t (and didn’t) wait that long.”

YAGNI Considered Depressing —

“I actually think YAGNI and Othello’s waiting moves embody the same concept. Both are brilliant, winning strategies. Yet, there’s a certain emotional side to YAGNI and software development. We tend to get attached to our good ideas.”

sneer.org: teapot << 'tempest' —

The entire Twitter Scaling Problems conversation in one place.

Sam Ruby: Genshi Filters for Venus —

“In the remaining four templates, the translation from XSLT to Genshi markup is straightforward. And generally, the Genshi markup is both more compact and more powerful.”

Lecture 7b: Metacircular Evaluator, Part 2 - Google Video —

“I consider being able to return a procedural value, and to have first class procedures in general, as being essential to doing very good modular programming.” — Gerald Sussman (PS: how come nobody told me you can link to specific time offsets in google

Ruby: intern.h Source File —

jackpot.

Invasion Of The Dynamic Language Weenies [hacknot.info] —

Wow. Pretty solid anti dynamic language advocacy piece. It’s been a while since I’ve written anything longish so maybe I’ll try to put together something of response to this.

have u seen an idea even billGates shouldn't hear Mr.Guido ? please read because it's important. —

“also it could be disguised as a cancer research stuff should some disassamble its code. the use-free-computer-time type of thing they do on the net.”

Q&A: James Gosling, 'father of Java' —

Wow. I’m nodding yesly to almost everything said by Gosling in this article. Weird. Here’s a good one: “The number one biggest threat to enterprises is the inherent fallibility and laziness of humans.”

mjt —

Browser-side JavaScript template engine with concepts borrowed from Kid. Used by Freebase to drive formatting around JSON. Looks interesting.

Block Helpers and DRY Views in Rails —

I’ve been using this technique for some time with great success. Oh, and this site’s design is bordering on perfection.

README.EXT —

“This document explains how to make extension libraries for Ruby.”

getting dirty with rubyinline [evanweaver.com]

A Faster Ruby. —

“Well if Ruby developers are so damn productive, why can’t they write a faster ruby?”

ROA Maturity Model —

How did we ever get anything done without superfluous quadrants and models. Bring ‘em on. The trick is making something every developer would know is a joke but that could make it past a manager or architect.

Agile Enterprise Architecture: Why I Can't Take Smalltalk Seriously —

These people are still around? Amazing. Ooohhh, “tens of thousands of simultaneous users” — scary! scary!

ruby-pg: Project Info [rubyforge.org] —

Matz’s ruby-postgres library has finally been forked.

PUT is not UPDATE [cafe.elharo.com] —

Hence the multiple disclaimers in the article, such as, “I hesitated to include this table. … What I don’t want to happen is that you start thinking of web resources as SQL tables. Don’t do that.”

7 Habits For Effective Text Editing 2.0 [video.google.com] —

Recent presentation by Mr. Bram Moolenaar on how to be a bad-ass with Vim.

XRuby Already Faster Than Ruby 1.8.5? —

“… the results for YARV/Rite are still streets ahead in terms of raw performance, and where I’m placing my bets for the next de facto Ruby interpreter.”

Planet PostgreSQL —

How long has this been here?

Improve this Script and Win $100USD —

exec 3<> /dev/tcp/$HOST/80 What?! How cool is that.

Google gtags version 1.0 —

Best idea ever. EVER!

Why You Need a Degree to Work For BigCo [raganwald.com] —

:)

Define - /etc? —

“et see” :)

REST Issues, Real and Imagined [mnot.net]

getopt and getopts —

A complete look at the little used utilities for processing arguments in scripts.

Less sucky multiple-select lists —

Another interesting take on multi-select lists that uses checkboxes with labels and colors.

Multi-Select Lists vs. Checkboxes —

I’m real close to hating multi-select list boxes right now. Using an overflowed UL of checkboxes has some interesting pros (and cons).

The BileBlog: Good riddance, Marc Fleury. —

“What Fleury contributed to the world of Java is a personality; love him or hate him, the man certainly deserved to be hated.”

int getRandomNumber() [xkcd.com] —

// guaranteed to be randon :)

Knowledge Acquisition —

John Panzer: “Software development is a knowledge acquisition activity, not a manufacturing activity.”

Please drop SVN —

Oh wow. The concept of logical patches is something I never considered before. Darcs has a “record” command that let’s you split multiple changes to a single file (or files I assume) into logical changes (“hunks”).

Web Developers: 13 Command Line Tricks You Might Not Know —

Anyone who doesn’t know every single one of these probably hasn’t been developing for the web very long. Probably a useful crash course for newbies making their way over from FrontPage or ASP.net though.

The window.onload problem (still) [peter.michaux.ca] —

Nugget of wisdom: “… developing for the web is frequently about accepting small compromises to big philosophical ideals.”

Gyre - The open source, web-based IDE and debugger for Rails —

Interesting concept. I’ll have to check this out once it comes out of “pre-pre-pre alpha” (which doesn’t really make sense, btw. There’s nothing more alpha than alpha).

More Thoughts on The Renaissance, Agile and developers —

“I tell you one thing for sure: Far more developers understand the business they work in than business people understand the technology that drives them forward.”

Why do we still use C? [dadhacker.com] —

“Maybe if we took away these PL theorists’ Emacs and LaTeX packages for a while we’d get better results.”

Aristotle Pagaltzis takes both sides of the XML 2.0 debate -- my feelings exactly —

“There are cases where you really do want that. There are cases when you don’t. There are cases where it’s half this, half that; cases, say, where you only want charset sniffing. There are cases where you want a pony. Not every document has the same g

Implement getElementsByClassName [bugzilla.mozilla.org] —

Awesome. Robert Sayre just checked in his document.getElementsByClassName implementation to mozilla trunk.

The End is Nigh: Help Squash Rails Bugs —

The JRuby guys are real close to 100% passing Rails' unit tests. I think I’m going to sign up for PostgreSQL testing/hacking. What are you doing?

Mr. Gosling - why did you make URL equals suck?!? —

Wow. Much worse than I thought.

3 pillars [dehora.net] —

“the version control system is a first order effect on software, along with two others – the build system and the bugtracker. Those choices impact absolutely everything else. Things like IDEs, by comparison, don’t matter at all.”

What's New in Prototype 1.5? [xml.com] —

Nice review of new features.

Greg the Architect - SOA This. SOA That. —

“Buhdooy!”

In Which I Think About Java Again, But Only For A Moment —

“… but I gave up after optimizing AWT, implementing drag and drop, and trying to make 1,200 pages of crappy APIs do the right thing on the Mac. Then I took a one-week Cocoa training course, and wrote the first prototype of iChat.”

subtlety : a remote subversion excursion —

Put in a subversion URL and get back an RSS feed for tracking changes.

Prototype Javascript Framework —

Documentation, finally!

Ruby book sales growth plummets again [bitworking.org] —

That’s sales growth not sales.

Access localhost via name from Parallels Desktop [macosxhonts.com] —

This is another thing that’s been driving me crazy for a while now. I’m going to try the bonjour technique mentioned in the comments.

Proposing URI Templates for WebForms 2.0 [whatwg.org] —

Oh, hell yes:

Web APIs Are Just Web Sites —

Well done.

Bill de hÓra: Mercurial, Part I —

Nice look at one of the better distributed version control clients picking up mindshare.

Microsoft exec called software developers 'pawns' —

“I mean, all through this presentation previously, I talked about how you’re using the pawns and you’re going to screw them if they don’t do what you want, and dah-dah-dah. You can’t let them feel like that.” and “So you can’t let them feel like pawns, no

What Mongrel Isn't (Or, Write Your Own Damn Web Server) —

“All you have to do is change the internal processing, add 200 more methods to the HTTP parser, serve Bittorrent over Ethernet, and have it save Korean orphans while eating a Mango in the back seat of an El Camino driven by twenty midget clowns.”

WSDL - Why Services Don't Launch [addsimplicity.com] —

Oh snap!

CASEBUILDER™ SOA —

This is too funny: “… provides you with the verbiage you need to explain SOA to non-technical people and ‘sell’ its long-term strategic benefits.”

demoroniser - correct moronic and gratuitously incompatible Microsoft HTML —

“The demoroniser keeps you from looking dumber than a bag of dirt when your Web page is viewed by a user on a non-Microsoft platform.”

Is anything ready for the enterprise? —

“I would rather take an easily modifiable, open platform that I can make do what I need in a specific environment.”

Software Development: Simplicity tops the agenda [infoworld.com] —

We won on my birthday :)

The perils of avoiding heresy (or "What are Design Patterns") —

In fact rather than being subtitled “Elements of Reusable Object-Oriented Software”, it should have been “21 reasons C++ sucks; 1 embarassment; and an Abstract Syntax Tree”.

ngrep - network grep —

“strives to provide most of GNU grep’s common features, applying them to the network layer. ngrep is a pcap-aware tool that will allow you to specify extended regular or hexadecimal expressions”

Law of Demeter —

Follow it.

Where were you on Saturday, November 9, 2002? —

Crazy.

IEs4Linux —

Whose going to get this running on OS X? I guess it doesn’t really matter. I can always X over to a Linux box…

Maruku: a Markdown interpreter written in Ruby —

This looks promising: handles all of Markdown proper plus various extensions.

Programmer Hierarchy —

Ranks programmers by who they consider themselves superior to. Comedy.

Why do so many reddit users hate java? (reddit.com) —

“Java’s solution to the problem of C++ allowing you to blow your foot off was to chop off your legs.”

InfoQ: Interview: Pete Lacey Criticizes Web Services —

Wow, I’m flattered blush Turns out I do know something about SOA after all. Speaking of “Motherhood and Apple Pie” – I quite liked that essay but it was one of those that never really took off.

Dynamic Language Support on the JVM —

Danny Coward Q/A on invokedynamic and “hot swapping” (method replacement). Pretty good piece until the end where we enter into some scary Java-static-typing-is-good-because-it-let’s-you-publish-APIs non-sense.

The Problem of Open Source in the Microsoft World —

I’m sorry but it is just baffling to me how developers and cough evangelists can put up with this kind of behavior as being the sort-of default mode of operation at MS. The company needs to consider massive sweeping changes in the way they treat develop

Socio-political and Commercial Motivations for WS-* —

Nice bit of history showing the chain of events that led to WS-*.

Firebug 1.0 Beta Screencast —

Holy… This is big. Huge big.

KISS (or why MS CS students have a bad time in interviews ...) —

“Yet for some strange reason, the MScCS students seem to value fancy algorithms over working algorithms.”

Web Pages That Suck presents the biggest web design mistakes in 2004 learn usability and good Web design by looking at bad Web design —

A perfect article.

10 Reasons Why Django kicks Ruby on Rails’ collective ass. —

Wherein the author lists 8 reasons (maybe 3 of which are approaching objective or even valid) and also spells Adrian’s name wrong: “Adrian Zolovaty”. Ruby/Python flame-bait is exactly what we need.

PostgreSQL 8.2 Release Notes —

We moved from Windows / MS SQL Server to FreeBSD / PostgreSQL about 5 months ago and I’ve been nothing but completely happy with the transition. 8.2 is a pretty nice upgrade if you’re doing data warehousing style stuff.

Stefan Tilkov on SOA —

Extremely clear and right take on REST, WS, and other techniques for distributing systems.

Programming Languages are like Women —

This guy gets around…

Shut the fuck up and write some code??? —

I have no idea … but I’m digging the Kid and TG references ;)

Ruby for the Web! (irb running in an applet via JRuby) —

I take back everything bad I’ve ever said about Java Applets ;)

? will save us, or, Applicative trumps imperative in the large —

Aristotle just destroys that recent reg article that suggests we need to shit-can 20 years of engineering masterpiece for distributed objects. Nice piece!

tech decentral » a RedMonk blog about web technology by Anne Zelenka —

Go RedMonk. This is a major pick-up, IMO.

CSS-Based Forms: Modern Solutions —

Big list of resources on CSS based forms.

J2EE SUCKS HUGE DONKEY BALLS. —

“Then they spend one day debugging shit that’s gone wrong with Eclipse (or its mangling of the CVS repository, or some ant dependency problem, or)… And meanwhile they whine that 256 megs of RAM isn’t enough to edit a fucking text file (and do NOTHING el

Blogging: Bad for coding —

and vice versa.

Incongruent State —

More good stuff from Chalain. This time the topic is classes that end in “er”.

Complexity vs. Complication —

A nice go at classifying different types of code transition.

Free software is a weak mode of production | Free Software Magazine —

“The success of GNU/Linux and other free software projects is annoying.”

Tomayko - Google Code Search —

Ego surfing on code.google.com :)

gotAPI.com —

The best attempt I’ve seen at splicing multiple API references together. This uses the external documentation but provides indexing and browsing features.

Shell script awk csv file —

“I could whip you up something in Java that would take 2 minutes to design, 30 minutes to implement, a day to write the deployment descriptor for, and 3 months to get sign off from the app support people at the client site _b”

E.W. Dijkstra Archive: On the cruelty of really teaching computing science —

Dijkstra’s writing style is so perfect.

But Martin, Enterprise Software IS Boring —

A well thought out and respectful response to Fowler’s argument that business software doesn’t have to be boring (RailsConf 2006). Good points abound but I have to disagree with the premise.

Lisp is Not an Acceptable Lisp —

So I’m considering automating my del.icio.us to just automatically add links with “statistically infrequent” words as tags to all Steve Yegge’s posts…

How to pull an all-nighter —

Fairly acurate prescription…

It's Not Software —

I have no idea how I missed this. Great Yegge piece from October 2004.

Coding Tool Is a Text Adventure —

But instead of ducking grues and collecting zorkmids, you’re interacting with whatever program code you’re working on, as well as the data and hardware devices that it uses. “It treats the web and APIs as just more objects and places, and is a platform fo

Tour de Babel —

the best shit ever

Getting started with extension development - MozillaZine Knowledge Base —

dangerous waters…

Rails RJS Templates —

I’m starting to “get it” now… Makes a ton of sense.

A Block Costume —

why on rebinding blocks to specific objects.. I had to do the same thing a little while ago. Using instance_method seemed like a hack but if it’s good enough for why, it’s good enough for me.

What (will be) new in Rails 1.1 —

I’m going to have to jump all over this.

/atom-tools/README —

Decent looking ruby library that implements a fair bit of an Atom Publishing Protocol client.

Yak Shaving —

I do this all the time…

Everything Your Professor Failed to Tell You About Functional Programming —

“This leads to my point: In computer science, nothing [still] makes sense [even] if you violate the identity principle.” :)

Which Part of "No XML" Don't You Understand? —

Ouch!

Bill Burcham’s memeRocket —

Go Bill! ‘Bout time you got a blog.

Quotations for Learning Programming —

“I have enjoyed reading (and writing), collecting, and pondering the following quotations, which I think are all relevant to teaching and learning programming.”