Grab the new Oracle InstantClient libraries

The new Intel Mac versions are available from the Oracle downloads site. Install them in /Library/Oracle/. You can do side-by-side installations in folders with whatever names you want, since apps find them by using the $ORACLE_HOME environment variable (and it’s friends). I’ve got mine in /Library/Oracle/instantclient/10.2.0.4. Also make sure that you’ve got the files required to run sqlplus and the sdk. You can drop those in the same directory.

Oh, and don’t forget to copy over your tnsnames.ora file.

Symlink the libraries

In the directory where you’ve installed the instant client, run this:

ln -s libclntsh.dylib.10.1 libclntsh.dylib

Set the environment variables correctly

You’ll probably want to put these lines in your .bash_profile, but they also must be run (or source‘d) from the command line to take effect:

export ORACLE_HOME=/Library/Oracle/instantclient/10.2.0.4
export TNS_ADMIN=$ORACLE_HOME
export LD_LIBRARY_PATH=$ORACLE_HOME
export DYLD_LIBRARY_PATH=$ORACLE_HOME
export PATH=$PATH:$ORACLE_HOME

On to the next step, making Rails & Oracle play nice.

Getting Rails to talk to Oracle

First,

sudo gem install activerecord-oracle-adapter --source http://gems.rubyonrails.org

This installs the oracle adapter, which is how ActiveRecord deals with Oracle. It doesn’t, however, install the Ruby oci8 driver, which is how Ruby talks to Oracle. We’ll do that now.

Compile the ruby-oci8 library

Make sure you’ve got the Oracle Instant Client SDK installed in your Oracle Instant Client directory (/Library/Oracle/instantclient/10.2.0.4)

The most recent stable version of the oci8 library is 1.0.1. Download it and unpack the file in the finder: it should unzip into ~/Downloads/ruby-oci8-1.0.1.

Now we can finish configuring the environment before we compile the library.

cd ~/Downloads/ruby-oci8-1.0.0
export SQLPATH=$ORACLE_HOME
export RC_ARCHS=i386
ruby setup.rb config
make
sudo make install

These steps should cause some compiler output to scroll by. Pay attention if you run into any errors on the setup step; the error messages are reasonably helpful at pointing you towards any problems.

Test connectivity

At this point, we’re done. We’ve got the latest Oracle InstantClient, and we’ve installed the ruby-oci8 library. Now it’s a question of making sure that everything works as advertised:

ruby /usr/bin/irb

In the IRb console, type:

require 'oci8'

If the console returns true or [], you’re in business.

Configure your database.yml

The last step is to make your application use the Oracle connection. In your database.yml, use the following to make it work:

development:
adapter: oracle
database: your_instance_name
username: your_user_name
password: your_password

The database name comes straight out of your tnsnames.ora file. You don’t need to specify any other connection information in database.yml, since the tnsnames.ora file has everything you need.

Your application is now talking to Oracle, without Rosetta!

Fix the ruby_fat and ruby_ppc setup

If you followed my previous instructions and went through all of the shenanigans with the ruby_ppc and ruby_fat versions and would like to undo them, it’s quite simple. Just remove the ruby_ppc files, and the symlinks to them (called ruby, and rename ruby_fat as ruby:

cd /usr/bin
sudo rm ruby
sudo rm ruby_ppc
sudo mv ruby_fat ruby
cd /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin
sudo rm ruby
sudo rm ruby_ppc
sudo mv ruby_fat ruby

Then, you should also remove the 2 management scripts:

sudo rm /usr/bin/ppc_ruby.sh
sudo rm /usr/bin/fat_ruby.sh

And that’s enough for the cleanup. From here you can start following the instructions beginning with getting the new Oracle libraries.

namespace :db do
  namespace :schema do
    desc "Create a db/schema.rb file"
    task :dump => :environment do
      require 'active_record/schema_dumper'
      puts "Creating schema:"
      File.open(ENV['SCHEMA'] || “db/schema.rb”, “w”) do |file|
        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
      end
    end
  end
end

This task as shown does exactly what the default rake task does, except for the puts line. Let’s just pretend that it’s a radically different and wonderful version that solves world hunger and raises your children. Now, if you drop this into a rakefile in your app’s lib/tasks directory, and then you run rake db:schema:dump --trace you’ll notice that the schema.rb file gets created twice. What the???

Check the docs

So I started poking around the Rake docs. Rake::Task.define_task does the following:

Define a task given args and an option block. If a rule with the given name already exists, the prerequisites and actions are added to the existing task. Returns the defined task.

Aha! So instead of overriding the existing task (monkeypatching it), I’m adding to it. That’s why the schema gets dumped twice. But what if I don’t want that? What to do if I want to replace the rake task with my new version?

Check the internets

About an hour of googling later, I finally came across a post from Matthew Bass explaining the solution to my problem:

Rake::TaskManager.class_eval do
  def remove_task(task_name)
    @tasks.delete(task_name.to_s)
  end
end

def remove_task(task_name)
  Rake.application.remove_task(task_name)
end

# Override existing test task to prevent integrations
# from being run unless specifically asked for
remove_task 'db:schema:dump'

# Now define db:schema:dump again, the way we did above

And that was it. It’s relatively straight-forward, but has a tendency to do strange things when rails gets updated. So you could abstract it into a plugin, with tests, but don’t forget to test it whenever you gem update rails.

Alternative solution

While I was googling I also ran into a very interesting post on alias_task_chain, a method that patches Rake tasks to work like more typical methods with alias_method_chain. If you were clever and wanted to spend the time, you could get a solution to the problem using this method.

What you know

Some clients approach me saying that they want a website. Some say that they want a website that looks nice. Some say they want a website that performs functions x, y and z. Some say they want a website set in 12pt Verdana with a background that’s exactly this shade of green, on a 960 pixel grid. And written in PHP with a custom CMS, please.

There’s nothing wrong with any of these, although the last client always tends to give me pause, for reasons I’ll discuss at the end of the article. I like to think of hiring a web professional the way I would hire a contractor to work on my house. Because, really, that’s what you’re doing: you’re hiring a contractor to work on your digital house. Not all contractors are the same. They produce work of differing quality, in different styles and at different prices.

The problem for most home owners/clients is that the sheer number of choices is overwhelming; they don’t even know where to start. If you want a contractor for your house, there’s a very clear geographic constraint on the choice — the contractor must be in the same place as you, so they can come to your house to do the work. But with the web, that’s not true; we’re all just one e-mail away from each other. (6 degrees of separation? Hah!)

Who might you hire?

Chances are pretty good that you’re not the first business in your industry to have a website. They’re also pretty good that you’re not the first business of your size to have a website. So look at some of these other businesses on the web, and find out who did their sites. Most web pros will have some link to themselves somewhere on the sites they design, usually in the footer or on an “About” page.

Start building a list of potential contractors in this way. You can also do a Google local search to find web designers in your area. They have the advantage of being able to meet you face to face, which is something that I really like, although it’s not necessary.

You’ll very quickly end up with 10-20 potential site builders this way. Collect ‘em all.

Who do you like?

This is the most fun part of selecting a web designer: making a short list. Everybody’s a critic, and this is your chance. Start by browsing their web sites.

If their site is old, clunky or ugly, then maybe you should take them off the list. If they tend to make sites radically different from the kind of site you’re looking for, take them off. If their personal style doesn’t match up with your vision of your site, then perhaps they’re not right for you. Although be careful; some people have amazing ranges and can surprise you.

Many web pros have a blog. Read some of it. Do they seem like the kind of person you would want working for you?

After going through this, you should be down to some kind of a short list.

Your ideas

Note that, so far, I haven’t said much about refining the ideas for your site. That’s because you don’t need to do that alone. The analogy about hiring a contractor isn’t really appropriate anymore. Really, when you hire someone (or some company) to build your site, you’re hiring an architect and a contractor all at the same time. The architect will help you refine your vision when you’re deciding on the addition to your house; let the web professional do the same.

You shouldn’t refine your ideas alone. The best designs come from lots of interaction between the designer and the client.

Talk to them

Now we get down to the nitty gritty. E-mail or call every member of your short list, and make an appointment. Speak with them. Ask them about their process. How do they get you from where you are to having a completed site? How much feedback is there between them and you along the way? What does their process emphasize? How flexible is the process?

Although there are wrong answers to these questions, there aren’t any right answers. What’s important here is that the way they work fit with what you want. Personality is a big part of this. You have to be able to talk to your web pro, and you have to be able to trust that their process will produce the end result that you’re looking for.

Get a quote

This one speaks for itself. Get a quote. Find out what their pricing method is. Do they bill hourly? Is it a flat fee? What are the restrictions about changing details of the project mid-stream? What kind of timeline can they work with? Is the quote firm?

Again, there aren’t really right answers, although there can be wrong ones. Comparing quotes is very difficult, as they are frequently apples and oranges. Unfortunately I don’t really have any good advice here, except this: in the low range of web design, you almost always get what you pay for, but above that it’s a free-for-all, and price frequently bears little correlation to the quality of the finished product.

Be wary of hidden costs

Be careful about hidden costs. For example, all web sites need to be hosted somewhere. Does your web designer offer their own web hosting? Many do. If so, what do they charge? What does the charge include? You can easily price this against any web hosting company’s rates to see if what you’re paying is reasonable.

If they don’t offer hosting, will they set you up with a reputable web host? Will they charge you for that?

How does your site get updated? Will you be able to do it, without breaking anything? If not, how much will it cost you to make changes? Be wary of being nickel-and-dimed to death with site updates, especially when nickels cost $80 an hour.

Search engine optimization (SEO) is another favored charge. Some web pros won’t submit your new site to the search engines. Or they will charge you for it. Some will issue repeated charges for re-submission every few months. This is a very bad idea: once the search engines are aware of you, they will re-index your site regularly. Re-submission is usually grounds for removal of your site from their search results. There can be a wide variety of charges associated with SEO; make sure that they are legitimate and useful for you.

Choose someone!

By now you’re very well equipped to choose the best web designer for you. You know a lot about the people on your short list: you understand something about who they are, how they think and how they will approach your project. Weigh that against your budget, and make your choice.

Trust your designer

Once you have chosen a designer, don’t be afraid to trust them. If you don’t think you can trust them, don’t hire them.

If you know as much as your designer does about web technology, then hiring them is a bad idea; let them sort out the design and the tech. They know if PHP is the best technology for your site or not. Discuss it with them, but listen to what they have to say. After all, you hired them to be your web expert. As long as you have enough input in to the process, they should be trusted to make the best decisions for you. If they can’t, then you hired a bad web professional — fire them and get your money back.

With trust and confidence on both sides, you will end up with a site that you love.

I wish that I had a photo of these to show; they were just too delicious, though, and didn’t last long enough. The addition of a little bit of almond meal to the crust gives them a complexity of flavor that plays very nicely with the clean tartness of the lemon curd.

Lemon curd is tricky

Lemon curd is a very difficult beast. It’s too easy for it to be off-balance: the butter, sugar or tartness from the lemons can easily dominate, and then it’s just good, not sublime like it can be. There are no hard and fast secrets for getting the balance right, either, as it depends entirely on the particular lemons you’re using. As their sugar levels vary, the amount of juice and sugar you’ll need to use to balance out the curd will change. This means that you should taste the curd while it’s cooking, so that you can balance it out at the last minute if it needs it.

The second tricky part to a good lemon curd is making it so that it sets properly, and doesn’t have those nasty little bits of egg white that cook too soon and gum it up. I came across a discussion of lemon curds online somewhere, and one of the participants had a suggestion which worked perfectly: that’s the basis of the recipe below. The secret is two-fold. First, you cream the butter and sugar like you’re making a cake. Second, you must stir the lemon curd constantly while it’s cooking. When you first put it on the heat it will be chunky. As you stir, it will go smooth. It will take several minutes for the transition to smoothness to start, but once it has started it will be quite rapid. This is when you have to taste it to correct the balance of flavors. Similarly, when it thickens it will happen very rapidly. The whole cooking process should take no more than 10–15 minutes.

Recipe

Crust

• ½ cup flour
• ½ almond meal
• ¼ confectioner’s sugar
• ½ melted butter

Curd

• ¼ cup butter, cut into pieces
• 1¼ cup sugar
• 4 eggs, lightly beaten
• ¾ cup lemon juice
• 1 tbsp. minced lemon zest

First, we prepare the crust:

1. Preheat the oven to 350°F
2. Sift together the flower, almond meal and powdered sugar
3. Stir in the melted butter
4. Press into the bottom of an 8-inch baking pan
5. Bake for 20 minutes

While the crust is baking, let’s make the curd:

1. Cream the butter
2. Gradually beat in the sugar
3. Beat in the eggs
4. Mix in the lemon juice and lemon zest
5. Cook over a double-boiler, while stirring constantly
6. The curd will thicken: it is done when it coats the spoon you’re stirring with, and you can use your finger to draw a line through the curd on the spoon that stays

Now assemble the bars:

1. Pour the curd into the pre-baked crust
2. Return the bars to the oven for another 25 minutes
3. When baked, let cool to room temperature and then refrigerate
4. Before serving, cut into 2-inch squares and sprinkle with powdered sugar

I brought a pile of these into work and they vanished: they’re quite tasty.

This is truly great news, for several reasons. One is that Microsoft is now arguing for greater openness. That can only help the marketplace. The other is that, for the first time in a long time, they’re making a very good decision with respect to IE, and they’re making it for the right reasons. They’re making it because they want to play nicer with their clients and their developers. That’s what I call a win-win: they win, and we win. Everybody wins!

But wouldn’t it be nice to have a single method call, that uses url_for syntax?

class Object
  def request(options = {})
    method = options.delete(:method) || :get
    options.reverse_merge!(:only_path => true)
    ENV['REQUEST_URI'] = app.url_for(options)
    ENV['REQUEST_METHOD'] = method.to_s
    Dispatcher.dispatch
  end
end

First we pull the method (:get, :post etc.) out, if it exists. By default we want it to be :get. Then we call url_for and have it only return the path, without any leading domain info. Next we populate the environmental variables and call the dispatcher. The return output will be the HTML your app renders.

To make the trick universally accessible on your development box, put the above code in ~/.irbrc:

Then, fire up the console to your favorite rails app, and call:

>> request(:controller => 'my_controller', :action => 'the_action')

You should see the HTML output scroll by.

I’ve found several pages on the internets that discuss how to do a good subversion setup, and they each had their strong points. I’ve combined their approaches into a method for making a canonical blank app.

Creating the canonical app

First, you should create a repository for your canonical blank app. Let’s say it’s at http://svn.my_svn.com/canonical/trunk. I trust that you know how to do this. Then, you can create your app:

rails canonical
cd canonical

Next you can do an in-place import of your SVN repo into your app directory:

svn checkout http://svn.my_svn.com/canonical/trunk .

Don’t forget the final period in that command; it’s critical. SVN should say something like Checked out revision 1. This step puts our newly created canonical directory under Subversion control.

Adding all of your files to the repository

Now we put all of our files under Subversion control:

svn add --force .

Again, don’t forget the trailing period. This command will output a long list of files with a leading “A”, indicating that they’ve been added.

Create the rake task

Put the following code in a file called svn.rake in the lib/tasks folder:

desc "Configure Subversion for Rails"
task :setup_svn do
  puts "Removing /log"
  system "svn remove log/*"
  system "svn commit -m 'removing all log files from subversion'"
  system 'svn propset svn:ignore "*.log" log/'
  system "svn update log/"
  system "svn commit -m 'Ignoring all files in /log/ ending in .log'"

  puts "Ignoring /db"
  system 'svn propset svn:ignore "*.db" db/'
  system "svn update db/"
  system "svn commit -m 'Ignoring all files in /db/ ending in .db'"

  puts "Renaming database.yml database.example"
  system "svn move config/database.yml config/database.example"
  system "svn commit -m 'Moving database.yml to database.example to provide a template for anyone who checks out the code'"
  system 'svn propset svn:ignore "database.yml" config/'
  system "svn update config/"
  system "svn commit -m 'Ignoring database.yml'"

  puts "Ignoring /tmp"
  system 'svn propset svn:ignore "*" tmp/'
  system "svn update tmp/"
  system "svn commit -m 'Ignoring all files in /tmp/'"

  puts "Ignoring /doc"
  system 'svn propset svn:ignore "*" doc/'
  system "svn update doc/"
  system "svn commit -m 'Ignoring all files in /doc/'"
end

Do any other setup

If there are any other setup or configuration bits that you use all the time — plugins, ActionMailer configs, date formats, etc., put those in the appropriate places. When using script/plugin make sure that you use the -x flag to get the Subversion stuff right. When using script/generate be sure to use the --svn flag to add the files automatically to Subversion.

For example, at my work most of our apps routinely connect to multiple databases, so I put stubs for each of them in database.example. I also like to have certain date formats available to me,

Run the rake task

Now, execute the new rake task:

rake setup_svn

Be warned, though, you should only run this once on the canonical: it moves the database.yml file to database.example, making the project non-functional. You don’t want any passwords in there, either, since you don’t want to expose them in the repository.

The script does a bunch of commits, so any changes you have made to your canonical will be saved to the repository.

Export new projects

The next time you want to create a new Rails project, instead of doing rails projectname you should do the following:

1. Export the canonical from the repository
2. Do an in-place import from the new project’s repository
3. Rename database.example as database.yml and populate it
4. Run rake secret and copy the new secret code into your environment.rb (you don’t want all of your apps to have the same code)

If you don’t want to mess with the canonical, you can just drop the svn.rake file in to your new projects and run it. That would give you some DRYness, like a good hitchhiker’s towel.

That’s it!

Now you should have a good canonical app that makes creating new projects a breeze. At my work we have multiple developers and we will have dozens of apps by the time we’re done migrating ourselves out of the old platform. By standardizing our new projects this way, it makes our startup time much faster and leads to better habits (like always using Subversion), and there is no bad in any of that.

It sounds like a great idea, right? I mean, why should I have to worry that Microsoft released IE7? If I used this tag, and specified IE6, then my page would always render correctly in IE, even if IE was on version 28.

WRONG!!!

Let’s really look at this situation. There are two wrongs here, and Microsoft wants to add a third. Let’s look at how we got here.

1. Microsoft made a bad browser: it didn’t (and still doesn’t) support the CSS standard
2. Developers everywhere screwed up by coding pages that take advantage of the IE bugs, in a way that breaks in standards-compliant browsers (never mind that conditional comments makes this unnecessary)
3. Microsoft upgrades IE to version 7, and those bad sites break
4. Microsoft says, “If every web developer were to just change how they work, we could have upgrades that are ok.”

Do you see the fatal flaw in the logic?

It’s right there in steps 1 and 2.

If Microsoft made browsers that support the standards, we wouldn’t be in this mess. I say, no to Microsoft’s proposal. I say, if Microsoft doesn’t want to make browsers that support the standards, then their customers get what they deserve if the web starts breaking for them. I say, how about Microsoft step up to the plate and make a rendering engine that works instead of relying on everyone else to fix their problems for them.

“But what about all of those pages that the IE7 upgrade broke?” you ask. Those are bad pages, and IE7 is a bad browser. They’re either not coded to standards, or IE7 choked on the correct standards-compliant code they were using, or both. That’s why they broke. The people who paid for that development should switch developers to get someone who knows what they’re doing, who will code pages that actually work. The browser shouldn’t have been released if it didn’t support the standards.

This is why they’re called “Web Standards.” Because they’re standard. I make a page that works in Firefox, I know that it works in Safari. I should know that it works in IE. If that’s not true, then it’s IE’s problem, not mine.

Note to Microsoft

FIX YOUR D*** BROWSER ALREADY. It’s almost been a decade since IE5 started support for CSS 2, and they still haven’t gotten it right. They make $50 billion dollars a year and can’t make their browser behave.

Note to web developers

FIX YOUR D*** PAGES ALREADY. It’s almost been a decade since CSS2 came out. You haven’t figured out how it works yet? You call yourself a professional? Get with it.

I’m a bleeding-heart liberal

Zeldman posted about people just like me. He says, “We won’t get converts by breaking sites and ridiculing their creators for not knowing as much as we do.” He’s right.

Except that we’ve tried that, and it doesn’t work. It doesn’t work because many of the web pages out there aren’t made by professionals. Anybody heard of Dreamweaver WYSIWYG mode? If the pages work, people are happy. Except that they don’t work. If they work in IE6, but not in IE7, they never worked. They just had the illusion of working.

Let’s make an analogy, to print design. If I, a rank amateur in the print design world, decided to print a book in 5 point Comic Sans and it was totally illegible, that’s my problem. It’s not the printer’s problem, or the reader’s problem. It’s mine. I screwed up, I made content that wasn’t accessible to anybody. Some readers have figured out that if they use a magnifying glass, it’s not so bad, they can read it. That doesn’t mean that my book wasn’t broken. Now let’s say that these people buy another book of mine, this time printed in 72 point Bembo. With their magnifying glass, they now complain that the new book is broken! They can’t read it. Nobody else can either, because the type is just too big. If I said, “Well, every publisher needs to do something so that my books are legible” you would say I’m stupid. It’s up to me to books that are legible. And that’s right. That’s why it’s up to Microsoft to stop making a browser that’s broken and expecting people to work around them. And it’s also up to developers to stop coddling the browser that’s broken.

Why the doctype switch isn’t targeting

One problem in this debate is that people are confusing doctype switching with version targeting. Using a standard doctype is like a contract: I, the developer, support this standard of HTML and CSS, so that you, the browser, can render it properly according to the same standard. The standard provides a common language, a shared vocabulary, so that the garbage I put in to the system is the same garbage that comes out. Targeting a browser isn’t the same thing. When I use conditional comments or other CSS hacks, I’m saying “hey browser, you’re don’t understand this sentence in our standard vocabulary, so I’m going to give you a sentence that you understand.” That’s not the same thing as saying which vocab you’re using. It’s like talking to a child — if you use a word the child doesn’t understand, you talk around it, explain it, you don’t switch languages. If I use the new meta-tag, and I target IE7, IE8, or IE42, it should render my page the same, according to the contract I say I’m holding to in my doctype declaration. End of story. If they don’t then they’ve got bugs.

Really?

Are we really going this way? I can’t believe that this industry is even considering Microsoft’s proposal. If the browsers aren’t upholding their end of the contract, why should we work around them? Let them be broken, let people decide they don’t want a broken browser, let the bad browsers die.

Who doesn’t love chocolate?

That’s what I thought. Nobody raised their hands.

I love to make desserts that finish a meal in style, and this chocolate mousse certainly fits the bill. The best part is that it’s very easy to make.

Choose your chocolate wisely

Like with flourless chocolate cakes, you have to choose your chocolate very carefully. If you look at the ingredients for this recipe, it’s chocolate with a little bit of butter, some eggs, and a smidgen of coffee. If your chocolate is no good, your mousse won’t be any good either. The mousse will highlight the characteristics of the chocolate; if the chocolate is bitter, the mousse will be bitter. If the chocolate is very fruity, the mousse will be fruity. So choose carefully.

I tend to make this with the blocks of Ghirardelli (dark, of course) that Trader Joe’s sells. It’s a very good all-purpose chocolate.

Pots de chocolat

• 8 ounces of any semisweet chocolate, broken into chunks
• 1½ tablespoons butter
• 2-3 tablespoons of strong coffee, rum or brandy
• 3 eggs
• Pinch of salt

1. Put the chocolate, butter and coffee (or liquor) into a double boiler over moderate heat. Stir until completely melted and smooth.
2. Let the chocolate stand for a few minutes to cool.
3. Separate the eggs.
4. Once the chocolate has cooled slightly (it should still be warm), add the egg yolks one at a time, stirring until smooth after each addition.
5. Beat the egg whites and the salt until they hold a firm shape. They should be stiff, but not dry.
6. Fold the whites into the chocolate. Start with a large spoonful of whites, and fold it in. Then do a second large spoonful. Then do half of the remaining whites, and then the rest.
7. Gently transfer the mousse to serving dishes like ramekins, small bowls, or martini glasses.
8. Put the dishes in the fridge for 6-8 hours or overnight. If overnight, the texture will be firmer when eaten; be sure to cover them with plastic wrap so that the tops don’t dry out.
9. Serve with a dollop of whipped cream and a garnish — grated chocolate, a mint leaf, or some fresh berries.

This recipe makes 6–8 servings.

Enjoy!

Sometimes stupid software bugs just burn my bu**.

For one of my clients, I designed a 8.5×11″ flyer that’s going to a real printer. It’s a full-bleed piece, so the printer requested that I give them an eighth-inch bleed, with trim marks. I thought, “Oh. No worries. I’m using my brand-spanking-new-hot-off-the-presses copy of CS3, which will surely be able to handle this sort of thing. Well, you can see where this is going — it doesn’t. If you make an 8.5×11″ documentin Illustrator CS3, and then save it as a PDF with the appropriate bleed size and trim marks, you don’t get what you wanted. Illustrator crops the document at the artboard limits, which are 8.5×11″.

Some quick googling turned up a discussion of the problem, but not the solution I wanted.

But there is a work-around. I’ll give you a hint: it doesn’t involve CS3’s new crop area tool.

If you use the crop area tool, you get the same bug, so it’s no help.

The solution:

1. Add ¼” of width all the way around the artboard, making your document 9×11.5″
2. Save the document as a PDF
3. Open the new PDF in Acrobat 8
4. Go to Document > Crop Pages…
5. Set the TrimBox (shown below) to ¼” all the way around — to compensate for the ¼” we added before. You’ll see the bright green line in the preview window that now delineates the original 8.5×11″ document size.

   

6. Go to Advanced > Print Production > Add Printers Marks
7. Check “Trim Marks”

You should now see the trim marks! Don’t forget to save…

Even though I’ve started a new job, which I love by the way, my freelance work continues. Last week I launched the newly redesigned Oregon Ki Society site, and it’s now in my portfolio. This one is particularly near and dear to my heart, as I began training Aikido with the OKS 11 years ago, and still train today.

To be honest, when I first saw their site in 1996 I wanted to get my hands on it to fix it up. Little did I know they would still be using the same site in 2007, when I was finally in a position to do something about it. The new site is crisp, clean and fresh with lots of strong photography. I’m also quite proud of that since I shot most of the photos.

The content is interesting, too; there are Ki Society dojos all over the world, and so there might be one near you. If there is, it’s worth checking out. The aikido training the Ki Society offers is unparalleled.

Updated (12/11/07): The ruby-oci8 library just went to full 1.0.0 release. I’ve updated that section to reflect the new file names.

Updated (5/5/08): The oracle adapter installation has been on-again-off-again with successive Rails releases, but there’s an easy fix for it. I’ve updated the relevant section.

At my new job, I’m using Ruby on Rails to connect to multiple databases — multiple Oracle (10g) instances, as well as MySQL and FileMaker. There’s a lot of challenges to doing this, so I’m going to post some of the less obvious solutions as they come up.

The first challenge I had was to get RoR to talk to Oracle. There isn’t a lot of information about this online, because the people who tend to use Oracle are not the people who tend to use open source software like Rails.

Upgrade Rails to version 2.0

To start out, I wanted to use the most recent release candidate of Rails: version 1.99. I figured that I might as well upgrade before writing my first application, so that the codebase is all Rails 2.0 and up. Leopard comes with both Ruby and Rails, and upgrading is actually very easy:

sudo gem install rails --source http://gems.rubyonrails.org

Then enter “y” at each prompt, to install all of the dependencies. That’s it! Check yourself with

rails –v

You should see Rails 1.99.0 or Rails 2.0.

Getting Rails to talk to Oracle

Now,

sudo gem install activerecord-oracle-adapter --source http://gems.rubyonrails.org

This installs the oracle adapter. It doesn’t, however, install the Ruby oci8 driver. We’ll do that now.

Make sure you’ve got the Oracle Instant Client SDK installed in your Oracle Instant Client directory (/Library/Oracle/instantclient/10.1.0.3)

There’s a problem on new Intel Macs with this library. Oracle hasn’t seen fit to release an Intel version of the library in the past year and a half, and that’s going to cause problems since the Ruby binary is going to run as Intel-native, but the Instant Client will run under Rosetta. To solve this, we have to make a PPC version of the Ruby binary.

Make PPC and fat versions of Ruby

This is easier than it sounds. We don’t have to recompile, since the Ruby binary in /user/bin is fat. You can check this:

file `which ruby`

This should show you a PPC and a i386 version:

/usr/bin/ruby_fat: Mach-O universal binary with 2 architectures
/usr/bin/ruby_fat (for architecture ppc7400):	Mach-O executable ppc
/usr/bin/ruby_fat (for architecture i386):	Mach-O executable i386

All we have to do is extract the PPC version as a standalone binary, and trick the system into using that only. It will make our Ruby slower, but it will get Ruby to talk to Oracle, so I’m willing to take the performance hit. It’s so fast on the Intel Macs anyway, unless your Rails apps are doing massive amounts of processing, you probably won’t notice.

We’ll use ditto to extract the PPC version:

sudo ditto -arch ppc7400 /usr/bin/ruby /usr/bin/ruby_ppc
sudo mv /usr/bin/ruby /usr/bin/ruby_fat

Now we’ve got two versions of the Ruby binary — the original fat version, and a PPC only version.

There’s a catch here, though: we actually have two copies of the ruby binary on our system. The second binary is a part of the Ruby Framework, and that’s the binary that’s used by irb, rake and other very useful Rails helpers, so let’s fix this one too:

sudo ditto -arch ppc7400 /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby_ppc
sudo mv /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby_fat

Now we’ll need a facility for switching between the fat and PPC only binaries. Create /usr/bin/ppc_ruby.sh:

#!/bin/bash
ln -fs /usr/bin/ruby_ppc /usr/bin/ruby
ln -fs /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby_ppc /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby

Create /usr/bin/fat_ruby.sh:

#!/bin/bash
ln -fs /usr/bin/ruby_fat /usr/bin/ruby
ln -fs /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby_fat /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby

Now, make them both executable:

sudo chmod 0711 /usr/bin/ppc_ruby.sh
sudo chmod 0711 /usr/bin/fat_ruby.sh

Run ruby_ppc.sh to switch to using the PPC version:

sudo /usr/bin/ppc_ruby.sh

Verify this worked:

file `which ruby`

This should return /usr/bin/ruby: Mach-O executable PPC.

We’re getting closer. Now we need the ruby-oci8 library.

Compile the ruby-oci8 library

The most recent stable version of the oci8 library is 1.0.0. Download it and unpack the file in the finder: it should unzip into ~/Downloads/ruby-oci8-1.0.0.

Before we can compile this library, we have to fool the system into making it PPC only, or it’s not going to work. With your favorite text editor, edit /usr/lib/ruby/1.8/universal-darwin9.0/rbconfig.rb. Comment out line 17 ('-arch ppc -arch i386' and replace it with '-arch ppc'. Save your changes. Leave the file open in your text editor, because we’ll come back to it.

Now we can finish configuring the environment before we compile the library.

cd ~/Downloads/ruby-oci8-1.0.0
export DYLD_LIBRARY_PATH=/Library/Oracle/instantclient/10.1.0.3
export SQLPATH=/Library/Oracle/instantclient/10.1.0.3
ruby setup.rb config
make
sudo make install

Now you can go back to your text editor and restore line 17, save your changes and exit.

Test connectivity

At this point, we’re done. We’ve fooled our system into running a PPC version of Ruby under Rosetta, and we’ve installed the ruby-oci8 library. Now it’s a question of making sure that it works:

ruby /usr/bin/irb

In the IRb console, type:

require 'oci8'

If the console returns true, you’re in business.

Configure your database.yml

The last step is to make your application use the Oracle connection. In your database.yml, use the following to make it work:

development:
adapter: oracle
database: your_instance_name
username: your_user_name
password: your_password

The database name comes straight out of your /Library/Oracle/instantclient/10.1.0.3/network/admin/tnsnames.ora file. You don’t need to specify any other connection information in database.yml, since the tnsnames.ora file has everything you need.

Your application is now talking to Oracle!

sudo gem install rails --source http://gems.rubyonrails.org

Then, enter “y” at each prompt, to install all of the dependencies. That’s it! Check yourself with:

rails -v

Right now it will show Rails 1.99.0 which is the current release candidate. When rails goes fully 2.0, the same instructions should work to get the full release installed.

And don’t forget, you can always rake rails:freeze to lock a Rails app to a particular version of Rails by copying all of the Rails libraries into the /vendor directory.

Happy coding!

Avalanche lily

Really, twice. First was at the end of June: I completely forgot to note it here. I took a photo of Erythronium montanum at the top of Larch Mountain outside of Portland. It was a rainy day, which usually doesn’t make for good hiking, but we were under a thick understory for most of the hike so it worked. There were vast numbers of these very delicate avalanche lilies waiting for us near the top of the mountain, all covered with droplets. They are quite charismatic.

Wandering daisy

The second time was today, for a photo of Erigeron peregrinus ssp. callianthemus. I shot this one over this past weekend hiking up on Mt. Hood. It was a glorious day for a hike, with perfect weather and clear skies. More photos from this trip are in my Flickr stream.

As always, many thanks to Daniel Mosquin of the UBC Botanical Garden and his Botany Photo of the Day, which I really can’t recommend enough. Every day you get a beautiful photo in your feed reader, along with some understanding of the natural world that surrounds us. It really is an amazing planet.

Most recently, I wanted to code this algorithm:

If on the current page
  show <a href="blah1">link 1</a>
else
  show <a href="blah2>link 2</a>

Rails has, of course, the nifty link_to_unless_current, but all that does is show the text of the link:

If on the current page
  show link
else
  show <a href="blah">link</a>

That’s not quite what I’m looking for. But when I was looking up link_to_unless_current in the docs, I realized that there IS an else condition on link_to_unless_current. The function takes a block as its last parameter, and that’s what gives you the “else.”

This code, in a view:

<%= link_to_unless_current('Link text', my_url) { 'Alternate text' } %>

produces this algorithmic result:

If on the current page
  show Alternate text
else
  show <a href="my_url">Link text</a>

Mission accomplished.

Once again it seems I owe my thanks to Daniel Mosquin from the UBC Botanical Garden for choosing my photo of Acer japonicum, the japanese maple, for yesterday’s photo of the day. That’s two in two months; we’ll see if I can make a third. If you read his comments I think that he’s completely right — there is something very appealing about the Japanese maples in the winter time, because of their architectural shapes. I took this photo shortly after a big rain, and the way the sunlight was catching the drops was so appealing that I couldn’t resist. I think that it makes the tree look somehow much more ancient than it really is.

My upstairs neighbor gave us some macha: Japanese powdered green tea. The Japanese are the only people on the planet who still drink this stuff — it’s a very primitive form of tea, and when brewed it’s quite bitter. They eat it with sweets that are too sweet, alternating bites of too-sweet with sips of too-bitter, and it all balances out.

I like drinking macha, though; but I’d rather make delicious tasty desserts with it, like this one which I made this afternoon. The recipe is based on the “Rich roll cookies” from Joy of Cooking.

Green tea cookies

Rich green tea roll cookies

• 1 cup softened butter
• 2/3 cup sugar
• 1 egg
• 1 teaspoon vanilla
• 2¼ cups flour
• 1 tbsp. powdered green tea
• 1/2 teaspoon salt

Cream together the butter and sugar. Beat in the egg and vanilla. Sift together the dry ingredients, and stir in to the butter mixture. Since there is almost no water in the dough, don’t worry about over-working it. When the dough has an even color and texture, form it into a ball and chill for 3-4 hours.

Preheat the oven to 350°.

Roll the dough out on a very, very lightly floured surface. Too much flour is death for these cookies. Cut them into your favorite shapes with a knife or cookie cutters. Bake them on a cookie sheet that either has a piece of parchment paper on it or has been lightly greased, for 8-10 minutes or until the corners get slightly brown.

Eating them reminds me of being in Japan!

Many thanks to Daniel Mosquin from the UBC Botanical Garden for choosing my photo of Zantedeschia aethiopia, also known as the calla lily, for today’s photo of the day. Woohoo!

For the record, I shot this image in western Australia, where the calla lily is highly invasive and is causing quite a bit of ecological upheaval in the tuart forests.

Although this page went live a little while ago, I’ve just gotten around to writing it up. A scientist at the University of Santa Barbara contacted me about making a professional page for her. I’ve added it to my portfolio. I’m particularly happy about the image at the bottom of the page behaves: use a big screen and make your browser window wide. Very wide.

I hope that the page will help Claudia advertise her work both to other scientists as well as to potential students and field assistants.

I can’t resist, this is too good to be true: there is such a thing as an urban cactus. It’s a housing project in Rotterdam, based on a cactus. By placing the balconies as the architects did, every resident gets a double-height outdoor space and more sunlight than they would with a typical balcony. I think it’s brilliant.