Just In Time

The Real Goal of Education

2008-07-16T08:45:00.000-07:00

Is education about memorizing facts? No, it's about learning to learn. It's about learning how to think.

"...developers today code in something called Python, but when I was in school C was all the rage. The need for reasoning, though, remains constant..." - Our Googley advice to students: Major in learning

DataMapper: Many-to-many

2008-06-23T18:55:00.001-07:00

You can define many-to-many associations using this syntax:

#item.rb
has n, :things, :through => Resource

#thing.rb
has n, :items, :through => Resource

In this case it will create a table items_things to manage the assignments. Easy enough. Depending on the relationship you are mapping out, it may make more sense to use the :through => :model syntax.

Now if you create an instance of an Item, you will get a method "things=". At first I thought this would be how you would assign a new Thing to your Item. Such as:

@item = Item.get(1)
@thing = Thing.get(1)
@item.things = @thing

FAIL! If you try adding a single Thing to your Item with this method you will receive a failure that the class you sent did not have a map method defined. Ah, ok. That makes sense, things= is obviously plural and will want an array of things. So how do you assign just one thing?

If you are unsure, a handy tool is to remember the "methods" method. So in this case you can try out:

@item.methods

You will see that you have not only a "things=" method, but also a plain old "things" method. If you try:

@item.things.methods

You will see that you have a << method, as should be expected. So to add our single Thing to our Item we do:

@item.things << @thing

That's it.

DataMapper: Parent / Child Relationship

2008-06-06T20:08:00.000-07:00

I couldn't find an example at datamapper.org /docs for a parent child relationship.

After a little searching, I found the answer in the integration tests. Here is the example:


 class Node
   include DataMapper::Resource

   def self.default_repository_name
     ADAPTER
   end

   property :id, Integer, :serial => true
   property :name, String

     has n, :children, :class_name => 'Node', :child_key => [ :parent_id ]
   belongs_to :parent, :class_name => 'Node', :child_key => [ :parent_id ]
 end

Hope that helps someone else.

Marshal data too short

2008-03-13T15:33:00.000-07:00

If you marshal data and then store it in a DB, make sure to either base64 encode it or store it in a binary data type (such as BLOB), otherwise it will probably cause errors.

Merb Monday: Vacation Edition

2008-03-03T10:00:00.000-08:00

I'm on vacation visiting family (with limited Internet access). Back to semi-normal next week.

Merb Monday: The Leap Year Edition

2008-02-25T13:27:00.000-08:00

News
Official documentation has been updated to include 0.9. Still a little light, but coming along. If you would like to help, create your own git branch and have at it!

Ivey had a baby. Congratulations!

Expect 0.9.1 (developer release) today (or soon).

You get an "extra" day this week. Use it wisely.

Teaser
Code name: Merblets.

Q&A

Q: What!? No RJS?

A: You can do anything rjs can do with *.js.erb templates (Answer by ezmobius)

Q: I read that Merb is template agnostic. What templates languages do I have available?

A: erb out of the box (erubis), haml (merb_haml as a dependency in init.rb), markaby (Answer by sqred)

Q: What does a named route in Merb look like?

A: r.match("/login").to(:controller => "Sessions", :action => "new").name(:login)
(Answer by jodo)

Q: Does Merb have a debugger tool?

A: You can use ruby-debug. Start Merb with the -D option to enable ruby-debug support.
Enter "debugger" somewhere in your code as a breakpoint. (Answer by jdempsey)

Q: How do I find out what version of Merb I'm using?

A: merb -v (Answer by ezmobius)

Q: How can I see the current routes?

A: merb -i
merb.show_routes
(Answer by ezmobius)

Q: Can the cookie session be used for large production apps?

A: As long as you don't store really sensitive info in the session then cookie sessions are fine (Answer by ezmobius)

Merb Monday: State of flux

2008-02-18T14:47:00.000-08:00

This week's edition is a little short. Certainly not for lack of activity in #merb, but due to the continued disturbance in the force caused by the 0.9 transition.

0.5 to 0.9 is a big jump (no wonder they skipped 0.6, 0.7 and 0.8!) Most of the discussion this week continued to be related to the transition to 0.9 and trouble ticket type "stuff".

News
0.9 was released (kinda), however this is a "developer" release and still has some wrinkles to be ironed out before a general public release will be pushed to RubyForge. If you are anxious to give it a spin, check Merbivore.

It looks like there will likely be a 0.9.1 "developer" release in the near future. Once we get to a 0.9.x general public release things should settle down and this series should get back to normal.

merbful_authentication should soon be updated to be compatible with 0.9.

Required Reading
0.9 introduces some really cool changes. One of those is Rack integration. You should read Ezra's post "So merb-core is built on rack you say? Why should I care?"

Q: If I use ActiveRecord as the ORM, do I then use ActiveRecord's migrations (and its syntax) by default?

A: Yes. You can use ActiveRecord with Merb as you would with Rails. (Answer by amoeba)

Q: How do you generate an app in Merb 0.9?

A: ./script/generate is gone. In it's place now lives merb-gen.

merb-gen myapp # a normal merb app merb-gen myapp --flat # a flattened app merb-gen myapp --very-flat # a single-file app

(Answer by ivey)

Answer Of The Week

And the answer to many of the questions this week which followed the format of:

Q: _____________________ in Merb 0.9?

A: "It's not in -core anymore" (Answer by ivey)

Audience Participation

Q: Assuming you are using ActiveRecord with Merb, how can you share models with a Rails application?

If you leave your answer in the comments, I'll post it next week. (hint) (Question & link by seebg)

Merb Monday: "That's the spirit"

2008-02-11T06:37:00.000-08:00

Tidbits from #merb for the week of Feb 4 - Feb 10.

A lot of the conversation this week revolved around the pre 0.9 release. Many of the questions involved bugs or other issues that one can expect in a pre-release. In general I didn't include them as they will quickly be outdated and likely be of little on going value.

Q: How do I install (freeze) gems within my application?

A: Navigate to the root of your Merb application.

gem install foo -i gems

In your merb.yml file include a line:

dependency "foo"

(Answer by wycats)

Q: How do I support a new MIME type? Say for an Atom feed.

A:

Merb.add_mime_type(:atom,:to_atom,%w[application/x-atom])

Replace application/x-atom with whatever the correct header for atom is then make a template: foo.atom.erb

In your controller, use:

provides :atom

(Answer by ezmobius)

Q: Where could I define a constant which would then be accessible in different views, but should have a different value depending on the environment merb is running in?

A: config/environment/*.rb where * represents the desired environment, for example development.rb.

Q: How do I find the current controller and action in the view?

A: In a helper you could create the two following methods.

def controller_name controller.request.controller_name.split('_').first end def action_name controller.request.action end

(Answer by slurry)

Q: What happened to MERB_ENV?

A: Merb's application constants have been re-factored as follows:

Old constant : New method MERB_FRAMEWORK_ROOT : Merb.framework_root MERB_ROOT : Merb.root MERB_VIEW_ROOT : Merb.view_path MERB_SKELETON_DIR : Merb.skeleton_path MERB_LOGGER : Merb.logger MERB_PATHS : Merb.load_paths MERB_ENV : Merb.environment

(Answer by slurry)

Q: Is there a way to list all the generators available?

A: ruby ./script/generate

Q: Where is the source now?

A: The Merb project has switched from using SVN to Git for source code management. With that change the source is now at Github. Specifically you will want to use wycats repo, which you can find at: git://github.com/wycats/

The source code is broken down into merb-core, merb-more, and merb-plugins.

For more information on how to work with Git, see "So you want to contribute to Merb-core".

Once you have cloned the Git repos to your local system, you will then move into that directory and issue a "rake install" command to build the gem.
(Answer by ivey)

Q: Where are bugs / tickets being tracked now?

A: Along with the move to Github, bugs and ticket tracking has been moved from DevJaVu over to Lighthouse, specifically at merb.lighthouseapp.com.

Answer of the week

Here is one little snippet of conversation that may provide the answer regardless of your specific problem:

Q: Can I do _____________?

A:
hassox: I guess so
hassox: but I can't really help you on it...
grrt: :) I'll see how far I get
hassox: that's the spirit :)
grrt: it's great to just explore

Sometimes it's best to just try something out.

Audience Participation

Q: Merb-core has methods "render" and "display". What's the difference?

Leave your answer in the comments. (Hint)

Working Remotely: The "Get Real" List.

2008-02-04T11:00:00.000-08:00

Every once in a while a post shows up on Digg or elsewhere about how to work remotely. Often it will be phrased like "How to work from the beach".

After reading these lists, I can't help put wonder... "do any of these people have any idea what they are talking about?"

Most of these articles are nothing more than recommendations for various online applications from flickr to mozy to zoho - which in my opinion have nothing to do with your ability to work remotely or not.

My Credentials
I lived in Cerro Punta, Chiriqui, Panama for 14 months. That's up in the mountains... in Central America... where most people don't have telephone service... or refrigerators.

How To Really Work Remotely
(from the beach or wherever you want)
The ability to do this has nothing to do with online applications. Here are the seven requirements that I needed:

1) Laptop
A laptop is the tool of choice for a number of reasons. It is easy to transport to your destination. If the power goes out, you still can work (and hopefully it will come back on before your battery dies).

2) Battery Back-Up / UPS / Surge Protector
With a laptop, the battery back-up portion may not be as critical - but you definitely will want to have all of your hardware plugged in to quality surge protector. Surges happen.

3) Data Back-Up
Your business likely depends upon your data. Get an external drive and make sure you are regularly backing up your data. As a second step, an internet based back-up can't hurt. But with a slower Internet connection (or even a fast one) this may be a slow way to recover your data in case of a catastrophe, and thus I wouldn't recommend it as your only back up.

4) Internet
The Internet itself, not the online applications, is your connection to the outside world. Depending on your specific usage, the speed and reliability required will vary. You may also wish to secure two means of connection, as the reliability may be less than you are used to. I was able to secure a cellular based service (advertised at 256K, but more like 56-128k down/15k up), and also a wireless service (1MB up/down). The cell service was slow, but cool that it basically worked country-wide (yes, even at the beach). Between the two I was able to have very reliable service and even good enough quality for VoIP phone calls.

5) Phone number
You (likely) need a phone number that can follow you wherever you happen to be. I used Packet8's VoIP service for my business line. This meant I could simply plug my little VoIP box into my router in Panama, and all my incoming / outgoing calls went through my TX number. Skype also worked pretty well.

6) A local relative / friend
Mail still needed to be picked up from my PO Box. Checks still needed to be deposited in my Bank account. Having a trustworthy person that you are able to turn these simple, but important, tasks over to will be a huge help. There are mail processing services available, but not in every city (or even state). Having clients send mail to an address in a different state might make them uncomfortable.

7) A business / job that does not require your physical presence
In the end this is the one that didn't work out. My line of work lends itself to remote work extremely well. Even when I am local, in person contact is very limited during the course of a project. The problem that arose was the initial phase of acquiring new projects. I would get leads, perform the initial interviews & evaluations, compile a proposal and even get the proposal accepted. But then many clients would want to meet face to face to sign the contract. Obviously this won't be true for every business, or geographical location, but for my principally Texas based clients this became a sticking point.

So that's what worked for me. For 14 months. In a cloud forest in Central America. And amazingly I didn't need any online applications to do it!

Merb Monday: Environment variables, partials, etc.

2008-02-04T09:00:00.000-08:00

I see a lot questions asked and answered in the #merb IRC room.

Many of them are questions that later I wish I remembered the answer to! So I'm going to try to keep track of questions I see asked and answered and record them here for the benefit of myself and others, and hopefully publish them here every Monday.

I might re-phrase the questions and answers slightly, as the writing tends to be quite terse on IRC.

Q: How do you check the current environment in Merb? I'm looking for the Merb equivalent to RAILS_ENV.

A: Merb.environment (Answered by: Booster)

Q: How do you render partials?

A: You use the partial method.

Scenario 1: You wish to render a partial template found in the same directory as your action's view template.

partial :foo

This will look in the current directory for a file named _foo.html.erb

Scenario 2: You wish to render a partial template found in a different directory than the action's view template.

partial 'common/foo'

This will look for the file views/common/_foo.html.erb
(Answered by: jp_n9)

Q: I'm trying to run my db:migrate and I'm getting a "no such file to load -- spec/rake/spectask" error.

A: Make sure you have the rspec gem installed.

sudo gem install rspec

(Answered by: octopod)

Q: How do I start merb in production mode?

A: Use the -e option. For example,

merb -e production

For a complete list of parameters type:

merb --help

(Answered by: Phoop)

Q: How do I get Merb to log data to the log file?

A: Make sure that you start Merb as a daemon with the -d directive, this will cause output to be logged to the log file located in the log/ directory (instead of being output to the console window).

merb -d

(Answered by: ezmobius)

Q: How can I use HAML for my templates?

A: Name your files with the .html.haml extension instead of the default .html.erb extension.

Example: name.html.haml

Second, you need to edit dependencies.rb to include the line:

dependency "haml"

You will also need to have the haml gem installed on your system. Restarting Merb will also likely be required. (Answered by: QaDeS, bradly)

Q: Is there an easy way to get the current URL in a merb view?

A: I think it's request.uri (Answered by: hassox)

In my testing the request variable does not appear to be directly available from a view template. However if you need that information you can easily pass the entire request variable, or just request.uri, into your view from the controller.

Monitoring Swiftiply & Merb with Monit

2008-01-31T10:09:00.000-08:00

Swiftiply combined with Merb is a pretty nice way to serve up your application. And while we hope that both are stable, it would be nice to know that just in case anything went wrong they would restart. It would also be nice for the application to automatically start upon reboot.

That is what we are going to attempt to setup using Monit.

Prerequisites:
We assume you already have Swiftiply and Merb setup and functioning properly. We are also assuming that you have Monit installed and functioning properly.

Versions:

Ubuntu 7.10 (Gutsy)
Ruby: 1.8.6
Merb: 0.5.2
Swiftiply: 0.6.1.1
Monit 4.8.1
Assumes your Merb app is "frozen" (rake merb:freeze)

Those are the version I was using at the time of the article. Different versions may lead to varying results.

Setup Monit To Auto-Start

> sudo vim /etc/default/monit

This is a pre-existing file. Edit as follows:

startup=1

Create init script for Swiftiply
The big problem with trying to monitor Swiftiply was that it does not write a pidfile for Monit to track. Fortunately someone solved the problem, and Google found it. Big credit for the script: http://pastie.textmate.org/107044.txt

> sudo vim /etc/init.d/swiftiply

This will be a new blank file. Edit as follows:

#!/bin/bash function generatepid(){ current_pid=`pgrep -f 'swiftiply -c /etc/swiftiply.conf'` pidfile_pid=`cat /var/run/swiftiply.pid` if [[ $current_pid = '' ]]; then rm /var/run/swiftiply.pid elif [[ $pidfile_pid != $current_pid ]]; then echo $current_pid > /var/run/swiftiply.pid fi } case "$1" in start) echo -n "Starting swiftiply:" swiftiply -c /etc/swiftiply.conf generatepid echo ;; stop) echo -n "Stopping swiftiply:" killall -9 swiftiply generatepid echo ;; restart) $0 stop $0 start ;; pid) generatepid ;; *) echo "usage: $0 [start|stop|restart|pid]" esac exit 0

This does assume that you Swiftiply configuration file is location at /etc/swiftiply.conf, if not change to the correct location.

Create init Script For Your Merb App
I will use "app1" but you can replace that with whatever name you would like as an identifier for this specific Merb application.

> sudo vim /etc/init.d/merb_app1

This will be a new blank file. Edit as follows:

#!/bin/bash case "$1" in start) echo -n "Starting Merb for App1:" export SWIFT=1 export HOME="/home/admin" #Assuming you have a user admin cd /full/path/to/your/app/current/ sudo ./script/merb -d -h 127.0.0.1 -p 30000 -e production echo ;; stop) echo -n "Stopping Merb for App1:" cd /full/path/to/your/app/current/ sudo ./script/stop_merb echo ;; restart) $0 stop $0 start ;; *) echo "usage: $0 [start|stop|restart]" esac exit 0

The -p directive should point to the same port that you have configured Swiftiply to listen to for this specific app. Also, this is assuming that you have Merb frozen. If not, then you will need to change "./script/merb" and "./script/stop_merb" to their unfrozen counterparts.

Set Permissions
Without these permissions set to execute the init scripts will not work.

> sudo chmod 755 /etc/init.d/swiftiply > sudo chmod 755 /etc/init.d/merb_app1

Configure Your Main Monit File

> sudo vim /etc/monit/monitrc

Add the following in to the pre-existing configuration:

check process swiftiply with pidfile /var/run/swiftiply.pid group root start program = "/etc/init.d/swiftiply start" stop program = "/etc/init.d/swiftiply stop" if 5 restarts within 5 cycles then timeout include /etc/monit/app1

Configure App1 Monit File
You could have just added the following in the main file, but I prefer to use the include statement and keep them in separate files.

> sudo vim /etc/monit/app1

This will be a new blank file. Edit as follows:

check process merb_app1 with pidfile /full/path/to/your/app/current/log/merb.30000.pid start program = "/etc/init.d/merb_app1 start" stop program = "/etc/init.d/merb_app1 stop" if 5 restarts within 5 cycles then timeout depends on swiftiply

30000 should be replaced with the specific port that you have Swiftiply listening on for this application. The "depends on swiftiply" will make sure that swiftiply is started first.

Does it work?

It'd take a miracle...

> sudo monit -t > sudo /etc/init.d/monit force-reload > sudo monit validate > sudo monit summary

Caveats
This setup only checks to make sure the processes are up and running.

Right now Merb overwrites log/merb.port#.pid with the last mongrel process started.

Unfortunately that means if you start 5 mongrels, you will only have the pid of the last one, and thus will only be able to monitor that one process with Monit.

On the up side, it still means you can guarantee at least one process to be up and responding to requests - which is better than none.

Update

Merb 0.9 is supposed to add the ability to specify a pidfile which will allow us to monitor multiple Merb processes even on the same port.

Useful?

If so, why not recommend me on Working With Rails!

Book Review: Programming Erlang

2008-01-30T08:15:00.000-08:00

Author: Joe Armstrong

Erlang really appears to be an interesting language, and the author's enthusiasm for the subject shows - which is good. It helped me to keep going, when at times the code was a little hard to follow.

The book does a good job of introducing the language. In particular later chapters give emphasis to the topics of concurrency through multiple processes, multi-cores and distributed programs. All very timely subjects for a world that is connected to the Internet, and where even laptops have multi-core processors

Unfortunately, I feel the author somewhat forgot his audience.

On page 5 he starts out with a description that fit me almost perfectly, and probably many other readers: "Once upon a time a programmer came across a book describing a funny programming language. It had an unfamiliar syntax [...] it wasn't even object-oriented. The programs were, well, different....Not only were the programs different, but the whole approach to programming was different."

After reading the book I don't feel like the "Erlang Master" that the road map described (pg 9). While the syntax is now familiar, I still look at the Erlang code and it feels foreign. I still have to "decipher" the code instead of read it.

I would have liked the book to more fully address the items from the "Once upon a time" paragraphs. Being that "the whole approach to programming" is different than the OO that many readers are used to, I would have liked to have seen a chapter (or three) on how to best get into that mode of thinking.

I do think the book is a good jumping off point. It gives you more than enough to get started.

However, if you are unfamiliar with languages where functions accept functions which also accept functions as parameters and in turn returns another function as a result, you may end up feeling (as I did) that you only have half the puzzle.

Serving PHP5 with Nginx on Ubuntu 7.10 (Gutsy)

2008-01-27T11:35:00.000-08:00

There are lots of tutorials out there to setup PHP with Nginx. I'm probably just retarded, but none of them got me to a working system. A detail left out of one, a configuration file left out of another, etc.

What follows is exactly what I did to get Nginx to serve PHP5 on a fresh Slicehost VPS slice running Ubuntu 7.10. Hopefully it will help someone else.

NOTE: The following commands assume that you have already setup a user account with sudo privileges and are executing the commands as that user, NOT as root.

Update your system and install basic tools required

> sudo aptitude update -y > sudo locale-gen en_GB.UTF-8 > sudo /usr/sbin/update-locale LANG=en_GB.UTF-8 > sudo aptitude safe-upgrade -y > sudo aptitude full-upgrade -y > sudo aptitude install build-essential -y

Install MySQL

> sudo aptitude install mysql-server mysql-client libmysqlclient15-dev -y

Install PHP5

> sudo aptitude install php5-cli php5-cgi php5-mysql php5-xcache -y

Note: Xcache is installed at this point and available for you to setup, but by default is not turned on.

Install Nginx

> sudo aptitude install nginx -y

Go to your IP address and you should now recieve the message "Welcome to nginx!"

FastCGI Parameter Configuration

We will place all of our fastcgi parameters in a single file which we can include in as necessary.

> sudo vim /etc/nginx/fastcgi_params

This will be a new empty file, add the following and save:

fastcgi_param QUERY_STRING $query_string; fastcgi_param REQUEST_METHOD $request_method; fastcgi_param CONTENT_TYPE $content_type; fastcgi_param CONTENT_LENGTH $content_length; fastcgi_param SCRIPT_NAME $fastcgi_script_name; fastcgi_param REQUEST_URI $request_uri; fastcgi_param DOCUMENT_URI $document_uri; fastcgi_param DOCUMENT_ROOT $document_root; fastcgi_param SERVER_PROTOCOL $server_protocol; fastcgi_param GATEWAY_INTERFACE CGI/1.1; fastcgi_param SERVER_SOFTWARE nginx; fastcgi_param REMOTE_ADDR $remote_addr; fastcgi_param REMOTE_PORT $remote_port; fastcgi_param SERVER_ADDR $server_addr; fastcgi_param SERVER_PORT $server_port; fastcgi_param SERVER_NAME $server_name; # PHP only, required if PHP was built with --enable-force-cgi-redirect # fastcgi_param REDIRECT_STATUS 200;

Nginx Configuration

> sudo vim /etc/nginx/sites-available/default

This is a pre-existing file. Find the part that looks similar to the following and edit it as so and save:

location ~ \.php$ { fastcgi_pass 127.0.0.1:9000; fastcgi_index index.php; fastcgi_param SCRIPT_FILENAME /var/www/nginx-default$fastcgi_script_name; include /etc/nginx/fastcgi_params; }

We need to remember to restart Nginx so that it picks up our configuration changes.

> sudo /etc/init.d/nginx stop > sudo /etc/init.d/nginx start

Spawn-fcgi

We still need a script to start our fast cgi processes. We will extract one from Lighttpd.

> mkdir ~/sources > cd ~/sources > wget http://www.lighttpd.net/download/lighttpd-1.4.18.tar.bz2 > tar -xvjf lighttpd-1.4.18.tar.bz2 > cd lighttpd-1.4.18 > ./configure > make > sudo cp src/spawn-fcgi /usr/bin/spawn-fcgi

Let's get automated!

> sudo touch /usr/bin/php-fastcgi > sudo vim /usr/bin/php-fastcgi

This is a new empty file, add the following and save:

#!/bin/sh /usr/bin/spawn-fcgi -a 127.0.0.1 -p 9000 -u www-data -f /usr/bin/php5-cgi

Next...

> sudo touch /etc/init.d/init-fastcgi > sudo vim /etc/init.d/init-fastcgi

This is also a new empty file, add the following and save:

#!/bin/bash PHP_SCRIPT=/usr/bin/php-fastcgi RETVAL=0 case "$1" in start) $PHP_SCRIPT RETVAL=$? ;; stop) killall -9 php RETVAL=$? ;; restart) killall -9 php $PHP_SCRIPT RETVAL=$? ;; *) echo "Usage: php-fastcgi {start|stop|restart}" exit 1 ;; esac exit $RETVAL

We need to change some permissions to make this all work.

> sudo chmod 755 /usr/bin/php-fastcgi > sudo chmod 755 /etc/init.d/init-fastcgi

Create a Test File

> sudo vim /var/www/nginx-default/index.php

Let's just print out the information page for our PHP installation.

<?php echo phpinfo(); ?>

Start It Up

> /etc/init.d/init-fastcgi start

Now go to your IP address/index.php and you should see the PHP info page displayed.

Set To Startup Automatically Upon Reboot

> sudo update-rc.d init-fastcgi defaults

You might want to test and make sure that it actually starts up upon reboot...

> sudo reboot

Final Words
If you think I have done anything stupid in the way this is setup, you may very well be right! Please leave a comment with a suggestion on how to improve the setup.

You probably will want to look into configuring Nginx for VirtualHosts, which is not considered in this post.

Credits
Much of this information was taken from the excellent post: How To Install A Complete LEMP (Linux - EnginxX (Nginx HTTP SERVER) - Mysql - PHP) Server (Not LAMP...) On Ubuntu/Debian, which got me about 90% there.

Merb: Multiple CSS files, one server request.

2008-01-18T12:01:00.000-08:00

In my previous post Continued Education: Performance Yahoo I referred to Steve Souder' book "High Performance Web Sites".

Rule #1 is "Make fewer HTTP requests."

Now we already know that Merb is "built for speed", but generally that is considered within the context of the server side of things.

I was happy to see that Merb also allows us to follow Souder's #1 Rule for making the client side snappy too. So how does Merb allow us to make fewer HTTP requests? By dynamically combining multiple stylesheet or script files into one.

Let's see some code!
It's this simple:

# app/views/layout/application.html.erb <% require_css :reset %> <% require_css :master %> <%= include_required_css :bundle => true %>

We define the various CSS files we wish to be included using require_css (in this example reset.css and master.css), then by setting the :bundle => true paramenter everything will be served up in a single HTTP request in a file called all.css! Now that's pretty cool.

But wait there's more!
The same technique works for Javascripts too.
You can have the same functionality for your javascripts using this syntax:

<% require_js :foo $> <%= include_required_js :bundle => true %>

But wait there's even more!
Now what is really cool is that you don't have to place your require_css or require_js statements only in the layout. You can place those in your views or even partials. ~~That means that for any given request, the bundled file will only include the files that are needed for that specific view.~~ Edit: It looks like you may need to manually define and uniquely name each possible combination of files. It also appears that a CSS file required in a view will appear first in the generated combined CSS file and thus be over ridden by the (likely) more general file defined in the layout - which probably isn't the desired behavior.

Getting it to work
By default the bundling action should only occur when in production mode. At the moment (Merb 0.5.2) it appears there is a bug and the bundling action doesn't realize when it is in production mode - so nothing happens.

What you need to do is edit your config/merb.yml file and uncomment the line that reads:

:bundle_assets: true

That's it! Should work. Enjoy.

One Gottcha
By forcing :bundle_assets to true in the merb.yml file, we are enabling this functionality for all environments instead of just for production. This isn't really ideal

Credits
Thanks to dudleyf in #merb for helping me figure this out. Thanks to codahale for writing the code for :bundle.

Continued Education: Performance Yahoo

2008-01-18T10:08:00.000-08:00

In this edition of "Continued Education" I'm linking up Steve Souders' (Chief Performance Yahoo!) Google Talk "High Performance Web Sites: 14 rules for faster pages".

I've recently been reading his book that covers the same topic, but sometimes it's nice to be able to just veg-out and watch.

Good practical information that is fairly easy to implement and can greatly improve our users' experiences.

To Git, or not to Git.

2007-12-14T07:35:00.000-08:00

I just read Joe Moore's (Pivotal Labs) thoughts on the Linus Torvalds' Git talk that was presented at Google.

I had also watched Linus' Google Talk video about a month ago, and had been hearing about Git in the Merb IRC room.

Git: A cruel piece of software?
The chairman introducing Linus describes Git as "a revision control system which is expressly designed to make you feel less intelligent than you thought you were" and as "a software tool which only he [Linus] is smart enough to know how to use." Was he joking or partly serious? I wasn't entirely sure.

With that preface, I had the impression that using Git was going to have a cliff like learning curve. Nevertheless, I decided to give it a try so I could at least know what others were talking about.

A collaboration of 1
Unlike Pivotal Labs, I'm just a solitary developer using SCM to track changes on my own code. So my needs are fairly limited. I don't really have any "collaboration" needs.

For someone with my limited SCM needs, probably any SCM would work just fine.

Initial thoughts
After using Git a bit, here are a my basic thoughts.

It's actually not too difficult at all (at least at a basic user level).
It is a command line tool. That's fine for me, as I always have a terminal open anyways.
Basic commands are easy to remember: "git status", "git add", "git commit", "git push"
It's pretty easy to setup custom ignore files and setup a remote repo.
Committing locally is fast & independent of your internet connection.
Deployment via Capistrano (v2.1) supports Git.

It appears that branching and merging are very easy, but honestly I don't really do too much (ok, any) of either. I will experiment with that in the future to see if it adds any value to my specific work flow.

You won't find the same level of application support for Git as SVN at the moment. For example, the other day I read about the release of SVNmate, a bundle for Textmate which adds some SVN status icons to your files. There currently is not a bundle offering the same for Git (although there is a bundle "work in progress"). Not necessarily deal-breakers, but things to be aware of.

Personally, I'm going to continue using Git and become more familiar with it's capabilities.

NOTE: Git does have the gitk command which opens a GUI. I haven't used it, other than a cursory glance, and thus am not familiar with it's features.

Related Resources:
Git Cheat Sheet: http://zrusin.blogspot.com/2007/09/git-cheat-sheet.html
Git Tutorial: http://www.kernel.org/pub/software/scm/git/docs/tutorial.html

Merb Tidbit: Logging

2007-12-10T07:14:00.000-08:00

Merb has it's handy built in Mongrel server, so you can easily start it up while developing with:

merb

However, you may wonder "Why isn't it generating any log files?"

Well actually it is, but the deal is they are all being output to the command line instead of being written to a file in the log/ directory. If you want to have them written to a log file, you need to start Merb up as a daemon. This is simply done like so:

merb -d

Now your logs will be written to the log/ directory. To stop the background merb process, use the -k PORT flag. For example, if you are running on port 4000 (which is the default) you would use:

merb -k 4000

You can also control the level of detail to be logged using the -l flag. Optional logging levels which can be passed with the -l flag include: DEBUG, INFO, WARN, ERROR and FATAL.

That's today's Merb tidbit. Happy Merbing!

Great Quote: Paul Rand

2007-11-21T13:52:00.000-08:00

I heard this quote in a video the other day. It struck a chord with me and I wished to share it for your consideration:

"Don't try to be original, just try to be good."
- Paul Rand.

Rails on Swiftiply / Mongrel

2007-11-15T10:33:00.000-08:00

Hosting Ruby on Rails is complicated, right? Not necessarily. Let's take a look at a fast and flexible way to serve up your Rails application.

Rails on Swiftiply / Mongrel
If you have done any reading or work with Rails you have probably heard of Mongrel. According to the Mongrel site, "Mongrel is a fast HTTP library and server for Ruby".

You may not have heard of Swiftiply yet. But you will. Well, actually I guess you just did. But you will no doubt be hearing more about it. Swiftiply "is a very fast, narrowly targetted clustering proxy". The Swiftiply website says "scaling your web applications should be easy". Sounds good to me. Let's see if it is!

Prerequisites
We will assume that you have already properly installed and configured the following:
Ruby
RubyGems
Rails

Version Info

Here are the most recent versions tested at the time of this article. Different versions may cause varying results.

OS: Ubuntu 7.10
Ruby: 1.8.6
RubyGems: 1.0.1
Swiftiply: 0.6.1.1
Mongrel: 1.1.3
Rails: 2.0.2

Installation: It's a breeze.

sudo gem install mongrel --include-dependencies
sudo gem install swiftiply --include-dependencies

I told you it was a breeze.

Configuration: Piece of cake.
Let's go ahead and configure Swiftiply first. Swiftiply does not install a configuration file for you, so you are creating a new blank file in the following step:

sudo vim /etc/swiftiply.conf

Here is the configuration that I used:

cluster_address: 123.45.678.9  # Use your IP here
cluster_port: 80
daemonize: true
epoll: true
epoll_descriptors: 20000
map:
- incoming:
 - sample.com
 - www.sample.com
outgoing: 127.0.0.1:30000 # Where Mongrels will connect
default: true
docroot: /var/www/sample.com/current # Rails root
cache_directory: public
redeployable: true
cache_extensions:
 - htm
 - html
 - txt

Amazingly that is all that is required in the way of configuration. If you wanted to serve up other applications on other domains or sub-domains, simply repeat the "map:" section for each.

Start up Swiftiply with:

swiftiply -c /etc/swiftiply.conf

With Swiftiply running, now all you need to do is start Mongrel(s) from within the directory of the Rails app you wish to serve. We let the system know that we want to use the special Swiftiply version of Mongrel with the "env SWIFT=1" directive. We also tell them to connect to the IP and port that you defined in your swiftiply.conf, like so:

env SWIFT=1 mongrel_rails start -d -a 127.0.0.1 -p 30000

You may also wish to include the directive "-e production", but I ran out of room on the line! ;)

Now if you want multiple mongrels serving up your app, just start another one up exactly the same. Same IP and port.

And now... your done.
And that is it. You have your basic Swiftiply / Mongrel stack setup.

Keep your eyes on Swiftiply as there will be some exciting new features be adding in the coming weeks and months.

Performance
With a blank Rails 1.2.5 application I show the following memory usages in "top":

Ruby (Mongrel): 47M
Swiftiply: 17M

For some statistics on performance of Swiftiply, please see the post "Testing Various Configurations of Rails, Merb, Swiftiply and Nginx" on Webficient.

Stuff To Know
Here are a couple things to remember about Swiftiply as you are setting it up:

Each application you wish to serve will be linked to ONE port.
All mongrels serving that application will connect to the exact same ONE port.
Even if you have (n) mongrels, they all connect to the exact same ONE port per application.
Swiftiply can serve multiple applications, just repeat the part from "map:" down in the swiftiply.conf file assigning your new application a single unique port.

Useful?

If so, why not recommend me on Working With Rails!

Book Review: Pro Active Record

2007-11-12T07:44:00.000-08:00

Title: Pro Active Record: Databases with Ruby and Rails.
Authors: Kevin Marshall, Chad Pytel, and Jon Yurek

Visuals:
Font size and layout are good. Easy on the eyes. Large and frequent sub-headings make it easier to locate information.

Audience:
The book lists it's intended "User level" at "Intermediate-Advanced".

Practicality:
It really depends on what you are expecting. I've been using Rails and ActiveRecord for about 2 years, so I should fit into the target audience. After reading the book I think it will be a great reference book to have within arm's reach while working with ActiveRecord. To me it will serve as an API to AR. So it will be practical in that sense.

On the other hand, while reading it I never experienced any "aha!" moments where I felt like I learned something new or exciting, which I had hoped for.

If you are a beginner (never having used AR) it will definitely save you time (and eye strain) hunting down tutorials on blogs.

Overall:
It's a good Active Record reference & usage tutorial(s). I would have appreciated this book even more when I was first starting to use the Ruby on Rails framework. So if you are a beginner, don't let the "Intermediate - Advanced" user level scare you off. Active Record is not a terribly complicated subject, and if you are using Rails (as a beginner or not) you will probably be using Active Record too.

I was kind of surprised when I read the Introduction to the book that it starts off with:

"Is there really enough to talk about in Active Record to fill a whole book?"

"Our answer, then and now, is, "Yes and no""

As an "Intermediate - Advanced" user, that's kind of how I felt at the end of this "Pro" book.

Merb & Datamapper: Getting Rolling

2007-11-07T08:02:00.000-08:00

Today we want to take a look at Merb and DataMapper.

NOTE: I'm doing this run through on OS X. If you are using a different OS, some of the instructions may need modifications (specifically in regards to path locations). This post also assumes that you are using MySQL, which you should already have installed (including the MySQL gem).

Merb: A Web Framework.
~~Yesterday marked the 0.4 release of Merb. At this point it should be fairly stable. Stable enough to make it, at the very least, worth a run through.~~ A few months have passed since the original tutorial, and since then Merb has released versions 0.4.1, 0.4.2, 0.5.0, 0.5.1, 0.5.2 and 0.5.3. Since 0.5.3 there has been a large amount of work done in putting together the 0.9.x release. At the time of this update, 0.9 is a "developer" release. I will be updating these instructions soon.

Merb, like Ruby on Rails, is an MVC web framework. The Merb project has goals of being performance oriented and providing flexibility through plugins. This should allow a developer to better mix and match available tool sets to the specific needs of any given project.

One of the areas of flexibility that Merb provides is in the use of an Object Relational Mapper (ORM). You may have heard of, or be familiar with, ActiveRecord which is the ORM provided by default within the Ruby on Rails framework. You can use ActiveRecord with Merb, but you also have other ORM options such as DataMapper and Sequel.

So let's get started.

Installation (outdated - still is 0.4 based)
First off you need to get Merb & DataMapper installed on your machine. Assuming that you already have Ruby and Gems installed on your system, installation is as simple as:

sudo gem install merb --include-dependencies
sudo gem install datamapper
sudo gem install ruby2ruby --include-dependencies
sudo gem install merb_datamapper ??

UPDATE: Merb does depend on the json gem (json_pure if you want to use it on jruby). This "should" be installed when you install "merb --include-dependencies", but some readers have reported that it wasn't. So just to be safe, run:

sudo gem install json

Lastly, we need to make sure DataObjects.rb drivers are installed. You should now be able to install as a gem:

sudo gem install do_mysql

UPDATE (12/11/07): benr75 reports: "The do_mysql gem is currently broken and refers to an absolute path for MySQL that may not exist on users systems. Fix instructions here."

Other possibly useful resources are: post on Blog::Heimidal and the DataMapper Getting Started page.

Assuming everything went smoothly for you, we are now ready to roll.

Generate & Configure Your New Merb Project (updated to 0.9)
Next we will be generating the default framework files.

Change to the directory where you wish to create your Merb project. For me that was:

cd /Users/justin/programming/projects/

Similar to Rails, to generate the framework code we simply run:

merb-gen project_name
cd project_name

As mentioned before we need to configure our Merb application to let it know that we want to use the DataMapper ORM, and setup our database. Pretty simple stuff. Just a few text edits in 2 files.

First, open config/init.rb and find and uncomment the following line as below:

### Uncomment for DataMapper ORM
use_orm :datamapper

The only other file we need to setup is our database configuration file. When you initially generated your project code Merb did not create this file. Why? Because you hadn't yet told it what ORM you wanted to use.

Since we have edited the dependencies.rb file to indicate we will be using the DataMapper ORM, all we now need to do is load the Merb framework and it will auto-generate a sample database configuration file for us. This sample file will be based on the specific requirements of the ORM we have chosen. So from the command line run:

merb

Easy. Merb saw that you wanted to use DataMapper, but no database has been configured. Automatically the database.sample.yml file was then generated. Now let's finish up our configuration of Merb. Open config/database.sample.yml and edit it according to your specific setup. For example mine looks like:

---
# This is a sample database file for the DataMapper ORM
:development: &defaults
:adapter: mysql
:database: merbtest_development
:username: root
:password:
:host: localhost

:test:
<<: *defaults      :database: merbtest_test              :production:      <<: *defaults      :database: merbtest_production

Don't forget to copy or rename the file to database.yml.

Also, the databases that you just configured in database.yml need to actually exist, so if you haven't done so already please take a moment to create them now.

That's It!
With those two simple configuration steps, our bare bones application should now be ready to roll. To start up, from within your application directory type:

merb

By default Merb is setup to run on port 4000 of host 0.0.0.0. So open up your browser and point it to:

http://0.0.0.0:4000/

You should now see the Merb default page before you.

If you wish to adjust the IP address or port number that Merb runs on, that is configurable from the ~~config/merb.yml~~ config/init.rb file.

That's it for this post. In the next post we will actually make our Merb app do something.

Until then you can get some basic ideas of how to wire things together in this post on PaulBarry.com