Hello all!
Iâve been so busy this year travelling (for pleasure and work) and helping grow the company that Iâve not had much to say here. Expect some posts soon!
In the meantime, if youâre looking for a new challenge⌠Planet Argon is seeking a few more Ruby on Rails developers. Interested? get in touch.
Earlier today⌠our team at Planet Argon launched a new site for the Ruby on Rails community. If you have a few spare minutes, Iâd love it if youâd to head over and read the announcement on RailsDeveloper.
Enjoy!
I love the OhMyZsh community. Letâs grow it a little more this next Tuesday.
Just a quick update to let you know that Iâll be moving more of my business-related topics to the Planet Argon Blog. I invite you to subscribe to that feed as well. :-)
s. We just published Episode 4 of the Planet Argon Podcast, which was on the topic of Hiring designers.
Welcome to what seems like my tenth installment (actually, itâs the fourth) of showing you how I setup my development environment on a fresh OSX install. In this case, Iâm actually getting a MacBook setup for a new employee with Snow Leopard.
Over the years, Iâve evolved these following steps and theyâve helped our team maintain a consistent and stable envirnment for Ruby on Rails development. I know that there are a few other ways to approaching this and Iâm sure youâll get similar results, but this approach has allowed me to maintain a hassle-free setup for the last five years.
As with all things⌠your milage may vary.
During this initial phase, weâre going to install the primary dependencies and setup our environment.
The first thing that youâll need to do is install XCode, which almost everything depends upon as this will install developer-friendly tools for you. Apple has been kind enough to ship this on your Snow Leopard DVD.
Go ahead and install XCode from the Optional Installs folder.
(might require a reboot)
You can also download it online.
Now weâll install MacPorts, which the web site describes itself as, âan open-source community initiative to design an easy-to-use system for compiling, installing, and upgrading either command-line, X11 or Aqua based open-source software on the Mac OS X operating system.â
As Iâve said in past versions of this guide, this tool is about to
become one of the most important tools on your operating system. Itâll
be used time and time again to maintain your libraries and many of the
Unix tools that youâll be using. If youâre from the Linux or BSD world,
you are likely familiar with similar tools⌠such as: apt-get,
port, and yum.
Youâll want to download the latest stable version from http://www.macports.org/. Once downloaded, you can install it.
Once this is installed, youâll be able to use the port command from
your console.
Letâs test out your MacPorts install by installing a useful tool called wget, which weâll use to install oh-my-zsh.
sudo port install wget
```bash
### Git and Subversion
Every development environment should have some source code management
tools available. We'll install both of these with one command.
```bash
sudo port install git-core +svn
```ruby
This will install git and subversion.
### oh-my-zsh
[Oh My Zsh](http://github.com/robbyrussell/oh-my-zsh) is the most
amazing thing to happen to shells since... well since I said so. It's
one of my open source projects that I encourage you to give a whirl.
```bash
wget http://github.com/robbyrussell/oh-my-zsh/raw/master/tools/install.sh -O - | sh
```ruby
That's it. The next time you open up your terminal, you'll be running
zsh with a bunch of stuff available. For more information, visit
<http://github.com/robbyrussell/oh-my-zsh>.
### Terminal theme (optional)
I never understood why the icon for Terminal has a black background but
when you start it up the default theme is black on white.
versus
Anyhow, I'm a fan of the the dark background. To change this, open up
preferences in Terminal. Select **Pro**, then click on the **Default**
window so that this sticks around.
Let's now open up a new Terminal window..
You should be looking at something like this:
Much better... let's continue.
## Phase Two
We're now going to start installing everything we need to get this
running.
### Ruby 1.8.7.x
First up, Ruby.
Snow Leopard includes Ruby and Rails already installed, but we're going
to back these up for a rainy day. Just issue these commands:
```bash
$ sudo su -
Password:
:~ root# mv /usr/bin/ruby /usr/bin/ruby.orig
:~ root# mv /usr/bin/gem /usr/bin/gem.orig
:~ root# mv /usr/bin/rails /usr/bin/rails.orig
:~ root# logout
```ruby
Now we'll go ahead and install a fresh copy of Ruby and RubyGems via
MacPorts.
```bash
sudo port install ruby rb-rubygems
```ruby
You should now see something like this for a bit...
Let's watch a video about bumble bees.
When it finishes installing, you should check that Ruby is available to
you and installed in `/opt/local/bin`.
We'll also take a second to create a symlink for this as some tools seem
to rely on `/usr/bin/ruby` being there.
```bash
sudo ln -s /opt/local/bin/ruby /usr/bin/ruby
```bash
Great, let's move on.
### Passenger (mod_rails)
Now that we have Ruby installed, we're going to take a quick detour to
setup Passenger with the Apache server already available on your
machine. I've been a big fan of using Passenger for your development for
over a year now.
```bash
sudo gem install passenger
```ruby
Once the gem is finished installing, you'll need to install the apache2
module with the following command:
It'll ask you to continue by pressing Enter. At this point, it'll check
that you have all the necessary dependencies and then compile everything
needed for Apache2.
Now I'll force you to watch a highlights reel of Fernando Torres... *the
best striker in the world!*
The passenger install will then show you this output, which you'll want
to stop and read for a moment and highlight the following:
Then using vi or emacs, you'll want to create a new file with the
following content:
```bash
vi /etc/apache2/other/passenger.conf
```text
Then paste in the following (what you highlighted and copied above.)
```apache
LoadModule passenger_module /opt/local/lib/ruby/gems/1.8/gems/passenger-2.2.9/ext/apache2/mod_passenger.so
PassengerRoot /opt/local/lib/ruby/gems/1.8/gems/passenger-2.2.9
PassengerRuby /opt/local/bin/ruby
```bash
You'll also want to include the following below what you just pasted.
```apache
# Set the default environment to development
RailsEnv development
# Which directory do you want Apache to be able to look into for projects?
<Directory "/Users/ryangensel/development">
Order allow,deny
Allow from all
</Directory>
```ruby
You'll want to quickly start up your web sharing, which will start
Apache2 up via your System Preferences.
Simple enough... moving forward.
### Passenger Pref Pane
To make things as simple as possible, I'd encourage you to install the
[Passenger Preference
Pane](http://www.fngtps.com/2009/09/new-os-more-pane-passenger-preference-pane-v1-3)
(view this post for a download).
### Development directory
I have a directory named `development/` in my home directory, which is
where I end up storing all of my projects. This should match whatever
you put above in the apache configuration
(`<Directory "/Users/ryangensel/development">`).
```bash
mkdir development; cd development;
```ruby
### Installing Ruby on Rails via RubyGems
Now we'll use RubyGems to install the latest version of Ruby on Rails
(and all of it's dependencies).
```bash
sudo gem install rails
```ruby
While this is installing, you can watch a video from my old band that
ended around the time that business started picking up for [Planet
Argon](http://planetargon.com).
Great, let's test out the install of Rails...
### Test Rails and Passenger
In your development directory, let's quickly a new Rails app...
```bash
rails testapp
```ruby
This will generate a new Rails application in a `testapp/` directory.
Now open up the **Passenger Preferences Pane** and add this directory as
a new application.
Press Apply...
You should now fire up your browser of choice and head to
`http://testapp.local`. If all has worked, you'll see a, "Welcome
aboard" screen from the Ruby on Rails application.
Assuming that this worked for you, let's take a quick break to make some
tea...
## Phase Three
In this last phase, we're going to install a few database servers and
corresponding rubygems so that you can get to work.
### PostgreSQL
At [Planet Argon](http://planetargon.com), we build our web applications
on top of [PostgreSQL](http://postgresql.org). I've been a long-time
advocate of it and hope you consider using it yourself.
At this point in time, the current stable version of PostgreSQL via
MacPorts is 8.4.x. Let's install that now...
```bash
sudo port install postgresql84 postgresql84-server
```text
Once this finishes compiling, you'll need to run the following commands
to setup a new PostgreSQL database.
```bash
sudo mkdir -p /opt/local/var/db/postgresql84/defaultdb
sudo chown postgres:postgres /opt/local/var/db/postgresql84/defaultdb
sudo su postgres -c '/opt/local/lib/postgresql84/bin/initdb -D /opt/local/var/db/postgresql84/defaultdb'
```ruby
Assuming that you want PostgreSQL to always be running, you can run:
```bash
sudo launchctl load -w /Library/LaunchDaemons/org.macports.postgresql84-server.plist
```ruby
...and to start it right now, run:
```bash
sudo launchctl start org.macports.postgresql84-server
```ruby
Before you can start using it, we'll need to make sure that the
PostgreSQL executables are available in your shell path. Since you're
now using [oh-my-zsh](http://github.com/robbyrussell/oh-my-zsh), you'll
want to edit `~/.zshrc` with your favorite editor.
```bash
vi ~/.zshrc
```text
Just append this to `export PATH=` line in the file.
```bash
:/opt/local/lib/postgresql84/bin
```ruby
Your PATH might look something like the following now:
```bash
# Customize to your needs... export PATH=/opt/local/bin:/opt/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/usr/X11/bin:/opt/local/lib/postgresql84/bin
```ruby
#### Setup database user
To setup a new database (with superuser credentials), just run:
```bash
createuser --superuser ryangensel -U postgres
```ruby
We'll now test creating a database:
```bash
createdb test_db
```text
Let's test that we can access it...
```bash
â ~ psql test_db
psql (8.4.2)
Type "help" for help.
test_db=# \q
```text
Great, let's drop it now.
```bash
â ~ dropdb test_db
â ~ psql test_db
psql: FATAL: database "test_db" does not exist
â ~
```ruby
Okay, we'll now install the library that will allow Ruby to talk to
PostgreSQL.
Just run:
```bash
sudo gem install pg
```ruby
Voila... let's move on to the inferior database...
### MySQL
We're going to run through the installation of MySQL really quickly
because you might need it.
```bash
sudo port install mysql5 mysql5-server
```text
This took ages on my machine... so let's watch a video.
We'll now setup the database and make sure it starts on system boot.
```bash
sudo -u _mysql mysql_install_db5
sudo launchctl load -w /Library/LaunchDaemons/org.macports.mysql5.plist
sudo launchctl start org.macports.mysql5
```text
Let's test that we can create a database now (and that it's running.)
```bash
â ~ mysql5 -u root
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 3
Server version: 5.1.43 Source distribution
Type 'help;' or '\h' for help. Type '
```text
Great, now let's install the Ruby library for MySQL.
```bash
sudo gem install mysql -- --with-mysql-dir=/opt/local
Perfect, now weâve got all the necessary tools to get you working on Ruby on Rails projects with either PostgreSQL or MySQL.
Thanks for following along with this guide. I hope it helped some of you setup your Snow Leopard environment. We still believe that the ideal hosting environment for your Ruby on Rails applications is a dedicated Linux server. In fact, weâre just about to release our new Boxcar Conductor tool to help with Rails deployments⌠stay tuned!
In the meantime, feel free to follow me on Twitter or Planet Argon on Twitter.
Earlier this evening, I accepted a pull-request for theme number 18, which is now included in Oh My Zsh. To celebrate, Iâve updated the themes wiki page with fresh screenshots.
Here is a sampling of some of the themes that you can use out of the box with Oh My Zsh.
Oh My Zsh is much more than a collection of themes for your zsh config. Itâs a way of life[^1^](#fn1){#fnref1 .footnote-ref role=âdoc-noterefâ}.
Also, be sure to follow ohmyzsh on twitter now!
Will refrain from any political commentary, but was notified by some friends that the GOP was using the source code for RubyURL for their new URL shortening site (gop.am).
To celebrate, I decided to daisy chain a few rubyurl-based sites together and came up with:
Enjoy!
As always, you can fork/clone here
While reviewing some code recently, I came across controller code that resembled the following.
if {lang=ârubyâ}customer.save CustomerMailer.deliver_welcome_message(customer){lang=ârubyâ}
flash[:message] = âYour account has been successfully created. Weâve sent you a welcome letter withâŚâ{lang=ârubyâ}
redirect_to dashboard_path{lang=ârubyâ}
else{lang=ârubyâ}
âŚ{lang=ârubyâ}
end{lang=ârubyâ}\
Fairly typical Rails code. Nothing alarming here, but I wanted to evaluate the call to the mailer in this scenario. When it comes to sending emails from your application, you can choose to do it from the controller as in the example above or in your models. Our team prefers to do this from our model via a callback as we are considering this to be part of our business logic.
Each time a customer is created, we want to send them an email. This can be moved into the model and resembled something like the following..
after_create :send_welcome_message #, other callbacks..
def send_welcome_message
CustomerMailer.deliver_welcome_message(self)
end\
There are a few benefits to doing it this way.
I definitely donât think doing this via controllers is a bad idea, I just lean towards keeping controllers as dumbed down as possible. This allows us to have less controller code that is focused on passing data to/from models and letting our models do the heavy lifting.
UPDATE: DHH was kind enough to post a more detailed response on his blog.
Recently, Carlos, suggested that I should start sharing some basic SQL tips that help with performance and/or general usage. I recently came across some code that I didnât like to read and/or write. For example, letâs take the followingâŚ
```
SELECT * FROM brochures WHERE published_at <= now() AND archived_at >= now()
```
Essentially, this is pulling back some data WHERE the the brochures
are considered published. (We have a project that allows people to
manage their brochure launch dates ahead of time.) In fact, in this
project, we have no less than 6-8 dates in the database that weâre
comparing data on and itâs easy to get lost in the logic when trying to
understand it.
Now, there isnât anything inheriently wrong with how this condition is
constuctued. As a matter of personal taste, I find it annoying to
mentally parse. Also, I find having to write now() more than once in a
WHERE clause to feel like Iâm repeating myself.
Read it outloudâŚ
âWHERE the brochures published at date is less than and/or equal to right now AND the archived date is greater than and/or equal to now.â
Who talks like that?
Luckily, there is a better and in my opinion, a more readable way to express this is with the BETWEEN construct in SQL. (postgresql docs, mysql docs)
```
SELECT * FROM brochures WHERE now() BETWEEN published_at AND archived_at
```
Letâs read this outloudâŚ
âWHERE the current date is between the published at and archived at dates.â
This sounds more natural to me.
Additionally, you can also do the inverse with NOT.
```
SELECT ... WHERE now() NOT BETWEEN brochures.published_at AND brochures.archive_at
```
Remember kids, âcode is for humans first and computers second.â â Martin Fowler
Earlier this week, we published Episode 3 of the Planet Argon Podcast. In this latest episode we responded to one of the ideas someone in the audience asked on this brainstormr, which was, âHow do you manage bugs?â
We had a round table discussion about how we classify and prioritize bugs with our clients, ticketing systems, and other tools that we use to streamline this process.
For those of you who didnât make it to Rails Underground in July to witness my mind-blowing talk, Launching Ruby on Rails projects , it appears that Skills Matter has finally posted a video of it online. :-)
The sound levels are really low⌠but hopefully youâll find it helpful.
You can also view the slides.
As mentioned in a recent article[^1^](#fn1){#fnref1 .footnote-ref role=âdoc-noterefâ}, Iâve been diving deep into Google Analytics lately while working on a few client projects. Weâre aiming to use much more of the features of Google Analytics and have been hitting some roadblocks with the development versus production application environments. Once you begin to dive into event tracking and AJAX-driven goal conversions, relying on just the sample code that Google Analytics provides you is going to result in you looking at a handful of JavaScript errors.
::: thumbnail
:::
another example from the firebug javascript consoleâŚ
::: thumbnail
:::
We see JavaScript errors like this because we donât load the google analytics code in our development environments. As you can see, we are only loading this in our production environment.
<% if RAILS_ENV 'production' -%> <!--// Google Analytics //-->
<script type="text/javascript"> var gaJsHost = (("https:"
document.location.protocol) ? âhttps://ssl.â : âhttp://www.â);
document.write(unescape(â%3Cscript src=ââ + gaJsHost +
âgoogle-analytics.com/ga.jsâ type=âtext/javascriptâ%3E%3C/script%3Eâ));
<% end -%>\
To track an event with Google Analytics, youâd need to trigger something like:
pageTracker._trackEvent(âButtonâ, âClickâ, âGet in touchâ);{lang=ârubyâ}\
As you can see from our code earlier, in development, the pageTracker
variable isnât defined and thatâs why weâre getting those JS errors. We
also donât want to add conditionals everywhere in our application to
check if weâre in development or production environment.. as thatâd just
make our views uglier than they need to be. So, I decided that Iâd
create a proxy class in JavaScript that would allow us to trigger
_trackEvent() and _trackPageview() and handle it appropriately.
This class works with the following logic:
pageTrackerconsole.log() for debugging purposesFor example, on a gallery on our web site⌠we track when people navigate next and/or previous through the photos. In our development environment, I can watch the JavaScript console output the following:
::: thumbnail
:::
And in our production environment, we can see that this was sent to Google Analytics.
::: thumbnail
:::
Weâre able to do this by initializing the GoogleAnalyticsProxy class and calling these functions through it. For example:
_gap = new GoogleAnalyticsProxy();{lang=ârubyâ}
_gap._trackEvent(âVideoâ, âPlayâ, âHomepage videoâ);{lang=ârubyâ}
_gap._trackEvent(âVideoâ, âPauseâ, âHomepage videoâ);{lang=ârubyâ}
_gap._trackEvent(âButtonâ, âClickâ, âCall to action Xâ);{lang=ârubyâ}\
Youâll see that weâre just calling _gap versus pageTracker. We then
replace all the instances of pageTracker (except where it is defined in
the google analytics code block they provide you). Youâll find this
located near the bottom of our application.html.erb file.
<% if RAILS_ENV 'production' -%> <!--// Google Analytics //-->
<script type="text/javascript"> var gaJsHost = (("https:"
document.location.protocol) ? âhttps://ssl.â : âhttp://www.â);
document.write(unescape(â%3Cscript src=ââ + gaJsHost +
âgoogle-analytics.com/ga.jsâ type=âtext/javascriptâ%3E%3C/script%3Eâ));
<% end -%>
We now have _gap available throughout our project and can call
_trackEvent() and _trackPageview() with it. Note: You can use any JS
variable name that you want, _gap is just what I went with.
Iâve gone ahead and tossed this small JavaScript class (known as GoogleAnalyticsProxy) on Github for your enjoyment. I have some more articles in the works that will show you some tips for how to make the most of Google Analytics. If you have any questions and/or ideas for related article topics, donât hesitate to let me know.