Platte daddy

Removing hard-coded cookies from ExpressionEngine

2011-12-07T11:15:00.000-05:00

A client is using ExpressionEngine 2 as just a CMS and not using its membership features, and we're doing everything we can to improve performance, both back-end and front-end.

On the front-end side, the cookie setting takes up some of the precious bytes that get transferred before the browser can start downloading assets.

I have turned off everything I can turn off that adds cookies to ExpressionEngine's output, but there were still two cookies hard-coded into the output even for logged-off users: exp_tracker and exp_last_activity.

The code that does this is in expressionengine/libraries/Session.php:

$this->EE->functions->set_cookie('tracker', serialize($tracker), '0');
$this->EE->functions->set_cookie('last_activity', $this->EE->localize->now, $expire);

This was a bit tricky to find, and I didn't see answers on Google, so there it is for posterity.

Note that EllisLab staff says making this change "can affect your ability to upgrade, and your ability to receive support." They also point out that you would need to re-apply such changes after an upgrade.

Web performance

2011-10-05T09:51:00.001-04:00

Several of my clients have asked me to do performance tuning for their websites. I find it fascinating work, and rewarding to deliver improvements that help machines serve humans rather than the other way around.

I'll try to post nuggets of value as I come across them, regardless of whether they seem basic or advanced to me.

A great one to start with this first day is WebPagetest. It loads a page with an empty cache, then a filled cache in one of many browsers and produces amazingly detailed reports.

I have been doing a lot of tuning on one of my clients' sites, but mostly through my own Mac Chrome on a pretty fast connection. I had WebPagetest run the site on IE8 on a slower connection and got quite an education.

OO programming in JavaScript, neatly summarized

2010-04-12T08:56:00.002-04:00

This article from Douglas Crockford outlines the basics and feel of programming with objects in JavaScript very succinctly.

On Documents vs. Streams, by Bryce Harrington

2010-04-07T10:13:00.002-04:00

This article was written by Bryce Harrington, and gave me a fresh perspective on interfaces when it was published and discussed on InfoQ. It's currently available only through Google's cache, so I'm republishing it here to preserve it.

The other day I was trying to figure out what was making my desktop computer run so slow. This was pretty unusual on Linux. Way back when I used to use Windows, I'd encounter such things due to running too many programs, so of course I looked at what was running.

But these days I don't really run that many intensive applications. I hardly ever use spreadsheets, presentation tools, word processors, or so on like I used to. Really the only things visible in my task bar were Firefox and Terminal. Killing off Firefox made no difference. And even more oddly, rebooting had no effect - within minutes my load average was up in the 20-30's.

Of course, the culprit was that I had a bunch of automatic cron jobs scheduled to occur at the same time. Reordering the timings got the system back on track.

But this led to an epiphany moment.

This was my *desktop* machine. The last time I'd seen this cron job I/O blocking madness was on servers. What was I doing with so many cron jobs on a *desktop*??

I looked at the individual cron jobs, and found that each and every one of them had something to do with my job. Disabling any one of them would reduce my work productivity. I could no longer do without one of these silly cron jobs than I could have done without Microsoft Excel a decade ago.

And then, as I looked around my desktop at the other things running on it - internet radio, IRC chat, mutt - that I noticed that I hardly ever use traditional "document-centric" applications. Everything running had something to do with dealing with _streams_ of information.

The realization sank in at that point, that our computer UI paradigm really stinks for what we actually use our computers for.

The prevailing UI paradigm today is built around the notion of document authoring. It expects that the main thing you do is create spreadsheets, word documents, presentations, and so on. There is a task bar to remind you of what documents you're editing, there is cross-application cut and paste so you can put pieces of one document into another. You can place documents on your desktop surface itself, so you can organize your work. You can define which applications to use for which types of docs. You can set up a default printer to put your documents to hard copy. You can set up system-wide fonts to use in documents. You can put icons to apps and even documents onto your panel. And on and on.

Occasionally, some of that is actually useful to me. But most of the time, for most of the work I do, it's all irrelevant. To pick one example, I used absolutely none of that in order to write this blog post.

Really, what I mostly do today is stream management. And I suspect this is true for the vast majority of people. I don't deal with writing documents, but with changes to documents. I put comments onto things. I slap patches onto things. I tweak the states of things. Once in a rare while I may author a completely new thingee, but even there I usually end up working with it as a stream of changes that I build up over time (and usually in collaboration with a few other people who stream changes to me).

Thinking about user interfaces this way, it occurs to me that there are a LOT of different kinds of streams. Streams of emails. Streams of spam to take *out* of my email stream. Streaming radio broadcasts. Streams of bug reports. Streams of software updates to apply. Streams of chatter on IRC. Streams of youtube video URL's from friends and family to check out. Streams of updates to my weather applet. Even my todo list is more like a stream of things coming in and going out, than like a static document I can print and save and be done with.

Each one of those silly cron jobs bogging down my computer were critically important for me, because THEY were the tools I used for helping me stay atop all these streams. They summarized my bug streams in various ways. They filtered my email streams into more organized sub-streams. They flagged tasks (and took care of certain tasks for me). They took care of updating the tools I used day to day.

It's weird that for all the document tools at my fingertips, it's a stodgy old *server* tool that is helps my productivity the most. I wonder how non-technical people not knowledgeable about crontab and scripting deal with such things?

This all got me to a key question... Since the purpose of our desktop UI is to make our work easier and more efficient, then if today's knowledge workers are, like me, more stream-oriented than document-oriented, then doesn't it stand to reason that we ought to re-think our UI design to optimize it for making stream management easier and more efficient? How would such optimization be done? How would such a UI look and feel? What kinds of toolkits would be needed?

Merlin Mann's How to Succeed in Business

2009-03-31T13:56:00.002-04:00

From John Gruber and Merlin Mann’s talk on making money by being authentically enthusiastic:

Give away more stuff than you think you should, and make it easy for people to get.
Focus on diverse secondary revenue streams, and always have your eyes open for new and replacement ones.
Don’t do stuff that seems profitable, but potentially messes up the reason people like you.

should be || should_not be

2009-03-20T12:15:00.002-04:00

Stephen Eley has done something very clever on the rSpec list, it begins thus:

should be || should_not be: that is the expectation:
Whether 'tis nobler in the parser to interpret
The outputs and side effects of outrageous duck typing,
Or to inherit against a sea of matchers
And by declaration extend them?

And on from there, to a satisfying conclusion.

javascript_named_routes

2009-03-20T10:18:00.002-04:00

Fred Polgardy has just released a tasty bit of code that will allow JavaScript to access Rails named routes in a very straightforward way.

Check out his javascript_named_routes Rails plugin.

How much process, and why?

2008-12-10T14:05:00.002-05:00

The best write-up in my memory of how agile processes fit into projects hackers build.

Don't steal from me, Senator Obama

2008-09-25T11:27:00.002-04:00

I signed a petition asking my legislators not to approve a bailout. I got a response from Senator Obama similar to the one quoted elsewhere.

Dear Senator Obama:

I contacted you earlier writing against the bailout, and received your reply.

Given your commitment to a bailout, I'm glad you're looking for ways to improve matters. But you are planning to remove thousands of dollars from my pocket, either as taxes or as devaluation of the dollar, to pay for mistakes made by private citizens.

You do not have my consent to do this. It is stealing from me.

Merely waving your hands and saying "liquidity" and "worsening downturn" is not enough explanation for why you're planning to take money from me. You owe us better than that.

Furthermore, you point to a need to rescue the economy. Have you considered the effects of inflation on the economy? Talking about bailing out mortgages without any discussion of the inflation this will create makes it look like you are only interested in protecting the rich. I'm sure you don't want that.

Another topic that isn't being discussed: is it the right answer to go on creating a socialist regime in the US? Buying up companies and personal loans? This isn't the America I grew up in. It sounds more like China. Are you for or against this approach?

The closest you came to answering my call to vote against a bailout plan was "I agree that urgent and decisive action is necessary during this time of economic turmoil". Please come back with a better answer for your actions than that.

Eating well, or, please hold the sugar

2008-09-16T11:40:00.003-04:00

Two members of our family were suffering new tooth-decay problems, and my wife Nicole had been reading about a dentist who researched the profound difference in health between people following traditional diets versus Western diets.

Nicole decided to take the plunge and learn how to feed us a traditional diet. We have removed refined flour and sugar from our diet, and added lots of whole, organic, delicious vegetables, milk products (unpasteurized, like God—and Louis Pasteur!—intended), honey, and meat. There are lots of changes she's making as she learns, which I'll also share over time, but she's posting interesting articles on her traditional-food blog.

This is incredible food, and our health is improving dramatically as we restore the levels of nutrition available to our bodies from the red zone to which modern Americans are accustomed, into normal ranges so our bodies have something to work with. Dental health, skin health, energy, mental function, sleep patterns, emotional health, you name it...every one of us is doing well and still improving rapidly.

I was generously offered some chai at work this morning. I took a few ounces. It was delicious, but I noticed an immediate and all-too-familiar feeling of weakening. I used to regard this as normal, but now I realize that I would feel this whenever I ate or drank anything with refined flour or sugar. As long as I stay clear of sugar and flour, I don't crave it, and this kind of experience is quite the reinforcement of my desire to stay away.

So my diet is very different now. This may sound inconvenient, and sometimes it is. But don't cry for me—I'm eating delicious homemade butter, homemade ice cream (sweetened with dehydrated cane juice and/or honey), rich Indian dishes...

Pasteurization was developed for wine. On hearing that pasteurization was to be used on milk, Pasteur is reported to have said, "What are they doing to my wonderful food?"

Back to article

Images: thrashing vs. process

2008-09-15T19:22:00.005-04:00

Steve McConnell illustrated an article about software process with these images. I'm interested in this effort—what is a success, and what could be improved?

How much to spend on security

2008-09-15T09:14:00.002-04:00

I love it when someone can give me a sound way to quantify wiggly and abstract things. Bruce Schneier wrote this about Security ROI:

…a company should implement only security countermeasures that affect its bottom line positively. It shouldn't spend more on a security problem than the problem is worth. Conversely, it shouldn't ignore problems that are costing it money when there are cheaper mitigation alternatives. A smart company needs to approach security as it would any other business decision: costs versus benefits.
The classic methodology is called annualized loss expectancy (ALE), and it's straightforward. Calculate the cost of a security incident in both tangibles like time and money, and intangibles like reputation and competitive advantage. Multiply that by the chance the incident will occur in a year. That tells you how much you should spend to mitigate the risk. So, for example, if your store has a 10 percent chance of getting robbed and the cost of being robbed is $10,000, then you should spend $1,000 a year on security. Spend more than that, and you're wasting money. Spend less than that, and you're also wasting money.
Of course, that $1,000 has to reduce the chance of being robbed to zero in order to be cost-effective. If a security measure cuts the chance of robbery by 40 percent -- to 6 percent a year -- then you should spend no more than $400 on it. If another security measure reduces it by 80 percent, it's worth $800. And if two security measures both reduce the chance of being robbed by 50 percent and one costs $300 and the other $700, the first one is worth it and the second isn't.

Taking back my corner of the web

2008-09-04T20:12:00.002-04:00

I've decided to abandon the idea of focusing this blog on a narrow set of topics. I have very wide-ranging interests and strengths, and I don't think anybody's benefiting from the slow trickle of weak ideas that's left when I restrict this blog to agile + Ruby. I may even wind up posting more frequently on those topics.

You may like this, you might not, but I wanted to give any subscribers fair warning.

Quick letter about electronic voting

2008-01-20T22:42:00.000-05:00

Electronic voting has been thoroughly shown to be unreliable and manipulatable. As a professional software developer, I can attest to the difficulty of creating systems that cannot be tampered with. I can also add that many reports I have read of defects in voting machines have suggested a lack of competence in a task that would be difficult for the very best developers.

On the other hand, voting techniques that leave a paper trail give us a backup plan when machines fail us. It is long past time to add laws that encourage and aid officials in implementing paper trails for our elections. Inaction makes our elections look illegitimate, even if there is indeed no manipulation at all.

Managing to capacity

2008-01-17T15:19:00.000-05:00

Jason Yip says managing to capacity is a prerequisite to other work on process:

When going down the path of Agile/Lean, there are two main topics:
Learning to manage to capacity
Learning how to improve process capability
If you can't accept the first point, the second point won't make any difference.... in fact, because of overburdening, you'll make the second point harder.

assert_efficient_sql

2008-01-16T16:05:00.000-05:00

The ever-brilliant Phlip Plumlee with a way to lint SQL "pessimizations":

assert_efficient_sql - O'Reilly Ruby

To ensure your test cases call efficient MySQL…
def test_my_case
 assert_efficient_sql do

   # just wrap them in this block!

 end
end
The assertion intercepts and copies out your MySQL SELECT statements, then calls EXPLAIN on each one, and inspects the results for common problems.
The goal is test cases that resist database pessimization, even as you change your data relations, to add new features. If you run your tests after every few changes, you can easily detect which change broke your database’s indices and relations.
This article is a reference for this assertion’s options.

Phlip is soliciting help with implementing this feature across more database engines.

Four busted laptops, one measly task

2008-01-10T01:26:00.000-05:00

Good friends of ours from out of state are staying with us tonight. They're fellow geeks, and he's a fellow developer.

Our task: copy 1.5 MB from a CD to his wife's MacBook.

Our challenge: his wife's MacBook does not currently read optical disks.

Tools available to solve the problem: a PC laptop with a failing hard drive, my work MacBook Pro that also has issues with optical disks, our family iBook that works but has no screen backlighting at present, and the destination MacBook, which, again, isn't reading optical disks.

Solution: I fortunately had SSH enabled on the iBook before its backlight went out. I logged into that, and inserted the CD into the iBook. Checking in /Volumes, I found that the CD wouldn't mount until I logged in to the GUI. I'm sure there are dozens of ways I could have done that from the command line, but it went along with the silly mood of the whole thing, so I went ahead and logged in blind.

Sure enough, during the GUI login process the CD appears in /Volumes. We make a tar file and my friend copies it down.

Easy peasy.

PS: Oh, and the eject key on the iBook didn't cause ejection. Turns out a quick drutil eject does fine.

Track down warnings in Ruby test runs

2008-01-04T11:20:00.000-05:00

Got warning or other spew in your Ruby test runs? To track down the source you can have a setup method output the test name:

p name

This makes it very easy to track down the source of the unwanted output.

This works because each test run is its own instance of your TestCase subclass.

Daniel J. Bernstein advocates for Ruby?

2007-12-03T10:11:00.000-05:00

It's not your typical advocacy piece for Ruby (in fact it's not about Ruby at all), but Daniel J. Bernstein has written a paper reflecting on the success of his qmail mail server, which has a security guarantee (in the form of a $500 bounty) that has gone unclaimed since March 1997, and which runs several prominent mail houses.

He notes several aspects of his development process and architectural decisions that contributed to qmail's success. Interestingly, many of his comments relate to his use of concepts in his C code that are usually associated with higher-level languages. Here he complains about C's dangerous handling of integers:

Another surprise for the programmer is that y can be much smaller than x after y = x + 1. This happens if x is the largest representable integer, typically 2^31 − 1; y will then be the smallest representable integer, typically −2^31.
...
Most programming environments are meta-engineered to make typical software easier to write. They should instead be meta-engineered to make incorrect software harder to write. An operation that is not exactly what I normally want should take more work to express than an operation that is exactly what I normally want.

Ruby does get many details like this right, and good object-oriented practices can help too. For example, I kept thinking of the Tiny Types pattern while reading this.

I'm reading this a bit at a time and still parsing what Bernstein's ideas mean to me, but the segments on spending some performance dollars to buy quality abstractions were refreshing to see from a developer who's met with measurable success.

Spying on assert_select

2007-10-25T15:35:00.000-04:00

When testing your views with assert_select, it's nice to get information on what response text failed to match, but it's too much to just throw @response.body into the test failure message:

assert_select('div#whatever-id p.classname', 'small stuff', @response.body)

Instead you can use nested assert_selects and the elements they yield:

assert_select('div#whatever-id') do |whateverId|
 assert_select('p.classname', 'small stuff', whateverId)
end

That will dump out just div#whatever-id and its contents into your test failure message.

A solution for developing remotely: Vim's netrw

2007-07-12T16:01:00.000-04:00

I'm doing some work that has to be developed remotely, so I wanted a way to edit locally instead of doing everything in a terminal window. I tried using MacFUSE and sshfs to make the remote directory appear on my own desktop, and it worked after I figured out the options I needed, but opening files in gvim was very slow.

So I took my friend Ed Marshall's advice and tried Vim 7's netrw support. Bingo! It works via scp (which is (almost?) always available when there's ssh access) and is dreamy.

To edit a file /path/to/file.rb owned by a user joe on a machine example.com:

vim scp://joe@example.com/path/to/file.rb

Brief pause while the file gets retrieved, but then it's copied to your /tmp directory and everything's full speed. The only downside I ran into was that inter-file navigation wasn't as good. To get a file browser for the files in ~/path/to, I could then do:

:sp %:h

or to edit ~/path/other_file.rb (again from a window opened on ~/path/to/file.rb):

:sp %:h:h/other_file.rb

:sp means "split window". % means "the current file". :h means "the parent directory of the preceding file path", and can be repeated.

I'd love to hear more about navigating in Vim + netrw—I haven't even gotten my feet wet yet. I just wanted to share the nice experience I had right out of the box.

Hidden in plain sight: script/runner

2007-07-11T17:55:00.000-04:00

I am loving the opportunity to work with my co-workers in the home office. We have "geek-out" lunches in the office once a week or so, and invariably all learn something.

So today I learned about script/runner, a file that's in every Rails app that I never looked into for some reason. Turns out I wish I had. It's a replacement for calling the Ruby interpreter that gives your script your app's Rails environment preloaded, so you can just write Ruby code without having to monkey around with loading Rails yourself. Just call something like

script/runner my_file.rb

script/runner "puts 'My Ruby code here'; puts MyModel.count".

What are your favorite "hidden-before-your-eyes" features of Rails?

Welcome Dave Astels!

2007-07-10T14:08:00.000-04:00

I'm excited to welcome Dave Astels to the Obtiva team. Dave is a very active member of the Agile community and has shared some ideas over the years that I have found very valuable for better understanding TDD. It's an honor to have him working with us.

Obtiva is shaping up to be quite a strong software house with a promising future.

Land rush

2007-06-25T07:38:00.000-04:00

I have a workplace running gag with a friend at a client wherein when we encounter a Rails misfeature (especially the ones that have been solved carefully and elegantly in Java or elsewhere), we rip on Rails mercilessly to make ourselves feel better. My friend came up with this one almost unprovoked, I thought it eminently bloggable:

"It's like the land rush. We are all so excited about the free land that we forgot about all the bears and Indians waiting to kill us."

How to stub out Rails helper methods with Mocha?

2007-06-18T17:31:00.000-04:00

UPDATE The code given doesn't actually work. I'd love to hear if anyone knows of code that will do this. I hacked around the problem a very ugly way.

Rails helper methods are defined in modules and mixed into objects...of what class? Turns out it's anonymous copies of ActionView::Base. How does one mock or stub methods on such a beast? Here's a solution I found:


class MyController
  def rescue_action(e) raise e end
  attr_reader :template
end

class MyControllerTest < Test::Unit::TestCase
  def setup
    @controller = ...
  end

  def test_should_stub_helper_method
    @controller.template.expects(:random_helper_method).returns('')
    ...
  end
end

Thanks to Matthew Dieter for posting about this. I had to add the attr_reader line to get this to work.

Rails plugins: keep init.rb thin

2007-05-21T12:25:00.000-04:00

Rails plugins' initializer script, init.rb, is currently invoked via eval, not require—so it inherits whatever module-space Rails calls it from. If you reopen any classes in init.rb itself (like the will_paginate guys quite reasonably attempted to define Hash#slice), your changes will be made—but to the wrong module.

So, to avoid strange gotchas, consider init.rb just a generic hook point to kick things off, and always require in any code that's to do actual work at plugin load time.

Alternatively, you can explicitly anchor referenced classes to the top level, like ::Hash. That's the route will_paginate took, but I would just break out a separate file and require it to keep things plain and clear.

Remove the menu bar and toolbar from gvim

2007-05-21T11:00:00.000-04:00

I wanted to reclaim some real estate from the top of my gvim screen. Here's a couple lines for the .vimrc or .gvimrc:

" Remove menu bar
set guioptions-=m

" Remove toolbar
set guioptions-=T

GUID generation in Ruby

2007-04-11T20:41:00.000-04:00

There's a good gem for Ruby GUID generation available:

gem install uuid

It's from the reliable-msg project.

Weekday code accepted into Ruby Facets

2007-02-28T12:56:00.000-05:00

Dave Hoover picked up the ball from my "next-weekday" post and submitted a contribution to the Ruby Facets project. Now Ruby Facets lets you require 'facets/more/times' and say things like 1.weekday.ago, 4.weekdays.from_now, and 9.weekdays.since(some_time).

Have a look at the source. Thanks for your work preparing this contribution, Dave!

Providing a format to RESTful resource routes

2007-02-23T10:01:00.000-05:00

I am absolutely loving the RESTful support in Rails 1.2. It uses conventions to tilt the playing field toward domain-driven design. Yum, yum, yum. My favorite use of conventions in Rails yet. The URLs are meaningful, the controllers now have a clear design, it's an appropriate and extensible abstraction, life is good and Rails apps are much improved for it.

But I ran into a hitch that foiled me for a little while. I only solved it by spelunking into the code, so I'm posting the solution in hopes that Google will be a better friend about this.

Simply providing a :format option to a resource's named route doesn't work as expected.

photo_path(:id => 1, :format => 'png') #=> /photo/1?format=png

Instead, the resources routing method defines a separate named route prefixed with formatted_:

formatted_photo_path(:id => 1, :format => 'png') #=> /photo/1.png

Tricky...I wonder what it would take to make this complication unnecessary.

Ruby on Rails and more at Obtiva

2007-02-10T10:14:00.000-05:00

I'm pleased to announce that I'm now working with Obtiva, a group of Agile coders in Wheaton.

We do a lot of Ruby on Rails development work. I'm enjoying getting to know and learn from Dave Hoover and Tyler Jennings. We're hard at work on several exciting projects, some intranet apps and some major upcoming launches for national brands that are expected to get quite a lot of traffic. In addition to client work, there are rumored to be some very interesting internal efforts. Watch for some compelling announcements in this space.

Interestingly, we're also a top-shelf Java Eclipse RCP shop. I got a demo of a major app we just delivered to a client's thousands of end users, and it's very polished and snappy. I'm quite excited about the opportunity to work with a serious agile team on this caliber of product.

We do agile coaching and training as well. I'll talk more about that in another post.

I'm excited to be part of this team. We're enthusiastic about developer testing and other agile practices, we walk the walk, and it shows in the high quality of our deliverables and the friendly culture.

Full speed ahead!

Shortcut for locating files in TextMate

2007-02-03T12:49:00.000-05:00

I haven't yet actually hunkered down and learned TextMate as a key tool like I did when I learned Vim at the sage advice of The Pragmatic Programmer. But I should.

One bit I picked up recently: instead of scrolling through the file drawer to find a certain file in the project, just hit Command-T. Up pops a nice filename search box. Type a key word from the file name, and a list of filenames appears below. Type a little more to shorten the list, or just use arrows and Return, up pops the file. No mouse.

Old hat for many, I'm sure, but for me it makes a big difference.

Calculate next weekday in Ruby on Rails

2006-12-20T21:15:00.000-05:00

I had to advance a Time to the next weekday for a client Ruby on Rails project. I admit I dreaded writing that code, I somehow imagined awful hacks atop awful hacks.

I'm happy to report it didn't turn out quite so bad after all:

def next_weekday(original_date)
  one_day = 60 * 60 * 24 # in Rails just say 1.day
  weekdays = 1..5        # Monday is wday 1
  result = original_date
  result += one_day until result > original_date && weekdays.member?(result.wday)
  result
end

And the test that drove it:

def test_next_weekday_skips_weekend
  original_date = Time.at(1165606025) #  a Friday
  assert_equal(5, original_date.wday, "this test should give a Friday")
  new_date = next_weekday(original_date)
  assert(
    new_date > original_date, 
    "new date should be after the original date"
  )
  assert_equal(
    1, new_date.wday, 
    "new date should be a Monday since we gave a Friday"
  )
end

Please feel free to embarrass me with your improvements in the comments.

Textpattern explains testable code concisely

2006-10-18T11:03:00.000-04:00

I've often stumbled over answering the question, "how is testable code different?" to people new to testing. Textpattern has the best elevator-speech answer I've seen:

Scripted unit tests are becoming increasingly important in the Textpattern release process. You can make your code more testable by using a functional design with minimal coupling. A function that can be run in isolation, and returns a value based on its arguments, is easy to test. A function that prints output based on global variables, database records and configuration values is much harder to test.

That's right. It's not about use of objects, it's about keeping side effects to a minimum. Nicely put.

Find out what stakeholders are thinking

2006-07-21T09:58:00.000-04:00

Jeffrey Veen:

At Adaptive Path, we used to do a kick-off exercise where we got all stakeholders to quickly sketch their assumption of what the final product would look like.
Then, they would all stare at each other’s work in terror, realizing just how different they all were.

A chat with myself, or Gmail Autochat

2006-06-06T00:57:00.001-04:00

They need to fix the thing where you can chat with yourself. I saw a green dot on the message I'd just written to my brother Alex that said "Reply by chat to", and thought, "cool, I'll chat him for kicks". The absence of a name didn't clue me in.

And then I noticed that whatever I said was echoed back to myself with an empty name. Huh, how strange, I wonder if Alex will see it twice. Then I noticed that he (my correspondent, who was Alex, of course?) was typing. Also strangely, he seemed to stop typing repeatedly and never actually send a message. He must be typing me a real epistle.

And how is this that he's typing to me when I open up the quick contacts and it says he's offline?

Oh wait.

Note: presumably this odd use case is possible for me because send my Gmail messages with my custom platte.name address in the From.

\A and \z versus ^ and $

2006-05-23T18:38:00.000-04:00

This one is subtle—if you’re anchoring a regular expression
to the beginning and end of a string, not a line, you want \A and \z, not ^ and $.

Guess who just got bit!

Bust your systems apart for maintainability

2006-04-19T12:46:00.000-04:00

Jeremy Voorhis recently posted a gem about heterogenous architecture:

There is something desirable about heterogenous architecture. Specialist components with clear lines of responsibility become a joy to work with, and easier to maintain. Don’t force heterogenous design, but consider it as an agile approach when you suspect your application is growing into a monolith.

I've found this to be very true, and push for solutions that use independent tools over integrated frameworky things whenever possible.

The reason why it works is simple: when two moving parts are only able to affect each other through a well-defined interface, you have a very focused set of things to think about when you need to debug or add features. Using different technologies forces the system to have a well-defined interface even if some people don't like following rules or are ignorant of best practices.

Test-driven development creates a similar effect at a smaller scale: because there's always at least two users of any given code, the test code and other production code, the developer has a strong motivation to make it easier to isolate each piece of code. The result is loosely-coupled parts that communicate across well-defined interfaces.

So right there are two ways to get to increased maintainability:

Build heterogenous systems to force some hard boundaries between components.
Test first, and design to make the code easy to test.

The first works anywhere. The second is more subtle and requires more cooperation from other developers, but has a deeper benefit.

New focus, new feed

2006-04-19T02:35:00.000-04:00

I'm planning to move this blog to my own domain at some point, and focus it on agile development, Ruby, and other things that aren't (overtly!) sociopolitical.

Please subscribe to my new feed address, which will follow the blog to its new home.

Getting Gestural

2006-04-05T15:16:00.000-04:00

37signals put this photo of me gabbing into the photostream from their recent Getting Real seminar.

I don't remember exactly what I was saying, but I doubt it was quite so dramatic or important as I look like I'm trying to impart.

Ward Cunnningham on testing in schools

2006-04-04T15:58:00.000-04:00

The complexity of subjects and diversity of students renders any notion of uniform testing foolish. My administration will make testing and grading an extracurricular activity like sports or debate and thereby relieve public school teachers of their most unproductive daytime burden. If employers want a unidimensional metric for hiring, let them pay for it themselves. If the smart kids want to compete for valedictorian, let their parents form a booster club and host bake sales to pay for the examinations.

—what Ward Cunningham would do if elected President, from his home page on his own wiki

Beautiful macro shots of insects

2006-03-28T15:49:00.000-05:00

Via 37signals, some beautiful macro shots of insects.

Some pair programming success

2006-03-24T12:57:00.000-05:00

I got to do some pair programming with a co-worker yesterday, about which I'm ecstatic. Sounds like he enjoyed it too.

"Righteousness and peace"

2006-03-20T12:12:00.000-05:00

How many times have I begged and pleaded, spoken and written in the media, that peace must be obtained; that we begin to make a break with the killings and the evil, that we become the human beings that we are, and behave as men of faith in the one God of justice, truth and peace who calls us to righteousness and peace, but whose call goes unheeded.

—Patriarch Pavle of the Serbian Orthodox Church, in a letter to Islamic leader Reis-ul-ulimi Jakov

From a compilation of several statements, prayers, and appeals of Patriarch Pavle.

Is your design on the right track? Remember "PC-COF"

2006-03-20T11:58:00.000-05:00

Testable Software Design:

Here’s my current definition of a testable system:
For each logical part of the system, a unit test can be written relatively easily and quickly that satisfies all the following PC-COF rules at the same time:
Partial runs are possible
Consistent results on every test run
Configuration is unneeded before run
Order of tests does not matter
Fast run time

—Roy Osherove via Keith Ray.

Waiting to refactor

2006-03-13T12:53:00.000-05:00

There's a slightly tangled area in the code of my current project. It's an aspect of the code that hasn't needed much flexibility to support the existing features, so this being an agile project with gradual design, the code isn't very flexible yet.

And then the request came to add several new features that would exercise the currently-inflexible code. Panic! At this point I'm not even sure what exactly is wrong with this code, only that I have been struggling uphill somewhat every time I set out to use it. It's a little research project each time.

So I pour out my heart to my boss and the team member who's in the Customer role (it's an internal project, he really is the customer). "Oh boss, danger! There's something slowing me down, I know not exactly what, but I shall surely need extra time, etc.!" Too bad I let my fear run wild there. If I'd have had more patience and courage, everything would have been fine.

I wound up simply keeping one eye on the "problem" area of the code while I continued to make forward progress on the new features. Turned out there were two problems I was smelling, 1) a longish.message.chain in violation of the Law of Demeter that was causing coupling problems, but only at 2-3 sites, and 2) inadequate model/presentation separation, a deeper and more widespread problem, but not hard to tackle either.

And now that I understand what problems I'm facing, I'm calm and confident about the code again and can implement the refactorings gradually with minimal disruption.

What did I learn?

Code smells are good, not to be feared. They mean I'm learning about my code, and am about to make a nice improvement in its design once I figure out the source of the smell.
It's good to be bothered about the state of the code, but don't worry about the annoyance until I understand it as a clearly defined problem. Then I can take concrete action.

Something not to do

2006-03-02T10:47:00.000-05:00

Work for a long time on a document, saving fairly infrequently.
Decide the document should have a different name, and instead of saving it again with that new name, move the original file to that location.
Open the file at the new location, electing not to save the changes.

Hope you're having a great morning doing today's work. I'll be here repeating yesterday afternoon, which I don't recall enjoying too much.

urlencode in Ruby

2006-03-01T15:24:00.000-05:00

I dug around for too long to find this one:

You can urlencode by calling CGI.escape.

Brian Marick breaks it down

2006-02-18T13:12:00.000-05:00

Brian Marick wrote down a design he would use to allow the different web application layers to be tested without too many end-to-end tests.

I wonder if Rails' components could be reimagined/rewired to work more like this.

Lurking dependencies in test doubles

2006-02-01T19:24:00.000-05:00

And so I find myself stroking my beard over an Object Mentor post again.

David Chelimsky points out that hand-rolled mocks create a dependency right in the test code. He relates a story similar to what I've experienced a few times, in which small test doubles became a whole parallel hierarchy of classes implementation-coupled to the classes. It hadn't occurred to me that auto-generated mocks, or other techniques to abstract the creation of test doubles, would help keep the dependency tree clean, but there it is.

The good news is this: the result of these observations has been that our service layer is morphing back to it's original form - very thin, simple APIs favoring dependency injection over service locator for both tests and the system under test.

More solid concepts to work with as I consider scope and strategy for a plugin to Needle-ize Rails.

By the by, I'm giving up on the 2-post-long "Rails contrarian" schtick, about 2 posts too late. Ron Jeffries quotes Ralph Waldo Emerson:

Speak the affirmative; emphasize your choice by utterly ignoring all that you reject.

So it's time to evangelize why Ruby systems do need dependency injection, or at least its full benefits. And try to ship some tools to help folks apply that advice easily.

Rails contrarian, part 2: Some wisdom from Ward Cunningham

2006-01-27T11:16:00.000-05:00

And now for some guidance from the brilliant minds that work on Fit, the acceptance-testing framework.

Michael Feathers is doing to Fit something like I'm hoping to do to Rails in this interesting post. Ward Cunningham himself weighs in with some of his profound insight in the comments:

Authors of large programs are wise to modularize things like application sequence, data access and input/output conversion. Where these modules exist in an application, it makes a lot of sense for Fit Fixtures to use them (after first testing them, of course). Be careful not to make your variation of Fit a platform for Fit-only modules that discourages modularity where it matters most, in the delivered application.

Thick and meaty stuff that goes right to the core of the issue, both for Fit and Rails, I think. I'll be thinking about that advice, and indeed the whole post, for a while. This is wonderful stuff.

Why Rails bugs me, part 1: test/mocks

2006-01-22T01:08:00.000-05:00

UPDATE: As I learn more, I'm collecting relevant links at the bottom of this post. Also, I didn't mean to sound anywhere near as negative as I did. My apologies, in particular to David, and I've reworded a few things.

So here's my dilemma. I heart Ruby and have worked with it whenever possible since I learned it in 2002. Then this Heinemeier Hansson guy comes along and builds a web framework on it, markets the tar out of it, it becomes a killer app, and suddenly everybody from Slashdot to Scoble is making noise about Ruby. It's been astonishing and quite wonderful.

So why am I less than enamored with Rails? Maybe I'm just playing the contrarian, as I'm wont to do, but I think I may have some reasons. Since I keep thinking of specific reasons and forgetting them at key moments, I'll try blogging even smallish issues here with whatever useful discussion I can come up with. Maybe then I can connect the dots more meaningfully.

I'll start with a simple one:

test/mocks

I cringed when I saw this introduced. A nice, official-looking directory where I can put code that will screw with my Ruby environment only for tests, and for all tests.

Nooooooo! Why not just start coding with lots of global variables and be done with it?

Well-designed code has minimal dependencies at any one point, and its dependencies are on abstractions rather than implementations. This test/mocks thing blesses the practice of reaching in and hacking on the dependencies of the code under test. This wouldn't be so bad for one or a small group of isolated tests; in fact it's one of the really nice things about Ruby that makes it great for test-driven development. But using test/mocks applies said hacks to all the tests!

Automated tests are worth the most when they can be confidently relied upon: "this test takes A, applies B and C, and I get D." Great. Now say I've changed all the B's in my system, let's call the new version "BB". My production code still uses B, but all of my tests use exclusively BB. How much confidence can a test like that give me when it matters most?

Instead, I should be writing code that can be passed its dependencies so I can use BB only in the tests where it's useful, and have the real McCoy available the rest of the time so my tests catch unexpected integration problems or whatever will happen in the real world where B lurks and my little hacked-up BB ain't.

I wish we could've scored a little chink in the Convention over Configuration armor for a sec back when Jamis wrote up a way to bring ubiquitous dependency injection to Rails. To me, Rails could be so much stronger as a framework with the flexibility and the attention to dependency management Jamis's proposal embodied..

And using the Needle dependency-injection tool this way wouldn't bring about the feared apocalypse of Rails2EE, wherein we do YAML situps to declare ServiceModuleAccessPointTriggers or whatever. It'd just add a spot where we can reach in and change which objects go where for a moment without screwing everything else up.

I really want to know if there's something I can do to help solve this problem. Please fire away with flames, suggestions, questions, or massive groundswell of support in the comments.

Reverie inspired by Stubbing Net::HTTP.get.

Updates

I went back and reread the pages from those few days in November 2004 when all this was shaking out. It looks like it may be possible to make a Needlizing plugin for Rails using Jamis's ideas and hacking the ActionController::Dependencies API.

And now for what might be perhaps the first Rails historical research project (?), wherein I'm trying to figure out who intended what, and what happened to those intentions:

Jamis's proposal

Dave Thomas hooks it up with some smart Ruby magic that turns class names into transparent accesses of the registry (looks like this became incorporated into Jamis's paper)

DHH likes Jamis's idea and especially Dave Thomas' simplification of it, but isn't sure what it will do to Rails internals

As Sam notes in the comments, Jamis says he's "not as convinced of the necessity of dependency injection in Ruby" as he once was.

Did anything happen after that? Has there been a definite decision not to incorporate dependency injection into Rails?

The problem with software patents in a word

2006-01-20T09:31:00.000-05:00

Imagine a world in which news was owned in such a way that once one guy reported it nobody else could report it for 20 years because the first guy to report it owned it. That's the problem that the patent law proposes to software.

Eben Moglen

Full night's sleep for Mama

2005-11-22T10:21:00.000-05:00

Nicole got a full night's sleep last night for the first time in a while. Gabriel had been waking lots from stuffiness. We'd repetorized (taken his symptoms and looked them up in homeopathic rubrics to find a suitable remedy) on as many symptoms as we could think of, with no results.

But last night, we just keyed in the main complaint, selected the matching symptom, gave him a dose of the single remedy that matched, et voilà. Problem gone instantly.

I'm guessing we won't again overlook 'striking, strange, unusual, peculiar' symptoms anytime soon.

RSS user experience

2005-10-04T11:36:00.000-04:00

It seems like RSS feeds are the most hyped and least finessed aspect of the web right now.

I subscribe to feeds from developers' hand-rolled blogs that seem to burp out umpteen recent posts as new every time they update. Some sites manage to remove formatting, making the feed nearly unreadable (Groklaw hasn't returned my emails offering to fix their problem). Some sites include partial content, but include enough content that it's not clear whether the feed is a full-content feed or not. Even Apple's Safari browser muddies the water here by adding a "Read more..." link after each item, whether or not there's more to read.

So RSS is not a consistently smooth user experience.

But yesterday, 37signals launched Writeboard, a nice little tool for collaborative editing. My friend is soliciting reviews for a paper he's writing, so he invited me to his writeboard for it. I subscribed to the RSS feed. I hadn't had any "wow" moments with Writeboard yet, but the RSS was nice. Each revision marked with the author's name and the title of the writeboard, the full text of the article with underlining or strikethrough for the changes made, the author's name also appears in the author field -- why, they thought it through!

A nice breath of fresh air.

Update: changed the markup of this post to remove Blogger's spurious <br /> tags. Might as well practice what I'm preaching. I need to get on board Typo.

We won't go to bed

2005-07-25T00:30:00.000-04:00

We won't go to bed until it's 12 billion o'clock.
- Raphael

I'm sure somebody analyzed it

2005-07-24T23:04:00.000-04:00

I'm sure somebody analyzed it and made sure it was the best decision for us all.
- Nicole

Returning from restful visit with

2005-06-01T16:21:00.000-04:00

Returning from restful visit with my in-laws. Very encouraging: friends with MS and cancer resonated with Hamer's theories & wanted to know more.

Sitting on a train wondering

2005-05-12T18:27:00.000-04:00

Sitting on a train wondering how to configure myself for the public. Noticed that the different Metra lines have their own personalities.

How to work with dates

2005-05-11T11:56:00.000-04:00

How to work with dates in a sloppy way?

A more rugged Backpack

2005-05-10T16:25:00.000-04:00

I'm surprised at my reaction to Backpack. I'm finding that it feels too clean, too packaged for something to which I could want to commit so thoroughly. I love 37signals' work, but I feel like Backpack's weakness is its failure to deliver something as open as the technologies from which it descends, namely blogs and wikis. The Backpack/Basecamp idiom is polished-looking, which is great for many purposes, but for me it doesn't work for brainstorming and other "raw bits" purposes that comprise what I need to do with what's in my head. Backpack suggests a larger integration of technologies and use cases than has been accounted for, and its ideas reach well beyond the scope of a single product.

I want an Ajax scratch pad that can share, email, receive mail, name URLs, remind, integrate fluidly. 37signals showed us how this can be packaged slickly. I'd like to open this idea up for a lot more collaboration and a lot more freedom.

I felt this way already, but Adam Bosworth of Google recently spoke about four criteria for evaluating whether a web technology will catch on: "Simple, sloppy, standards-based, scalable."

Backpack is standards-based. I've discussed a desire to make a sloppy version. I bet the remaining criteria of "simple" and "scalable" can be used to create something really interesting.

And towards "standards-based": what if in addition to creating and consuming email, whatever-it-is also created and consumed RSS? IM?

But also, as I complained to the 37signals team, Backpack doesn't have a clear focus. It's really slick, and its current huge success may make me look like a fool for saying so, but I don't think it's a winning idea without a better story. Whatever angle I come up with, Backpack is too big or too small, too personal or too prefab. I like the way Google is building focused services independently, then gradually tying them in to the larger Google experience. Backpack seems like several such services awkwardly rolled into one.

I'll collect ideas and action items toward the vision described above
in the comments. Please speak up if this piques your interest.

It's an experiment.

2005-05-10T14:28:00.000-04:00

I'm typing this on my cell. Mini thoughts...like poetry. We'll see.

Glass

2004-09-02T13:10:00.000-04:00

I just realized, I really enjoy drinking from a glass, as in glass glass, not plastic glass. Maybe it's a silver-spoon thing, but it's a little bit of elegance or something.

Cold blood

2004-06-29T10:26:00.000-04:00

A father's last day with his son.

Reports from the Guardian, WNYC's On the Media.

FP

2004-05-10T11:18:00.000-04:00

* first post
* faux pas
* Fisher-Price
* functional programming
* fap poofer
* fat pig
* fluffy pigeon