Sometimes you need to quickly host a web application from your local machine but need a public address for people to connect to. What do you do? Recently localtunnel, a Ruby Gem, was released that makes all of this easy.

Installation

To install, type: gem install localtunnel

Usage

1. Open a terminal window.
2. Type: localtunnel -k ~/.ssh/id_rsa.pub 3000. Of course, feel free to choose a different port.
3. Send the newly created server address (example: http://3ufx.localtunnel.com) to whoever needs to connect to your local server.

TextExpander

For those of you using, TextExpander, I setup the “;tunnel” abbreviation to expand to:

localtunnel -k ~/.ssh/id_rsa.pub %fill:port%

Notes

There is a slight downside to using localtunnel and that is that it will clutter your ~/.ssh/known_hosts file with all those auto-generated host names. It would be nice if localtunnel performed a cleanup task to remove extraneous entries after use. Make sure to run the following command if this bothers you:

ssh-keygen -R 3ufx.localtunnel.com (replace 3ufx with whatever was generated for your session).

Conclusion

Overall, a handy piece of software and worth adding to your toolbox.

Introduction

Redmine is open source software for project management. It comes complete with project management (of course), calendars, issue tracking, milestone/version planning, news syndication, wikis, forums, user and role management, etc. Built on top of Ruby and Rails, it make a compelling piece of software for small teams/startups that needs a quick and dirty project management solution.

The purpose of this post is to walk you through setting up Redmine on your local development box and remotely on a Heroku server.

Requirements

The following is required to setup Redmine and makes some assumptions about your familiarity with each.

1. Mac OS X (Lion)- Ubuntu would be fine too (except for the HomeBrew specifics, of course).
2. Homebrew - Automates your development environment setup needs.
3. rbenv - RVM would be fine as well but, for the purposes of this post, I’ll stick with rbenv.
4. Ruby 1.8.7-p357 - Use the latest patch for Ruby 1.8.7. Yeah, I know, no love for Ruby 1.9.x yet.
5. Ruby on Rails 2.3.14 - Yeah, they don’t support Rails 3.x yet.
6. Heroku - You’ll want the bamboo-ree-1.8.7 stack. Don’t worry, we’ll get to that in a sec.
7. PostgreSQL - Using 9.1.2 at the time of this writing.

Local Setup

The following assumes a relatively fresh Ruby install (skip ahead if necessary). NOTE: I’m using Ruby Gems 1.6.2.

1. Open a terminal window and start typing out the following commands.
2. brew install readline
3. CONFIGURE_OPTS="--with-readline-dir=$(brew --prefix readline)" rbenv install 1.8.7-p357
4. env ARCHFLAGS="-arch x86_64" gem install pg
5. gem install -v 2.3.14 rails
6. gem uninstall rake - Rails installs the newest version of Rake. Redmine doesn’t like this, so rip it out.
7. gem install -v 0.8.7 rake - Required by Redmine.
8. gem install -v 0.4.2 i18n
9. Download the latest Redmine build, unpack, and change directory to the project root.
10. rake generate_session_store
11. Edit the database.yml. Example: database.yml.
12. rake db:create
13. rake db:migrate
14. rake redmine:load_default_data

CAUTION: I like to use Pow to easily spin up my local rails apps. In order to do this you need to generate a config.ru file (code is provided by Pow when you try to launch Redmine). Make sure that you add the config.ru to your .gitignore file before deploying to Heroku. Otherwise you’ll get odd errors related to not being able to find your stylesheet and javascript assets when launching the app on Heroku.

Remote Setup

1. cd to the root of your Redmine project.
2. rm -rf vendor/rails
3. rm -rf vendor/gems/coderay
4. Create a .gems file in the root of your project folder (don’t forget to rename gems.txt download to .gems).
5. heroku create <your project name> --stack bamboo-ree-1.8.7
6. git init
7. git add .
8. git commit -a -m "Initial commit."
9. git push heroku master
10. heroku run rake db:migrate
11. heroku run rake redmine:load_default_data
12. Load <your project name>.heroku.com in your browser. Have a beer!

NOTE: Depending on your Heroku setup you might need to pass the --app <your project name> suffix to each of the Heroku commands above. The Heroku gem will warn you if necessary.

Next Steps

At this point you should be up and running locally as well as remotely on Heorku. You can, of course, add domain name support, update your DNS and give your new app a proper domain name. Adding DB backup support, etc. would be good. Also email and Amazon S3 file storage would be wise too along with any other goodies you can dream up. …but I’ll leave that up the reader to play with.

Credits

Special thanks to Brant for the initial setup and impetus for this.

Install

To install Mac OX X Lion, you’ll need to be running Snow Leopard with the App Store application installed. Here are the steps necessary to configure you machine:

1. Launch the App Store and buy Lion to start the download.
2. Once the download completes, DO NOT start the install. Instead ensure that you make a copy of the DMG image via the Lion installer application (found in your Applications folder). You’ll need to open file info on the installer and choose to show package contents. You’ll want to make a copy of the Contents/SharedSupport/InstallESD.dmg file. More details here.
3. Once a copy of the DMG has been made, you can start the install.
4. Follow the screen prompts to complete.

For those that don’t like the default Lion install settings, you’ll need to perform the install twice. However, this time you have the DMG installer image. You can either make a DVD or USB boot disk. Once you have, you can reboot Lion while holding down the COMMAND+R keys to launch into recovery mode. Here are the steps for reinstall:

1. Launch Disk Utilities and format the main partition as MacOS Extended (journaled, case sensitive). Don’t bother messing with the boot disk partition as that is where your recovery utilities are.
2. Exit Disk Utilities and start the Lion installer.
3. Follow the install prompts until the Lion install completes.

Configuration

1. Rename your computer via System Preferences - Sharing.
2. Unhide your user library folder: chflags nohidden ~/Library

Applications

1. Mac OS X 10.7.x Software Updates (Software Update)
2. Mac OS X 10.7.x Combo Patch (web)
3. XCode (App Store)
4. Dropbox (web)
5. 1Password (App Store)
6. Knox (web)
7. iTerm2 (web)
8. Sublime Text 2 (web)
9. Alfred (web)
10. Alfred Powerpack (web)
11. TextExpander (App Store)
12. PathFinder (web)
13. Firefox (web)
14. Google Chrome (web)
15. Opera (web)
16. OmniFocus (App Store)
17. OmniOutliner (App Store)
18. OmniGraffle Professional (App Store)
19. OmniDazzle (web)
20. Caffeine (App Store)
21. Fantastical (App Store)
22. ColorSnapper (App Store)
23. xScope (App Store)
24. 3Hub (App Store)
25. ExpanDrive (web)
26. iStat Menus (web)
27. Growl (App Store)
28. Air Display (App Store)
29. Pastebot Sync (web)
30. PDFpenPro (App Store)
31. Gitbox (App Store)
32. GitHub (web)
33. Snippets (web)
34. Patterns (App Store)
35. Espresso (web)
36. Gradient (App Store)
37. CodeKit (web)
38. LittleSnapper (App Store)
39. Acorn (App Store)
40. Pixelmator (App Store)
41. DoubleTake (web)
42. ImageOptim (web)
43. ImageAlpha (web)
44. VLC (web)
45. pgAdmin (web)
46. VMWare Fusion (web)
47. Billings (App Store)
48. MoneyWell (App Store)
49. Delicious Library (App Store)
50. GarageBand (App Store)
51. iMovie (App Store)
52. iPhoto (App Store)
53. OpenOffice (web)
54. Logitech Control Center (web)
55. Logitech Harmony Remote (web)
56. Colloquy (web)
57. Skype (web)

Configurations

1. Enable FileVault (via System Preferences - Security and Privacy).
2. Configure Wi-Fi.
3. Configure printer.
4. Configure scanner.
5. Configure Apple Mail and all email accounts.
6. Configure iCal
7. Configure iTunes
8. Install the Network Link Conditioner preference pane (found via /Developer/Applications/Utilities/Network Link Conditioner/)
9. Install Firefox extensions.
10. Configure installed applications.
11. Configure Ruby development environment.

Notes

For more Mac-related information, check out my Mac page.

When on the move with my laptop, I end up having to resize all my applications which is time consuming to say the least. The main difference is due to two very difference screen resolutions:

• Home Screen = 2560×1440 pixels
• Laptop Screen = 1440×990 pixels

The worst is when moving from my smaller laptop resolution back to the big screen at home because all my applications are severely squished. I finally got fed up with the manual labor of resizing my desktop environment each time and crafted a solution: Alfred + Ruby. Win!

Requirements

This post assumes you are familiar with the following:

• Mac OS
• Alfred
• Bash Shell Scripting
• Ruby
• RVM

You might also want to read my previous post, Connecting Alfred to Bitly via Ruby, to understand my reasoning for using a bash shell wrapper script when using multiple Ruby installs.

Setup

You’ll want to download the following scripts:

• rvm_ruby - A Bash shell script for dealing with multiple Ruby installs.
• app_resizer.rb - A Ruby script for resizing applications.

…and install them as follows (for example):

• /bin/rvm_ruby
• ~/path/to/your/ruby/scripts/folder/app_resizer.rb

Feel free to configure the app_resizer.rb script to your liking. The applications and related bounds are specific to my environment but you’ll find that it is easy enough to add your apps and bounds to your liking. The script only supports two modes: home and laptop. Again, feel free to tweak as you desire.

To configure Alfred, open preferences and go to your terminal command settings (click to enlarge):

…and here are my settings for the app resizer script and command in Alfred (click to enlarge):

Usage

Once the Ruby script and Alfred settings are configured, I can now perform the following keyboard commands to resize all running applications:

• OPTION + SPACE
• resize home + ENTER

…or…

• OPTION + SPACE
• resize laptop + ENTER

I wrote the Ruby script so that it only affects running applications. If you later launch an application after you have resized your applications, you can always run the Alfred “resize” command again. Easy peasy.

Resources

You have probably noticed by now that I’m using rb-appscript gem in my Ruby script. I did this because I really don’t enjoy writing pure AppleScript code. Should you decide to get more involved with AppleScript, I highly recommend downloading the associated rb-appscript tools: ASDictionary and ASTranslate.

Enjoy.

I love Alfred for the Mac OS. It is one of the core power tools that I use on a daily basis. Coupled with the Powerpack I’m always finding new ways of expending my capabilities. In this case, faster URL shortening.

Requirements

This post assumes you are familiar with the following:

• Mac OS
• Alfred
• Bash Shell Scripting
• Ruby Programming Language
• RVM

The Problem

Recently, while using my Tweeter Gem (e.g. Twitter for the Command Line), I ran into a situation where I wanted to streamline my URL shortening experience by executing the following keyboard commands:

• OPTION + SPACE
• bilty + pasted long URL + ENTER

If you are thinking “Yeah, but Alfred comes with a Bitly command out of the box.” You are correct. However, it only sends you to the Bitly page for shortening URLs. I’d rather not see Bitly open in a browser tab. I only want the work performed and sent to my clipboard without the browser involved. Then I can paste the shortened URL within my terminal window with only a few keystrokes. Simple. Fast. Efficient.

The Solution

The solution is an easy one now that Alfred supports terminal/shell shortcuts. Almost. The reason is that if you are using RVM, which any sensible Rubyist should be using, you’ll find that Alfred defaults to the system Ruby environment that comes pre-installed with your Mac OS. To prove this, try running a Ruby script referencing a Ruby Gem that you DON’T have installed in your system environment. With Alfred logging turned on (via advanced options), you’ll see the following in your Mac OS Console (click to enlarge):

D’oh!

While this might not be an issue for some, I’d rather use a specific Ruby version and gem set rather than install the same gem to my system library and pollute that unused space. This then requires a shell script to be crafted which allows one to launch a Ruby script within a specific Ruby environment.

Using this shell script, the following becomes possible from the command line:

rvm_ruby ruby-1.9.2-p136 <path to Ruby script>/bitly.rb <some long URL>

NOTE: I placed this shell script in my /bin folder with user, group, and world access set with read and execute access only (i.e. sudo chmod 555).

The corresponding bitly.rb Ruby script then accepts a single URL argument which leverages the Bilty API to shorten a long URL in the background with the end result being copied to the clipboard via the pbcopy Mac OS command.

Putting It Together

Armed with the shell script and the bitly.rb Ruby script, you can now setup the following terminal shortcut in Alfred (click to enlarge):

Here are the shortcut details:

Now you can type:

• OPTION + SPACE
• bilty + pasted long URL + ENTER

…and have the shortened URL ready for pasting via the Mac OS clipboard.

Happy URL shortening!

Somehow I had overlooked this change with my Twitter account but have since corrected it. You should fix your account as well, if you haven’t already.

After reading Creating Flow with OmniFocus by Kourosh Dini M.D., I greatly improved my flow and focus of daily actions. I had been performing these actions on a daily basis but ended up recalling actions from memory and sometimes skipping and forgetting actions which would inevitably pile up as additional work on the weekends. I’ve worked out a system that keeps these daily tasks out of my head and into my trusted system (i.e. OmniFocus) so that I maintain the consistency that I desire AND keep my thoughts clear for more important ideas. The following is a breakdown of my dawn, noon, and dusk actions that I perform on a daily basis.

The following assumes you read Getting Things Done by David Allen and use OmniFocus for the Mac.

Project Overview

To start, it helps to have an overview of my projects via the planning mode of OmniFocus. In my case, I put all daily and weekly tasks in a “Reviews” folder because in a sense, these are my daily and weekly reviews before I start or return to work.

Each project is described as follows:

• Dawn - Repeats daily 5am - 8am, actions are sequential, and marked complete when the last action is performed.
• Noon - Repeats daily 11:30am - 1pm, actions are sequential, and marked complete when the last action is performed.
• Dusk - Repeats daily 5pm - 8pm, actions are sequential, and marked complete when the last action is performed.
• Weekly - Outside the scope of this article.
• Maintenance - A place for saving actions related to fixing and/or enhancing the above mentioned projects.

Dawn Actions

My actions for starting the day:

(click to view)

For those unfamiliar with OmniFocus, there are three columns to the screenshot above. The left-most column is for the actions themselves, the next column is for the context in which the action is to be performed, and the very last column is for the note icons (which have been expanded for reading).

I won’t go into each action individually since I think you can get a pretty good understanding of what each action does (via the associated notes) but I do want to go over the purpose of each group of actions:

• Catch Up - Each action is performed in sequence and is mainly for quickly catching up on activities that took place while I was away. For tweets and feeds that require further reading, I send them to Instapaper or (mark them as starred - in the case of Google Reader). These actions are reserved for quickly catching up on the news. In depth processing of the news happens later as you’ll see below.
• Plan - Here is where I plan (or modify previous plans) for the day based on news read and actions required of me after processing email. For calendaring, I use Google Calendar. I usually only need to check one calendar since all my other calendars pour into my personal calendar (via sharing). Important, next, and due soon actions are easily viewed and acted upon via the OmniFocus perspective links. Screenshots of each perspective are provided below.
• Clean Up - Based on what was read and planned for the day, here is where I go back and read up on the articles I didn’t have time for when catching up earlier. This section of actions is always “as time allows”. Some days I have more time, other days I don’t have time at all. I at least attempt to “touch the keys” even when time is limited. Notice that I don’t close my email client until the very end of this action group. This allows me to delegate or require actions of others while reviewing important, next, and due soon actions.
• Synchronize - Most days I have the ability to work from home…but if I do need to run out the door at least I’ll have my iPhone synced with my most critical data (well, ok, “critical” really only means OmniFocus but the other data is nice to have too).

Noon Actions

My actions when resurfacing from work:

(click to view)

Basically identical to my dawn actions except that, by this time, I might have SMS and voice mail messages to respond too (as I generally don’t respond any incoming messages while working). Remember, it’s all about protecting the flow and staying focused on the work at hand which means not getting detracted by email, phone, Twitter, Feeds, etc. This is something that got ingrained in my head after reading 4-Hour Workweek by Timothy Ferriss. The necessity to sync my phone is not really required, so that is not listed here either.

Dusk Actions

My actions when resurfacing from work and winding down the day:

(click to view)

These are the same actions as performed during the noon hour.

Perspectives

As promised, here are my OmniFocus perspective settings.

Important Actions

Next Actions

Due Soon Actions

Conclusion

In practice, I’ve found that it takes me anywhere from 10 minutes to 1 hour to complete the dawn, noon, and dusk projects. It used to be that these actions could pile up and get unwieldy. I’d have to claim information bankruptcy but now, with a trusted system, I can stay on task without ever letting the mountain overwhelm me. The key to all of this, of course, is being disciplined about it. When you are, the flow is smooth as silk but, let it get out of control, and it can become daunting.

These tasks, like anything else in OmniFocus, are constantly evolving. It might be that I streamline this even further in the future. For me, at least, it works and maybe it can help you too.

1. OPTION+SPACE - Opens the Alfred quick entry window.
2. google metaprogramming - Typing this phrase into Alfred opens a new browser tab with the “metapgramming” search results.

Awesome, right? Well, for those familiar with Alfred, this comes default via Web Searches feature. …but what if you want to add keywords for custom URLs. No problem, click on Custom Searches and add your own preferences. Using the example above, lets say I want to use Google’s secure search capability. Here’s how:

• Open Alfred Preferences.
• Click on “Features”.
• Click on “Custom Searches”
• Click the ‘+’ button.
• Enter the following:
  • Search URL: https://encrypted.google.com/search?q={query}
  • Display Text: Google Secure Search
  • Keyword: google
• Click “Save”.

Did you notice the {query} variable in the search URL above? This allows you to pass “metaprogramming” to the google keyword which ultimately yields the following URL: https://encrypted.google.com/search?q=metaprogramming.

Here is a visual example of some of my custom settings:

Running with that you, could also keep keyboard shortcuts for other services like GitHub, Instapaper, Netflix, etc.

Go wild and enjoy.

I ran into odd behavior the other day when working with chained scopes that required current time to be calculated each time the scope was called. For example, lets say that you are building a blogging application in Rails where you have a Post model. Each post has a published_at attribute which you use to determine whether a post is viewable or not. With that in mind, you might write a scope like this:

scope :published, where("published_at <= ?", Time.now.utc)

Now, when you call Post.published, you’ll only get back posts that were published before or equal to current time. Wrong. Scopes, since they are essentially class methods, get calculated at application launch. So if you haven’t restarted your Rails app for some time, then current time is actually whenever you launched the Rails app. To fix this, you simply rewrite the scope with a lambda, as follows:

scope :published, lambda {where "published_at <= ?", Time.now.utc}

There, much better. This means that each time Post.published is called, the time will be calculated at the time in which the published scope was called.

Great, so now that we’ve got that figured out. Lets build upon our “published” scope and create a chained scope that can not only display published posts but those that are meant for external/public viewing. For example:

scope :external, published.where(:external => true)

Seems reasonable, right? You should get all published and external posts based on current time because we corrected behavior for the published scope. Sadly, this is not true. You’ll only get externally published posts based on the time in which the server was started. Yep, you guessed it, we need to wrap this in another block. So the code above now becomes:

scope :external, lambda {published.where :external => true}

Now, finally, you can call Post.external and get all externally published posts based on the current time from which you called the “external” scope. Personally, I feel this is not intuitive and seems like a bug. Especially, since one of the most powerful features of Rails 3 is the beauty of building upon and chaining your scopes to condense complex operations into a single call.

I recently tweeted the following:

“Twitter Spam: Tweeting only a link to your blog post. Its insulting to those that follow your tweets and posts. Unfollow immediately.”

…which managed to spark the following feedback:

• DilatedTime: Seems an excessive posture. What if one follows only one or the other? I find no issue with the practice. Tune one out.
• gefahrmaus: I disagree. One form of tweet is not exclusive of the other. They are the same. Your argument may be missing a lot of context.

My reason for making the statement is due to the fact that it brakes what I consider Best Practices for using Twitter and is also a new form of SPAM. I see it happening more often than I like and find it rather irritating to come across. Here is an example of what I consider to be offensive:

• <some twitter handle> New Post: <link to new post on personal site>

Notice, in this example, the person is using Twitter to republishing a link that he/she owns. The reason I find this offensive is that I usually don’t care if you have a new post on your site because, more often than not, I’m also subscribed to your site as well. What I’m looking for on Twitter is something ancillary to what is found on your main web site. I’m looking for interesting, educational, funny, witty, etc. bits of information beyond the more thoughtful, longer forms of writing found in a blog post. If you want to post a link to your site, then add something to it. Make it interesting, don’t just regurgitate the same link to an article on your site that I’ll find in my feed reader. Give me context and reason for why I should be interested in seeing the same link to an article on your site that I just saw a few minutes ago in my feed reader. Even worse is when you shrink the URL to a tiny URL so I can’t even tell what the link is before clicking on it. Basically, what you are telling me is that you don’t care about wasting my time. Well, if you don’t care, then I don’t care either and will unfollow you. Simple as that. It’s a bold statement, yes, but I also believe this is an abuse of technology and want to call people out on it.

So what do you do if you want to promote your site on Twitter? Well, don’t do it via a Twitter account that is supposed to represent you. Create a new Twitter account that is purely for marketing or self-promotional purposes. You can hype yourself much as you want. I won’t follow that account because, like I said, I’m already following your web site. But if your goal is to direct as much traffic as possible to your site, then use a promotional Twitter account. It would also be wise to ensure the links on your Twitter profile(s) point back to your main site. My personal feeling is that if I like what you are saying on Twitter, I’m going to dig deeper into your online profile to understand where else you might live digitally and start following you from those places as well.

If you respect your audience, you’ll build stronger connections that could turn into real relationships or benefit you in other ways.

Introduction

I’ve been looking for a great syndicated feed reader for my iPhone for whats seems like ages and I finally found one: Reeder. I stumbled upon this while reading iPad Opinions as, yes, there is an iPad version as well. After reading Ken’s review, checking out the Reeder screenshots, and noticing the Google Reader synchronization support, I immediately spent the $2.99 for the app and have been happy ever since. Besides, OmniFocus for the iPhone, Reeder is my second favorite app on the iPhone. In fact, I enjoy the app so much that I actually find my reading habits have changed to where I prefer to read the news via Reeder on the iPhone rather than via a desktop client. Its that good!

Screenshots

This is the main or initial page of all items you have stared for reading later, etc. Clicking on “Starred” gives you a list of all starred items in all folders. Otherwise you can click on a folder in particular to read specific starred items. The circular arrow icon (lower right) is for manual syncing with Google Reader. This isn’t a bad habit to get into, once you have finished reading your feeds, to ensure Google Reeder stays in sync.

This is the second page of unread items only. As with the first page, click “Unread” to read all or delve in each folder for specifics.

This is the third page of just your folders, notes, etc. Well, this is out I organize/categorize my feeds at least.

This last screen is of a few unread items within my “Development” folder. You can tap on each headline to read in detail.

Design

The design, as Ken mentions in his article is very spartan. I would argue that controls are not the most intuitive but you only need to stumble a few times before you’re off running.

Synchronization

The synchronization with Google Reader is really, really good. I’ve not seen synchronization work so well for a feed reader. Then again, I’ve really only used NetNewsWire (both desktop and iPhone app) which are somewhat pathetic. In fact, NetNewsWire for the iPhone is downright awful. Then again, the app is free. Perhaps that is why.

Workflow

As mentioned earlier, my work flow has really changed. I used to read my feeds morning, noon, and night via the desktop (and still do for the most part) but the sheer convenience of being able to read my feeds while on the balcony, traveling, eating lunch, in bed, etc. is a lot of fun. If I need desktop access for downloads, video feeds, etc. I can star those news articles for later reading and quickly move on to next unread items.

Final Thoughts

If you enjoy your feeds, love being mobile, and appreciate really good synchronization, then buy this app!

• jQuery Check All Bookmarklet (right click to save as a bookmark then click the bookmark to use)

In my case, I keep all my bookmarklets within a single folder which are easily accessible from my Firefox bookmarks toolbar. So having this capability within one click is highly useful.

1. MacOS 10.6.0 (Snow Leopard Disk) - Insert the DVD, click Install MacOSX, click the Utilities button, and click the Restart button. You’ll be booted into the Snow Leopard install at which point you’ll want to launch Disk Utility and format your hard drive (MacOS Extended (Journaled)). After you have wiped your hard drive, exit Disk Utility, and continue on with the Snow Leopard install.
2. XCode Tools (Snow Leopard Disk)
3. Mac OS X 10.6.5 Combo Patch (download)
4. iPhoto (download)
5. GarageBand (download)
6. iMovie (download)
7. iDVD (download)
8. PathFinder (download)
9. OmniFocus (download)
10. OmniOutliner (download)
11. OmniGraffle (download)
12. Firefox (download)
13. Google Chrome (download)
14. Opera (download)
15. ExpanDrive (download)
16. NetNewsWire (download)
17. 1Password (download)
18. Skitch (download)
19. VLC (download)
20. Caffeine (download)
21. Coconut Battery (download)
22. iStat Menus (download)
23. Growl (download)
24. TextMate (download)
25. CSSEdit (download)
26. VMWare Fusion (download)
27. Billings (download)
28. MoneyWell (download)
29. Delicious Library (download)
30. OpenOffice (download)
31. Skype (download)
32. Tweetie (download)
33. Lorem Ipsum widget (download)
34. Logitech Harmony 890 remote software (download)
35. RipIt (download)
36. Startup Sound (download)
37. iBackup (download)
38. Dropbox (download)
39. Software Updates (via the Apple icon - requires a reboot)

Configurations

After installing the applications, you might need to configure some of them. Here are some notes:

1. Configure printer.
2. Configure scanner.
3. Configure Spaces.
4. Install Firefox extensions.
5. Set up the Ruby development environment.

Notes

You can learn more about some of these apps on my Applications page. Also, since I’m one of those who likes organization, I wrote a post on data management a while back that sheds further light on how I manage my apps and the data related to them in case it is of interest (Note: even though the post was originally written for Windows some of the concepts still apply for the MacOS).

For those wanting to set up a proper Ruby and Ruby on Rails development environment for your Mac OS, I’ve created an OmniOutliner outline that might be of help:

• MacOS Ruby Development Setup 1.6.0

The Spaces feature is a heavily used aspect of my setup. It allows me to group similar applications together within each space (a.k.a. desktop).

Configuration

Here is my configuration:

What might not be clear from the screenshot above is the complete picture of what I am loading in each space. Here is a more verbose breakdown of each of my spaces:

1. Navigation (PathFinder/Terminal)
2. Chat (Skype/Tweetie)
3. Email (Apple Mail)
4. Syndication (NetNewsWire)
5. Web (Firefox/Safari/Chrome/Opera)
6. Planning (iCal, Address Book)
7. Organization (OmniFocus)
8. Design (OmniGraffle)
9. Notes (OmniOutliner)
10. Documentation (OpenOffice/Preview/Digital Books)
11. Development (TextMate)
12. Virtualization (VMFusion)
13. Finance (MoneyWell/Billings)
14. Security (1Password)
15. Media (iTunes, iPhone, GarageBand, iMovie, iDVD)
16. Miscellaneous

Example

Notes

What I really like about each space is that all application related events are captured in the space that the application is running in. It is rather handy to have my chat windows, e-mail, etcs all within their own space without being cluttered upon other applications. I also like that I can easily switch between application using the APPLE+TAB key combo.

As full release of Ruby on Rails 3.0 draws near, I find myself collecting news, articles, and preparing myself for the transition. Here is what I’ve been reading so far:

• Reading material.
• Introduction.
• Approaching the upgrade.
• Getting up to speed.
• Upgrading to Rails 3.
• Automating a portion of the Rails 3 upgrade process with the rails-upgrade gem.
• Revamped Routes.
• Render Options.
• Active Record Query Interface.
• Understanding the ActionMailer API.
• Generic Actions.
• The Rails Module.
• Discovering Rails 3 generators.
• Validations.
• I18n changes.
• Signed and Permanent cookies.
• Creating new apps with the Rails 3 beta.
• Gem and Plugin Compatibility Checker.

I’m sure I’ll collect more as time rolls on. BTW, you can find these links and more on my Ruby page where I continue to capture useful Ruby information.

Its always fun to look over someone’s shoulder and see how certain technology is used so I thought I’d share my setup. In this case, I’m talking about the home screen of my iPhone since it where I keep the most trafficked applications.

Here is a break down of my home screen (left to right, top to bottom):

• OmniFocus - Inspired by the book “Getting Things Done” by David Allen, this is the best app to implement David’s teachings perfectly via software. This app is heavily used (hence being in the first position). Sync’s perfectly with the desktop and truly is my digital brain. Well done OmniGroup!
• Groundwork - At one point I tried to do accomplish all professional work within OmniFocus (and still do when I’m the solely responsible). The only problem is that OmniFocus is for single use and doesn’t work well in a team/collaborative setting. This is why it is handy to have Groundwork around to sync with your Basecamp setup. Perfect for checking status and not loosing ideas while on the go.
• Nezumi - Almost all my Ruby on Rails apps are running on Heroku. This is a handy app for managing your apps while from the road. It is limited in function but having log, reboot, and console access is a nice backup plan.
• Ego - Sounds bad but is actually quite useful when it comes to tracking Google Analytic, Feed Burner, and Twitter stats for various my Ruby on Rails applications.
• Messages - Default iPhone app, sometimes useful. I don’t really use SMS much but keep it around since others like to communicate that way. Personally, I think SMS should die much like email.
• Tweetie - Another app that makes managing multiple Twitter accounts easy. I use Tweetie on both the iPhone and desktop.
• Skype - My favorite instant chat client. I use no other. Obviously, very handy to have on the phone. Also, a great way to save on SMS text costs.
• Calendar - Default iPhone app. What can’t be done (or doesn’t make sense to do) in OmniFocus, is done here. Syncs perfectly with my desktop app. No complaints.
• Maps - Default iPhone app. Always handy and now on the 3GS version of the phone, it does a pretty good job of keeping track of where you are in real-time.
• 1Password - So passwords suck and just about every web site and application known to man does it their own special way. The only way to deal with the chaos is to use 1Password. I love having this on the iPhone because it syncs with my desktop client and allows me to easily cut and paste complicated 20-character or more passwords into my local iPhone app configurations or web pages. BTW, as you might have guessed, this didn’t truly become useful until Apple enabled cut and paste support.
• Dropbox - While some people might like Evernote, I still find files and folders extremely handy. This app does all the heavy lifting of keeping my files and folders synced between all machines. Plus they give you up to 3GB of space for free. Brilliant.
• Billings - When I was running my own consulting company (actually, I still do), this app was used a lot. I keep it around now because I like track my open source and personal project work. I’m mostly curious as to how much time I spend on things and like to know whether my speed is increasing over time.
• AccuWeather - So far the best weather app for my tastes. Since I live in the mountains and ride a metal steed, it is wise to know what is brewing. Especially in the dead of winter.
• Clock - It’s what gets me up in the morning. Also handy for when you are in the kitchen.
• Calculator - For those calculations that would take too much brain power to compute.
• Convertbot - For unit conversion calculations. Handy when cooking or in the garage. It’s also an elegantly designed application and worth looking into if nothing else to help inspire your own designs.
• Phone - While I don’t use the phone much, it does give me access to my contacts.
• Mail - Used often with Inbox Zero discipline. What can’t get processed immediately gets scheduled via OmniFocus.
• Safari - Used mostly for info lookup. Always handy in a pinch and for testing your own sites, of course.
• iPod - Besides, the OmniFocus app, this is probably the secondly most used app for constant learning. Audiobooks and educational podcasts are heavily consumed.

For a list of the apps mentioned above and other iPhone related news, check out my iPhone page for more info.

I have a Canon PIXMA MP470 device. It’s a decent printer that doubles as a scanner. The device is perfect for my needs although I would argue that it eats printer ink a little faster than I’d like. Then again, I got it for free, so I can’t complain too much (well if you don’t calculate the long term cost of printer ink over time).

In the past, I used proprietary software that came with the device to scan documents. For printing support, I could easily detect and attach to the printer via Bonjour (as the device is plugged into an Apple Airport so all machines on the network can use it). In the case of scanning, I would have to attach the USB cable directly to my computer. There might be a way to do this via Bonjour but that eludes me at the moment.

Recently, I upgraded to Snow Leopard and discovered that I could scan documents using the native Image Capture application. Perhaps, you could do this in Leopard too? Anyway, this allowed me to no longer require installing Canon’s proprietary printer/scanner software. The only downside is that the Image Capture application doesn’t know how to combine multiple document scans into one PDF. Nor does the Preview application allow one to combine multiple PDFs into one PDF document either. Bummer.

The solution is to use Automator. I generally use Automator for quick image manipulation, resizing, etc but it also has decent PDF support. In my case, where I have several PDF files from multiple scans of a single document, I can use Automator to combine all these PDFs into one file. As part of Apple’s Automator action library, someone has already built an Automator worklfow that does exactly this. You can download the workflow and use it to combine multiple PDF files into one.

Something to think about if you are in a situation like this. It definitely does the trick for me.

Over a year ago, I write a post about my favorite Ruby feeds. I’ve since deleted that post in order to write about an updated set of Ruby feeds that you should be paying attention to (if not already). I read all of these feeds religiously on a daily basis and have broken them down below by general news and information followed by screencasts/tutorials. Enjoy.

News

• A Fresh Cup - My personal favorite. While you can find similar news via the links below, Mike Gunderloy does an excellent job of summing everything up in place for news, information, and new gems from the Ruby community.
• Ruby Toolbox - A great trending site for finding out what gems are hot and most popular within the Ruby community. This can save you a lot of time when you want to know which gem is the best solution for a problem that has already been solved.
• Ruby Trends - Another trending site. Useful for cross-checking against Ruby Toolbox on what is hot.
• Ruby News - Straight from the source. Find about new releases, conferences, developments, etc.
• Ruby Inside - The inside scoop on Ruby news.
• RubyFlow - A great site for picking up new resources to add to your development repertoire.
• RubyFu - Useful quick news and resource links.
• Ruby Best Practices - A great source of thoughtful discussion, including code samples, on how to write better code.
• Ruby5 - From some of the same guys who provide the Rails Envy podcast below. This is another podcast on Ruby news but in short, 5-minute, segments of usually discussing many of the new and interesting gems being developed.
• Rails Inside - Get the inside scoop on Rails news.
• Riding Rails - Learn what is happening with the Ruby on Rails team.
• Rails Spikes - A multi-authored site of Ruby developers discussing news, tips, code, etc.
• Rails Illustrated - Info on Rails, web design, and the user experience.
• Rails Notes - Another site worth checking out and picking up new learning.
• Rails Tips - As the site description goes: “One man, feverishly posting everything he learns.”
• The Rails Way - News and information dedicated to teaching best practices of Ruby on Rails.
• Ruby on Rails Security Project - A good place to read up on security issues or at least keep your mind in it.
• Giant Robots Smashing Into Other Giant Robots - Good development tips and tricks, mostly related to Rails.
• Ryan’s Scraps - Interesting news on what’s new and upcoming within the Rails code base. Includes code samples and detailed descriptions and examples of new Rails features.
• Has Many Through - Although he has a low writing frequency, the posts are enlightening.
• Rails Envy - An entertaining and informative weekly podcast dedicated to Ruby, Rails, and web framework news.
• Rails Podcasts - Ruby/Rails podcasts by Geoffrey Grosenbach of PeepCode fame.
• Rails Magazine - News, articles, and information about the Ruby on Rails framework.

Tutorials

• Railscasts - Short screen cast tutorials of Ruby on Rails code.
• Envy Casts - Produced by the same guys that host the Rails Envy podcasts. Each screen cast tutorial will set you back about $9.
• PeepCode - Screencast tutorials like Railscasts but longer in length and not free (roughly $9 per episode).
• Tekniqal - A collection of screencasts that cover some of the Ruby basics.
• Scaling Rails - A series of screencasts on detailing how to scale your Ruby on Rails application appropriately. Produced by Gregg Pollack of Envy Cast fame.
• BDD Casts - Video tutorials on all things related to Behavior Driven Development.

BTW, you can find this list and more on my Ruby page.

I have released a simple GitHub project called Ruby Gem Setup that makes setting up your Ruby Gems a little easier. Here are a few highlights:

• Ensures the Ruby Gem environment is at the latest version.
• Adds GitHub and Gemcutter as gem sources.
• Allows you to configure a setup.txt file that lists all your favorite gems for install.

Very handy, especially when managing gems for multiple versions of Ruby. Feel free to fork the project for your own purposes if you like or simply maintain your own setup.txt file.

Sometimes, when working with IRB or the Rails console, you might need a list of methods on a particular class or object. You don’t necessarily need to consult the doc because it is one of those situations where you would know the method if you saw it. So what do you do? Well, one trick is to use the select method (passed via a block) on a collection of methods. You can always start by asking the class for its methods by typing the following:

Hash.methods

Which yields:

["require_dependency", "decode_b", "write_inheritable_hash", "model_name", "breakpoint", "require", "delegate", "taguri", "const_missing", "new", "class_inheritable_hash", "suppress", "methods", "andand", "method", "allocate", "attr_internal_reader", "protected_instance_methods", "deprecate", "taguri=", "subclasses", "cattr_accessor", "include?", "daemonize", "taint", "present?", "class_eval", "alias_method_chain", "instance_variable_defined?", "yaml_tag_class_name", "name", "find_hidden_method", "reset_inheritable_attributes", "metaclass", "autoload", "to_yaml_style", "class_variables", "parent", "inheritable_attributes", "__id__", "singleton_methods", "synchronize", "dclone", "private_instance_methods", "object_id", "subclasses_of", "respond_to?", "nil?", "ancestors", "yaml_tag_read_class", "parent_name", "tap", "__send__", "require_library_or_gem", "protected_methods", "require_or_load", "me", "tainted?", "attr_internal_writer", "remove_class", "class_inheritable_reader", "untaint", "instance_of?", "autoload?", "b64encode", "included_in_classes", "equal?", "method_defined?", "with_options", "const_missing_without_dependencies", "display", "class_variable_defined?", "private_methods", "hash", "instance_method", "send", "constants", "deprecation_horizon", "instance_values", "`", "attr_internal_accessor", "yaml_tag_subclasses?", "class_inheritable_writer", "kind_of?", "enable_warnings", "freeze", "eql?", "public_method_defined?", "to_json", "id", "returning", "parents", "write_inheritable_attribute", "dont", "acts_like?", "require_association", "public_methods", "instance_eval", "superclass_delegating_reader", "instance_variable_names", "attr_internal", "const_get", "to_enum", "class_inheritable_array_writer", "is_a?", "silence_stderr", "private_method_defined?", "cattr_reader", "type", "const_missing_with_dependencies", "local_constants", "superclass", "write_inheritable_array", "instance_variables", "frozen?", "blank?", "attr_internal_naming_format", "const_set", "copy_instance_variables_from", "enum_for", "class_inheritable_hash_writer", "silence_stream", "to_a", "to_param", "mattr_reader", "protected_method_defined?", "attr_internal_naming_format=", "extended_by", "silence_warnings", "class", "public_class_method", "encode64", "from_xml", "instance_variable_get", "<=>", "to_yaml", "load_with_new_constant_marking", "==", "superclass_delegating_writer", "method_added", "class_inheritable_accessor", "===", "duplicable?", "extend", "to_s", "to_query", "alias_attribute", "instance_methods", ">=", "remove_subclasses", "extend_with_included_modules_from", "mattr_writer", "<=", "cattr_writer", "local_constant_names", "clone", "private_class_method", "decode64", "read_inheritable_attribute", "const_defined?", "yaml_as", "included_modules", "debugger", "=~", "instance_variable_set", "<", "superclass_delegating_accessor", "deprecated_method_warning", "attr_accessor_with_default", ">", "class_inheritable_array", "inspect", "[]“, “remove_subclasses_of”, “instance_exec”, “try”, “mattr_accessor”, “public_instance_methods”, “as_load_path”, “to_yaml_properties”, “unloadable”, “dup”, “module_eval”]

OK, yeah, that’s a bit overkill. How about we narrow it down to the types of methods (using the select method with a regular expression):

Hash.methods {|m| m.select =~ /methods/}

Which yields:

["methods", "protected_instance_methods", "singleton_methods", "private_instance_methods", "protected_methods", "private_methods", "public_methods", "instance_methods", "public_instance_methods"]

Ah, much better. …but I’m not quite there yet. Lets say I know it’s an instance method and it is a type of “to” method. I could then type the following:

Hash.instance_methods {|m| m.select =~ /to_/}

Which yields:

["to_yaml_style", "to_hash", "to_set", "to_xml", "to_json", "to_enum", "to_options", "to_a", "to_param", "to_yaml", "to_options!", "to_s", "to_query", "to_yaml_properties"]

OK, now I remember, it was the “to_yaml” method that I was looking for!

This, of course, is a contrived example. However, if you know what type of method you are looking for and part of its name, then this is a quick and effective way of getting back a subset of methods from which you can gauge what it is that you’re looking for.

Where I tend use this most (as of late) is with Rails models that accept nested attributes (i.e. accepts_nested_attributes_for). For example:

Recipe.instance_methods {|m| m.select =~ /attributes/}

["update_attributes!", "comments_attributes=", "reject_new_nested_attributes_procs", "attributes", "attributes=", "time_zone_aware_attributes", "respond_to_without_attributes?", "update_attributes", "skip_time_zone_conversion_for_attributes", "user_recipe_attributes=", "ingredient_groups_attributes=", "attributes_before_type_cast", "instructions_attributes=", "sources_attributes="]

So there you have it, in case it is of help.

If you have the unfortunate experience of having to deal with Oracle databases you might run into an interesting problem with default scopes where Oracle spits back the following error:

ORA-00933: SQL command not properly ended: UPDATE post SET post_gid = NULL WHERE ((post_gid = 2060)) ORDER BY name

The problem, if you guessed it, is that you can’t add an ORDER clause to the end of an UPDATE statement in SQL. It is invalid syntax. This happens because you might have done something like this in your Post model:

class Post < ActiveRecord::Base
# Named Scopes
default_scope :order => "name"
end

I really like to use default_scope on my models when apt. However, with Oracle, you might as well forget about that until Rails is patched (which I suppose I should do once this aggravates me more). The workaround is to not use default scopes but, instead, used named scopes, define them as conditions to your finds (usually index actions), and/or has_many associations. For example:

Named Scope

class Post < ActiveRecord::Base
# Named Scopes
named_scope :default, :order => "name"
end

This will work nicely but if you need to pass additional conditions, you’ll still need to do the following:

Post.default.all(:conditions => {:name => "Once Upon a Time"})

Index Action

Post.all :order => "name"

Has Many Association

class User < ActiveRecord::Base
# Associations
has_many :posts, :order => "name"
end

Obviously, not as elegant as defining them in one location but it’ll get you by.

(click to view)

By clicking Tweetie’s sidebar you can quickly jump from tweets you have composed, see replies, direct messages, and search. You can also use global keyboard shortcut to enter tweets. In my case I use CTRL+OPTION+COMMAND+T often to bring up a dialog to enter a quick tweet:

(click to view)

Notice that you can also use keyboard shortcuts to quickly convert long URLs to short ones. The only downside to using the keyboard shortcut is that the dialog only pops up in the Leopard Space from which you originally launched Tweetie (focus is switched to that Leopard Space as well). I was expecting the OmniFocus QuickEntry dialog behavior which works from any Leopard Space. I messaged the developer about this and the response was that it is not easy to do but is looking into it. If that can get fixed, I would be tempted to buy the app even though the ad-supported, free version is not that annoying.

So I have become a GitHub fan (powered by Git, obviously). It is free to use if you are developing open source code or you can pay various service fees to have GitHub host your private code. As for me, I’m working on a few open source projects. Three, of which, are live now.

…but I learned a few lessons along the way. I thought I’d share what I learned in case you might be curious.

Make everything a gem when apt

They are easy to develop and manage. Plus they are version controlled and simple to configure within a Ruby on Rails app. I made the mistake of developing Ruby on Rails plug-ins initially and have finally converted all my plug-ins to gems now. Plug-ins, it seems, are going the way of the Dodo.

Be wary of your user account.

When you register with GitHub, pick a user account that you want to stick with as all software associated with your username will be prefixed to your code (this is especially critical with gems). In my case, I use “aeonscope” which yields the following gem install command line: sudo gem install aeonscope-XXX. The installed gems will also show up on your file system with the same “aeonscope-” prefix. You don’t, however, have to name your libraries in this manner which means that your Rails configurations will not match. Lets take a closer look:

• GitHub Login: aeonscope
• GitHub Project: rest
• GitHub Project Path: http://github.com/aeonscope/rest
• Gem Install Command: sudo gem install aeonscope-rest
• Ruby on Rails Configuration (via environment.rb): config.gem "aeonscope-rest", :lib => "rest"

Notice when you configure my gem in Rails, you must specify “rest” instead of “aeonscope-rest” for the library. This is because I don’t want to namespace my Rails code with “aeonscope”. I debated as to whether this was wise and, in the end, decided it was lame to force namespaces. I like the fact that gems are installed and stored on your local file system with the namespace but once you configure the gem in Rails you then specify the library without the GitHub login prefix.

Know your tools

Save yourself some setup time by using Jeweler to craft your gems. Once you have released your new gem, you can check if it has built. The rest is a just a matter of reading the GitHub docs and learning about Git in general.

With that in mind, I was playing with a Firebug extension called Firebug UJS. I really enjoyed this tool because it allowed you to see UJS behavior within the DOM while investigating code in Firebug. Cool! Only problem is that it totally hosed most of my jQuery enabled pages. In fact, if you install this plugin and try to view the jQuery UI demos, you’ll be in a world of hurt.

While the extension is a nifty idea, I would recommend saving yourself time and frustration by not installing this. If you want a list of extensions you might want to be using, then check out my Firefox page for more info.