Litany Against Fear

Intention revealing methods

2013-06-11T00:00:00-07:00

Current status

2013-04-26T00:00:00-07:00

What was your first job?

2013-03-25T00:00:00-07:00

It's not a meetup

2013-03-05T00:00:00-08:00

Drawing the native/web line in Basecamp for iPhone

2013-02-15T00:00:00-08:00

Why I loved building Basecamp for iPhone in RubyMotion

2013-02-13T00:00:00-08:00

Use Jekyll, SCSS, and CoffeeScript without plugins

2013-01-09T00:00:00-08:00

I’ve been using Jekyll for almost 4 years now, which is long before SCSS and CoffeeScript existed. Since then, there have been a slew of plugins that build on top of Jekyll that provide everything from new “models” to an asset pipeline like Rails. I have a simple rule with how I use Jekyll:

If I need more than what Jekyll provides by default, I don’t use Jekyll.

I’m super happy that people can build on top of Jekyll’s “core”. Projects like Octopress and stories like Obama raising $250M with Jekyll are awesome for the community. However, if I need something more complex than simply “posts” and “pages” for a static site, I’m not going to try to shoehorn Jekyll into a solution.

If you want to use CoffeeScript or SCSS with Jekyll, you don’t need to modify Jekyll to get this done. You can just use gems, and rake. My sites use an “assets” directory, which contain all of the .scss and .coffee files, and then some simple Ruby process spawning generates the assets. Here’s a gist so you can use it too:

I’ve written 3 fully fledged Jekyll sites using this method to generate assets, and here’s the source to them for you to check out:

There’s a few downsides to this method that I’d like to put out there before you go ahead and remove your plugins:

Errors aren’t reported too well
Killing the rake process with ^C leaves some gross error messages
This doesn’t combine multiple assets into one file
Heavy caching means that CSS refreshes are hard sometimes

If you can live with the above problems, I hope this code helps you out. Let me know if it does!

Thanks, 2012

2012-12-31T00:00:00-08:00

Thanks to my wife, Amanda, for being awesome, learning how to program, and standing up to speak. We’ve been through a lot this year and you’ve made it all worth it. I love you.

Thanks to my parents and grandparents, who now we can live close enough to see again on a regular basis. Yes, I’ll try to clean out my old room in 2013. Thanks to my brother for letting me win at least one Super Smash Bros game this year.

Thanks to my mother-in-law, and my brother and sisters-in-law for putting up with years of me being tangled to my computer and for always being welcoming into your family.

— — —

Thanks to our friends here in Buffalo, especially Mark & Becca: Through board games, movies, sports games, BBQs, porch hangouts, and more, you’ve made us feel at home. Sorry about the dog hair on your clothes.

Thanks to my partners at CoworkBuffalo, Kevin, Dan, and Brian, and our customers. You all have proven our little community of freelancers and remote workers is more productive and happy when we’re together.

Thanks to the tech community here in Buffalo, from meeting for coffee, to helping me start OpenHack nights, to organizing talks at the Ruby group: you’ve shown me that no matter how small the city, the passion is just as big.

— — —

Thanks to Jason, David, and all of my coworkers at 37signals. I’ve learned an immense amount in the past year from everyone about how to make products that we are proud of. Thanks for answering my questions, being patient, and taking time out of your day to help me out.

Thanks to those who toil away at open source thanklessly and tirelessly. Your work does not go unnoticed. Thanks to those who work hard behind the scenes to make the impossible possible for thousands of open source consumers. There needs to be more of you.

Thanks to my fellow RubyGems maintainers and overseers: Evan, Eric, Erik, Chris, Terence - it’s crazy to think of where Ruby as a whole would be without your efforts. Please keep it up…more than we can ever imagine are depending on us.

— — —

Thanks to Ben, for being my friend for many years, and I hope we can be friends for many more.

Thanks to my friends and former coworkers in Boston. We miss you, and you need to come visit Buffalo. We’ll try to make it out there again soon.

Thanks to anyone who took time to come see me speak this year. I hope the GIFs were entertaining, and you learned something.

— — —

To those I missed: Thank you. Happy 2013.

Open Source Guilt & Passion

2012-12-03T00:00:00-08:00

Automating with convention: Introducing sub

2012-09-28T00:00:00-07:00

Three quick Rails console tips

2012-05-17T00:00:00-07:00

Code Spelunking in the all new Basecamp

2012-04-27T00:00:00-07:00

The On-Call Programmer

2012-04-16T00:00:00-07:00

All hands, battlestations!

2012-02-12T00:00:00-08:00

Kicking the tires: My trial month

2012-01-13T00:00:00-08:00

Danger, Danger: High Voltage! Use Rails 3.1 for Static Sites

2011-10-21T00:00:00-07:00

Use Capybara on any HTML fragment or page

2011-07-26T00:00:00-07:00

Redis Pub/Sub…how does it work?

2011-06-08T00:00:00-07:00

Fetching source index for http://rubygems.org/

2011-01-13T00:00:00-08:00

Gem Sawyer, Modern Day Ruby Warrior

2010-10-06T00:00:00-07:00

Sailing down the Hudson with RVM

2010-06-18T00:00:00-07:00

IronRuby drops - make some noise!

2010-04-18T00:00:00-07:00

A little context about myself and recent events:

I used to be big into .NET before Ruby.
I decided to move away from .NET over 2 years ago.
For the past 4 months I’ve been using ASP.NET MVC 2 for my senior capstone project.
IronRuby’s 1.0 release has dropped!

This week Scott Bellware wrote about why this should matter to anyone doing .NET, especially the ‘forward thinking’ ALT.NET crowd. I’m not too familiar with the history of the ALT.NET movement, but I love following smart developers in any sector of our industry on Twitter and I’ve been watching more .NET devs lately because of my senior project.

Here’s Scott’s main points as I saw it:

Comparsions of Rails to ASP.NET MVC 2 are difficult (I agree!)
Getting the average .NET developer out of the Visual Studio comfort zone is still unlikely
You can now painlessly use Ruby and Rails with IIS and .NET in general
Stop using .NET ports of Ruby projects, you can just run them with IronRuby now!

After reading it and seeing Jason Meridth’s tweet…

…I had to give a Rubyist response. My reaction is: Welcome! I don’t think fear has anything to do with it, it’s just hard to break out of the norm for any of us. I’m positive you’ll have fun learning Ruby and integrating with your existing .NET infrastructure.

I’m right behind Scott in that the barrier to entry for those on Windows and in the .NET ecosystem has been lowered immensely. Plenty have said it before, but now is the time to start. Many of us have converted over from C#/VB.NET, and I can’t be the only one who’s happy to share their experience with those considering diving into Ruby.

Let me start you off right now:

IronRuby has dropped, but you have to make the noise. We Rubyists are waiting to hear from you!

Redis: Data Cheeseburgers

2010-03-12T00:00:00-08:00

The Rails Module (in Rails 3)

2010-02-03T00:00:00-08:00

So, you may have noticed this in the Rails 3 Changelog…

Railties now deprecates:

RAILS_ROOT in favour of Rails.root,
RAILS_ENV in favour of Rails.env, and
RAILS_DEFAULT_LOGGER in favour of Rails.logger.

Great…but why? Better alternatives have existed for a while in Rails core (some since 2.1.0), and it’s about damn time you start using them properly. There’s also some other helpful methods on the Rails module we’ll explore in this post.

Rails.root

This is a big one. Every Rails developer has done File.join(RAILS_ROOT, "path", "to", "something") before. Stop that. And don’t just replace RAILS_ROOT with Rails.root either. Rails.root is a Pathname, which means you can do cool stuff like this:

$ rails console
>> Rails.root
=> #<Pathname:/Users/qrush/Dev/ruby/new_app>

>> Rails.root.join("config", "database.yml")
=> #<Pathname:/Users/qrush/Dev/ruby/new_app/config/database.yml>

>> _.read
=> "development:\n ...

Rails.env

Same deal, you’ve probably done something like if RAILS_ENV == "production" in your Rails apps. Stop that too. Oh, you thought this would just be a String?

$ rails console
>> Rails.env
=> "development"

>> Rails.env.class
=> ActiveSupport::StringInquirer

Whaaaat? Actually, this is a really neat utility. From activesupport/lib/active_support/string_inquirer.rb:

module ActiveSupport
  class StringInquirer < String
    def method_missing(method_name, *arguments)
      if method_name.to_s[-1,1] == "?"
        self == method_name.to_s[0..-2]
      else
        super
      end
    end
  end
end

Awesome. This lets us do stuff like this in Gemcutter:

if Rails.env.development? || Rails.env.test?
  include Vault::FS
else
  include Vault::S3
end

Rails.logger

This is your favorite Logger class, just now without an annoying constant name of RAILS_DEFAULT_LOGGER. Much easier to remember.

$ rails console
>> Rails.logger
=> #<ActiveSupport::BufferedLogger:0x21de384 ...

>> Rails.logger.info "zomg!"
=> "zomg!\n"

>> File.read("log/development.log")
=> "zomg!\n"

Rails.public_path

A helpful shortcut to what your public assets directory is called, probably to use with Rails.root. (Why this isn’t a Pathname is beyond me, sounds like a good patch to whip up!)

$ rails console
>> Rails.public_path
=> "public"

Rails.cache

Now the rabbit hole goes deeper. This is a unified interface to memory/file/you name it caching stores that can be used with Rails. If you’ve ever made some sort of caching global variable, like $memcache or CACHE, you should read up here.

$ rails console
>> Rails.cache
=> #<ActiveSupport::Cache::MemoryStore:0x21e04b8 @data={}>

>> Rails.cache.write("rush", "limelight")
=> "limelight"

>> Rails.cache.read("rush")
=> "limelight"

>> Rails.cache
=> #<ActiveSupport::Cache::MemoryStore:0x21e04b8
     @data={"rush"=>"limelight"}>

Rails.application

The new Rails::Application class encapsulates a lot of what was thrown around in Railties in previous releases of Rails, and really represents the ultimate embracing of Rack’s modularity. Yehuda’s post can explain it further, but the important thing is now you can run multiple Rails::Applications in the same process if you need to, and it’s promoting decoupling even further by starting from the inside of the framework. Awesome.

$ rails console
>> Rails.application
=> #<NewApp::Application:0x13896b0 ...

>> Rails.application.routes
=> #<ActionDispatch::Routing::RouteSet:0x162877c ...

>> Rails.application.routes.recognize_path("rails/info/properties")
=> {:controller=>"rails/info", :action=>"properties"}

Rails.configuration

This gives you global access to all of the configuration data set up in your config/application.rb and various config/environments/#{Rails.env}.rb files, if you should ever need it.

$ rails console
>> Rails.configuration
=> #<Rails::Application::Configuration:0x7e1ab0 ...

>> pp Rails.configuration.middleware
[ActionDispatch::Static,
 Rack::Lock,
 Rack::Runtime,
 Rails::Rack::Logger,
 ActionDispatch::ShowExceptions,
 ActionDispatch::Callbacks,
 ActionDispatch::Cookies,
 ActionDispatch::Session::CookieStore,
 ActionDispatch::Flash,
 ActionDispatch::Cascade,
 ActionDispatch::ParamsParser,
 Rack::MethodOverride,
 ActionDispatch::Head,
 ActiveRecord::ConnectionAdapters::ConnectionManagement,
 ActiveRecord::QueryCache]
=> nil

Wrapup

I’m sure some are missing here (like Rails.version), but these are the ones that I think matter most to Rails developers. If something else should be covered here, let me know!

Load Rails conditionally with Rack

2009-11-10T00:00:00-08:00

One of the great things about Gemcutter is that it’s using Sinatra via Rails Metal to serve up the gems. Recently, I had to run some long migrations (~10 minutes) and I’m sure we’ll have some more in the future. Since the gem server is decoupled from the Rails app, some clever Rack loading now allows us to continue to serve gems even when we’re down for maintenance.

The config.ru now looks like this:

if ENV['MAINTENANCE_MODE']
  require File.join('vendor', 'bundler_gems', 'environment')
  require File.join('config', 'environment')
 
  use Rack::Static,
    :urls => ["/index.html",
              "/favicon.ico",
              "/images",
              "/stylesheets"],
    :root => "public/maintenance"
  use Hostess
  use Rack::Maintenance,
    :file => File.join('public', 'maintenance', 'index.html')
  run Sinatra::Application
else
  require 'thin'
 
  run Rack::Adapter::Rails.new(:environment => ENV['RAILS_ENV'])
end

So now, Heroku treats Gemcutter as a Rack app, and not a pure Rails app. Normally, it’ll just use Thin and boot up Rails as normal with Rack::Adapter::Rails. script/server still works as normal, too, but I’ll probably use shotgun instead.

The fun begins when you run MAINTENANCE_MODE=on rackup. The following happens from there:

Load up the Bundler environment that has all of our gems, and some of Rails’ magic.
Fire up Rack::Static to serve static assets like the images and CSS to make the site look nice
Use the Hostess, Gemcutter’s Sinatra gem server to continue to serve gems
All other requests are then caught by David Dollar’s rack-maintenance that simply serves up a static HTML page.
Use Sinatra::Application since we need some sort of endpoint.

And boom, we have a read-only site that continues to serve gems. Rack rules.

Gem Bundler is the Future

2009-10-14T00:00:00-07:00

If you haven’t checked out Yehuda Katz’s and Carl Lerche’s gem bundler yet, now is the time. This project replaces the horribly broken dependency resolution in Rails and what we all know and use as config.gem‘s. Ever seen can’t activate $gemname ($gemversion = runtime)? Or maybe my favorite, when it can’t even figure out what gem can’t be activated. If so, read on, bundler’s about to make your life a lot easier.

Yehuda has a great roundup of what can be done (and has been done with the bundler) on his blog. This is going to be a part of Rails 3, so you’re going to have to run into this sooner or later. I was getting frustrated with managing gem dependencies in Gemcutter, so now it’s bundled up and ready as a decent example of the bundler in action.

Enter the bundler

I’m using the edge gem built from their repo, and I suggest you do as well. Hopefully soon they’ll push it to that new gem hosting site I’ve heard so much about.

git clone git://github.com/wycats/bundler
cd bundler
sudo rake install

The Gemfile

Now we’re ready to make a Gemfile. This is basically a specification of what gems should be included in your app. Here’s Gemcutter’s:

clear_sources
bundle_path "vendor/bundler_gems"

source "http://gemcutter.org"
source "http://gems.github.com"

gem "rails", "2.3.4"

gem "clearance"
gem "will_paginate"
gem "sinatra"
gem "xml-simple"
gem "gchartrb", :require_as => "google_chart"
gem "ddollar-pacecar", "1.1.6", :require_as => "pacecar"
gem "net-scp"

only :test do
  gem "shoulda"
  gem "factory_girl"
  gem "webrat"
  gem "cucumber", "0.3.101"
  gem "rr"
  gem "redgreen"
  gem "fakeweb"
  gem "rack-test", :require_as => "rack/test"
end

only :production do
  gem "rack-cache",        :require_as => "rack/cache"
  gem "aws-s3",            :require_as => "aws/s3"
  gem "ambethia-smtp-tls", :require_as => "smtp-tls"
  gem "memcache-client",   :require_as => "memcache"
end

Some notes here:

By default the gem host is gems.rubyforge.org, so I’ve cleared the sources to use gemcutter.org instead.
You can easily specify gems for a given environment and multiple gems with only and pass it a symbol for the environment name. Thank goodness.
The default bundle path is vendor/gems. This won’t work for Rails since it assumes way too much about this directory, so we switch it to vendor/bundler_gems. Note: Yehuda has told me that this will work as normal once Rails 3 is closer/done.

Bundle up!

Now we’re ready to run gem bundle. This pulls down the gems from the given sources along with any dependencies. This basically creates a virtual RubyGems environment right inside of your vendor directory. (I’m cutting some out since the log is so long)

$ gem bundle
Calculating dependencies...
Updating source: http://gems.github.com
Updating source: http://gemcutter.org
Downloading actionmailer-2.3.4.gem
Downloading actionpack-2.3.4.gem
...
Downloading xml-simple-1.0.12.gem
Installing rr (0.10.4)
Installing fakeweb (1.2.6)
...
Installing nokogiri (1.3.3)
Building native extensions.  This could take a while...
Done.

So now in your vendor/bundler_gems directory, we’ve got the .gem files pulled down in cache, unpacked in the gems directory, and the gem specifications are unloaded into specifications. Bundler also makes its own environment.rb for loading the dependencies.

vendor
|-- bundler_gems
|   |-- cache
|   |   |-- actionmailer-2.3.4.gem
|   |   |-- actionpack-2.3.4.gem
|   |   |-- ...
|   |   `-- xml-simple-1.0.12.gem
|   |-- doc
|   |-- environment.rb
|   |-- gems
|   |   |-- actionmailer-2.3.4
|   |   |-- actionpack-2.3.4
|   |   |-- ...
|   |   `-- xml-simple-1.0.12
|   `-- specifications
|       |-- actionmailer-2.3.4.gemspec
|       |-- actionpack-2.3.4.gemspec
|       |-- ...
|       `-- xml-simple-1.0.12.gemspec
`-- plugins

Bundler will also dump gem executables in your Rails.root/bin directory. This means you can then use bin/rake, for example. Running rake as normal should still work though. As for your version control, it’s recommended to check in the .gem’s only, then run gem bundle to unpack/install them. This goes both for new developers and getting code deployed.

Loading the Environment

Now the issue is to load up the bundled environment instead of the system installed one. Start by creating a config/preinitializer.rb, which is loaded first before config/environment.rb:

require "#{File.dirname(__FILE__)}/../vendor/bundler_gems/environment"

Then, in each config/environments/*.rb file:

Bundler.require_env RAILS_ENV

This basically does a require for every gem listed in your Gemfile and their associated dependencies. That should be it! Your app should (hopefully) boot and now you should run your tests to ensure your application is still working right.

If you want to see this all in action clone Gemcutter and follow the contribution guidelines for getting up and running.

Issues

So, I had a few roadblocks with the bundler, and I don’t think it would be fair to not mention them.

The documentation sucks. I’m hoping this will improve before Rails 3 is ready (whenever that is). Maybe a Rails guide would be appropriate, and I’ll definitely help start it.
Gemcutter’s on Heroku, so it’s necessary to check in a lot of the vendored code (in fact, all of the development/production dependencies). New contributors just have to run gem bundle -u to get the test dependencies.
In my staging environment I had to use Bundler.require_env "production". Pretty self-explanatory but I missed it at first.
Shoulda macros just stopped working, since it assumes the location of gems in vendor/gems or vendor/plugins. I had to include this in test/test_helper.rb to make it happy:

Shoulda.autoload_macros(Rails.root, "vendor/bundler_gems/gems/*")

Wrapup

This guide went over how to use Bundler today, with a Rails 2.3.4 app. According to Yehuda, this eventually will be packaged in Rails 3, so the commands will be baked into Rails…so something like script/bundle. The nice thing is that you can use the bundler with any Ruby project, so this is good to know in general.

The bundler is really the future of gem dependency management. If you’re sick of fighting with config.gem‘s or are starting a new app it would be well worth your time to start looking at it. If you’re having trouble with the bundler (or success stories!) feel free to comment here or hop in #carlhuda on irc.freenode.net. Check it out on GitHub if you haven’t yet.

On Gem Forking

2009-10-09T00:00:00-07:00

So, GitHub has recommended Gemcutter as an alternative to hosting gems on GitHub. Of course, there seems to be an outcry, for three main reasons that I can see:

1) Effort must be made to move documentation and install instructions
2) Gem forking is not possible with the new site
3) GitHub gave no warning on this

As for #1, you’ve got a year to update your user base and get gems off GitHub. I’d assume that any actively maintained project has figured Gemcutter out by then. And for #3, at least we’ve got a new service that works and can meet the same needs.

Regarding RubyGem forking, I’d like to state that this statement is false. Gemcutter accepts built gems, so you simply need to mimic the actions that GitHub’s gem builder did: Open your .gemspec up, append your username to the gem name, and save. gem build, gem push, and done.

I think an important distinction must be made here: gem forking != scm forking. GitHub made it easy for anyone to automatically push modifications to gems, but there’s a bigger picture to think of here. Hopefully at some point, the changes you made will be brought back into the mainline gem. As David Dollar so eloquently puts it:

I think the general idea is that gem forks should be a huge special case. I’m somewhat of the mind personally that making gem forks too ‘easy’ causes a great deal of unnecessary fragmentation in the community. It seems reasonable to me, that if your project is going to depend on a gem fork, that the dependency resolution not be automatic, and your installation instructions can tell the user how to get the forked dependency.

If a fork is going to be long-term, or a true alternative, it should probably be reregistered under a new name as a different project.

Like I stated above, ‘gem forking’ is still supported just because of the nature of how Gemcutter works. I felt there needed to be a longer term solution for this in general, since now the community has grown used to it. This lively discussion ensued, and after some deliberation we’re going to use subdomains in order to solve the problem.

The idea is this: you’ll be able to register your own subdomain on gemcutter.org, such as qrush.gemcutter.org, and we’ll give you a completely blank index to push to. Hopefully you’ll be able to add others like the gem owner system works now. I feel this feature needs to be used in the following ways:

1) Subdomain use should be infrequent. It’s for trial/forked gems that shouldn’t be relied on for production.
2) Use prerelease versions for development snapshots (version numbers like 1.0.0pre, gem install yourgem --prerelease)
3) Don’t add someone’s subdomain as a source, unless you can completely trust anything they toss there. (like, your own for example)
4) Consider gemcutter.org/rubygems.org as the main, canonical repo that you can trust.
5) Start looking into gem signing/cert since it’s the way we can really trust gems

Of course, none of this subdomains stuff works yet, but it seems like the best way forward. It’s also spawning new, awesome ideas like password protected, private subdomains. If you’re interested in contributing to the project, please fork away or hop in #gemcutter on Freenode to see what’s happening.

This is our gem host now, let’s make it awesome.

Internbot Chronicles #6: The end

2009-08-26T00:00:00-07:00

Stupid ruby tricks

2009-08-13T00:00:00-07:00

RailsCamp NE Adventures

2009-07-20T00:00:00-07:00

The concept is simple: Get a bunch of developers together for a weekend away from the internet and most of civilization to have fun and relax. To be honest, I didn’t get to relax much, but it was made up in spades just by how awesome the event was.

The venue was the Maine MountainView House in Bryant Pond, ME I’m sure others will post better pictures soon, but the pond itself was beautiful. A dock, fire pit, and plenty of chairs made for some fun smore-making and werewolf games. The house was huge and definitely stood up to nearly 30 developers’ antics throughout the weekend.

The event itself was slightly organized, which was just perfect: catered lunch and dinner, and plenty of social hacking. Each day had a few talks showing off fun projects and interesting problems. Topics included covered internationalization with gettext, CouchDB, the Rails Rumble, rdoc.info, RadiantCMS, and plenty more I’m probably missing. I showed off Gemcutter and got plenty of awesome feedback and ideas for the site.

As for hacking, it was an interesting mix of people and skill levels. Quite a few developers were there mostly to observe what others were using for tools and to understand how they work. I loved showing off Cucumber and I definitely heard the good word of TATFT being preached. I wish I could have watched a little more, but I was having too much fun coding away.

My adventure went something like this: The start of Saturday got a few people talking about ideas to hack on, and perhaps a project the group could work on together. Nick Plante mentioned games via Twitter, and that eventually lead to implementing DopeWars. From there, some went outside on the porch to sketch out how the app would work, and we then wrote some basic user stories. It ended up that Jason and I banged out a quick prototype in Sinatra and got something decently working. On Sunday, amongst recovering from some late night Urban Terror, I hacked with some others on searching gems via Gemcutter’s web interface.

If there’s a RailsCamp going on even remotely close to you, do everything you can to get there. It was more hands on than RailsConf, and the amount of networking and fun being had was multiplied. I’d just like to say thanks to the organizers, Pat Allan and Brian Cardarella, for working hard to put on a great time for all. I’d love to help organize a RailsCamp in the future, perhaps since I’m returning to Rochester soon it could include the Great Lakes region and bring in hackers from NY, PA, OH, MI, and more. (If you’re interested too, leave a comment!)

The Journey to Ruby 1.9

2009-07-17T00:00:00-07:00

Internbot Chronicles #5: Training Reflections

2009-06-25T00:00:00-07:00

Internbot Chronicles #4: CI & Test Metrics

2009-05-29T00:00:00-07:00

Git Started with Git

2009-05-01T00:00:00-07:00

One of the best parts about my internship at Thoughtbot is that I’m able to participate in the awesome Ruby user group meetings nearby. For the month of April I talked about learning Git and how it can be integrated into your daily life at three different venues: Boston.rb, BarCampBoston 4, and NHRuby. Here’s the slides from the talk:

What I definitely enjoyed the most was getting questions and feedback from the audience. I was half afraid that I was leaving them far behind with some of the advanced topics (especially with rebasing) but from what I gathered most seemed pretty solid after the talk. I don’t think I could ask for more than responses like this (thanks!):

One aspect that really bit me was dealing with amount of material and questions, especially since the time requirements were different for all three. I cut plenty of slides out to fit it under an hour by the end, since my original timeslot was roughly double that. You can get all three versions if you’re extra curious here.

BarCamp Boston 4 Roundup

2009-04-26T00:00:00-07:00

BarCamp Boston 4 has been a lot of fun. This post is just a roundup of the talks I went to on Sunday. I gave a talk about getting started with git, which seems to have went well.

I’ve never been to MIT before, and I need to come back and explore the campus more. It was held in the MIT Strata center, which is absolutely ridiculous. The architecture is really just unreal. Also, I can’t believe how much pizza a few hundred nerds can down in a manner of minutes.

One of the neatest things was that a project was being run in the hallway with a Wiffiti stream of the tweets, pictures, and more that was going on:

Here’s the talks I went to and what I got out of them. You can see the full schedule here.

how to be a freelancer

The person giving this talk wanted to hit like 8 points, but I think he only got to 3. What ensued was plenty of discussion on how to deal with clients, how to ditch them, and problems that come up with freelancing in general. The general gist I got from it: I’m glad I don’t have to deal with that.

Code secrets

This was a great idea: people in the audience write down horrible, deep, dark secrets about code they’ve written, and then they’re read off. Hilarity ensued.

Starting a Boston startup space

Sadly I didn’t pay too much attention to this one, but my basic gist was that it’s a community service, and it’s tough to decide a business model that works for the people you’re serving. I’ll definitely be utilizing the local coworking if I end up on the lam as a freelancer or mobile worker after school is over.

Fun with QR Codes

QR codes are really neat, and can do some ridiculous stuff. They’re really awesome for embedding URLs into the real life, like putting a QR code near a bus stop that can open a schedule for you. I just wish my phone didn’t suck so I could actually read them. I do wonder how this concept would catch on with the general public. What is really funny is to watch people try to read the QR code on their phones from the screen.

JavaScript Testing Discussion

Lots of gripes about the current state of testing JS in the browser. There’s plenty of ways to DO testing in the browser, but there doesn’t seem to be a be-all, end-all solution. Listing out various testing frameworks, but there doesn’t seem to be many familiar with most of them. Complaints, bitching and moaning about how difficult this situation is. It all boils down to not being able to remove the human element from testing it correctly.

Ruby Testing Panel

Seems to be a general discussion of what’s going on in the Ruby testing world and reactions that people have. Starting off with a rant or reasons why to Test First. Diving into some differences between RSpec and Shoulda and their syntax differences. Some talk about mocking and stubbing and the different libraries. This discussion went for an hour but I skipped out early to make the next talk.

Introduction to the Arduino

Should be easy to translate software development experience into the microcontroller world. Throwing some around the room so we can get a look at what they are. Huge advantage: the bootloader. All you need is a USB cable and you can load code on it. There’s ways to get around it or write your own too. Ridiculously neat demo: the arduino spins a platter with a thin slot that has LEDs beneath it. There’s a lens at the top of the platter that the arduino can hook into, and control the speed of how fast the platter will go. Lots of C code and magic registers that you need data sheets for. I wonder if the Ruby library abstracts any of this away. Data sheets just seem scary, but useful.

LOLCODE 101

This isn’t 100% serious, but for some reason somebody made a programming language around this meme. I would post some code but pygments doesn’t support the language. Best part of the language: DIAF is exiting with a status code.

Internbot Chronicles #3

2009-04-24T00:00:00-07:00

Internbot Chronicles #2

2009-03-30T00:00:00-07:00

Internbot Chronicles #1

2009-03-13T00:00:00-07:00

Checkout tracked remote branch with Git

2009-01-07T00:00:00-08:00

I frequently need to do this when setting up or syncing my various machines, and I seem to forget the command all the time. So let’s say you’ve got more than one branch on your remote, and you want to bring it down into your local repository as well:

Viewing information on the remote should look something like this:

$ git remote show origin
  * remote origin
    URL: *************
    Remote branch merged with 'git pull' 
      while on branch master
        master
      Tracked remote branches
        haml master

Luckily, the command syntax for this is quite simple:

git checkout --track -b <local branch> <remote>/<tracked branch>

So in my case, I used this command:

git checkout --track -b haml origin/haml

You can also use a simpler version:

git checkout -t origin/haml

If you only could follow 10 people on Twitter...

2008-12-11T00:00:00-08:00

…who would they be? I’m following a staggering number of people (1,337 to be exact), and the signal vs. noise ratio is just getting out of control. I’m not sure how I got into this situation: I just started following everyone that followed me, and it spun out of control. I see a few options from here:

Remove everyone and start again.
Set up groups in TweetDeck and continue to follow a ton of people.
Slowly whittle away until my following/follower ratio is down to 1:1.

This got me thinking…what if you could only follow 10 people? Who would I follow and why? I present my list, and I encourage you to think of your own.

ablissfulgal: My girlfriend. I don’t need to explain this one.
mittense: Former coworker from Stardock who plays way too many video games.
GarrettAtreides: Classmate at RIT, MS lover, and all around goofy dude.
AmazingSyco: Classmate at RIT, Cocoa hacker, and all around funny dude.
chorn: Local Ruby fan that’s a riot. Supposedly he’s a CTO too.
BreakingNewsOn: For those who prefer their news in ALL CAPS.
defunkt: One of the GitHubbers and an awesome Rubyist.
faithfulgeek: Convert to the Ruby/OSX world from Microsoft. I’m going through the same transition.
nakajima: Ruby ninja who’s a code machine. And he’s hilarious.
guykawasaki: Entrepreneur extraordinaire. I’m listed on his site as a Twitterati too.

To those who didn’t make the cut, don’t feel bad! It’s not that I don’t want to communicate with you, just most likely I can communicate easier through a different channel (IRC, IM, what have you).

Who would you follow? Let me know in the comments or make your own blog post!

Open Source Collaboration with Git and GitHub

2008-12-05T00:00:00-08:00

I just gave a talk at the Society of Software Engineers’ Tech Talk Thursdays about Git and GitHub. The talk was a mashup of Scott Chacon’s various resources on Git along with Michael Hartl’s presentation on contributing to Insoshi with GitHub. I think it went pretty well and it was followed by some good discussion.

The talk is an introduction to Git from the perspective of a student who has used version control before (and hopefully has learned a bit of graph theory). I went over the little history that Git has, why Git rocks, and how helpful and easy it is to use GitHub. Check out the slides: (yes, there’s puppies)

Open Source Collaboration With Git And Git Hub

View SlideShare presentation or Upload your own. (tags: oss collaboration)

It was definitely a lot of fun. (I almost wish someone was taking notes!) Someone was taking a video, so hopefully it’ll be up soon. Next time I give the talk I want to show how easy it is to convert from svn/cvs as well as create and browse repositories since I got a lot of suprised looks about git init and git instaweb during Q&A.

GitHub Rebase #6

2008-12-01T00:00:00-08:00

The sixth edition of my column is live: http://github.com/blog/246-github-rebase-6

I’m slowly improving the parsing process. For the last edition I broke out all of the work the app does into rake tasks, and then the Rails site is just for viewing the data. Basically there’s a few steps:

Download ATOM feeds (This week, 1400. Last week, 1200).
Check that all of the downloads went ok. (Bad gateway errors happen to good people)
Parse the files, making sure that events are unique and users forkers are logged.

Surprisingly I’m relying less and less on my app to get the column together, which is good. Huge kudos to the GitHubbers for creating the Recently Created page for each language. This helps me diversify the column while avoiding a lot of data crunching on my end.

Next week I definitely want to parse the entire month’s worth of events to really see the trends come out. Luckily their atom feed goes back 4000-5000 pages (of 30 events each) or this wouldn’t be able to happen. What this will mean is that I’ll actually have to optimize the download and parsing as much as possible. Stay tuned!

GitHub Rebase #4

2008-11-17T00:00:00-08:00

The latest edition is now up! http://github.com/blog/224-github-rebase-4

I really need to get some of this process sped up and automated. Currently I have to manually look up all of the repositories, and creating the table was a bitch. I also need to figure out how to make my Rails site that processes GitHub’s RSS feed to be multithreaded so it doesn’t take an hour or two…or three…to figure out what’s going on with it.

GitHub Rebase #3

2008-11-09T00:00:00-08:00

Geez, it’s been 3 weeks already? The third installment is up at:

http://github.com/blog/208-github-rebase-3

GitHub Rebase #2

2008-11-03T00:00:00-08:00

The second edition of my weekly installment is now hosted at GitHub!

Next week I’m going to release it on late Saturday, or perhaps early Sunday. It’s a bit late this week, but I don’t think anyone will notice.

GitHub Rebase #1

2008-10-26T00:00:00-07:00

This is the start of a new weekly column that going to recap some of the action that’s been happening on GitHub during the past week. My goals with this column include:

Prove that Git is a great choice for version control!
See how active the community at GitHub really is and what they’re working on.
Show how Open Source development is truly open.
Using the magic of feed-normalizer, hpricot, and gchartrb, I’ve created a little Rails app (dubbed Rebase, of course) that I can use to rip all of the events that are going on at GitHub. I’m going to try to keep the format of the column consistent, but I definitely need your feedback to make it better.

Stats Breakdown

And, just for fun:

Notably New Projects

Each week I’m going to look over some interesting new projects that have just showed up on GitHub and explain what they’re about. If you have a project you think I should showcase, let me know and I’ll see about featuring it!

Wysihat: A minimalist’s approach to WYSIWYG/Rich Text Editor. Right now it’s very, very beta, but it has the support of 37Signals so I definitely hope it’s destined for greatness. Once some decent themes are created for it, I’d definitely consider integrating it in some of my sites. This project definitely is growing and needs help, so fork away.

Android: Google announced that their Android framework was going open source and was hosted on Git, so it was clearly only a matter of time before their code landed on GitHub too. They have a ton of projects in their codebase, but it doesn’t seem like all of them have pushed yet. Definitely looks promising though, and I really would like to see how their system works.

acts_as_passive_aggressive: Just in case you ever needed a way to vent on your users, this plugin provides the perfect opportunity. I love the project’s readme.

VoteReport: This is a new Rails site to track the election next week through Twitter. They’ve got quite a lot of documentation on their PBWiki, and I really hope that this site turns out to be a little more useful and fun than watching tweets fly by on Twitter’s election page. If you want to help them get the project up and running before the 4th, go for it!

javascript-xhtml-purifier: A new, robust JS script to sanitize HTML. I can guarantee that at some point most web developers will need to do this, so bookmark or clone away.
Next week I’d love to break down the stats a little more and figure out what commits were the most commented on, and maybe which projects had the most activity. Let me know what you’d like to see in the future!

Pumpkin Carving 2008

2008-10-20T00:00:00-07:00

In 2006 I created a stormtrooper. Last year was HomestarRunner. This year however, I paid homage to the one and the only, Octocat:

This of course is the logo of one of my favorite sites, GitHub. We’re having our Halloween party this weekend so I made this guy a little early this year.

If you’re curious, you can see the creation process on my new Flickr account (their upload and photo managing interface is kickass!). If you’d like the stencil I used, just leave a comment or email me. Happy Halloween!

Where do you get Ruby news from?

2008-10-19T00:00:00-07:00

I’m wondering where other fellow Ruby and Rails hackers get their Ruby-related news fix from. For some reason I just feel continually disconnected from the community at large and I just want to make sure I’m taking advantage of the resources out there. So here’s my news sources:

Ruby.Reddit (http://reddit.com/r/ruby): This seems to be one of the most active sources, and usually the commentors are fantastic. It’s community-driven news at its best, but sometimes it’s a little slow compared to the other subreddits. What I like most about it is that the community is relatively small, so if you post a story it usually sticks on the page for a few days.
RubyFlow (http://rubyflow.com): I just got into RubyFlow recently, and it seems more like the community well than anything. You can throw a coin in and wish for some visitors to your blog, but you’re usually lost in the mix. It’s a very interesting concept though, and it’s definitely fun to see big names in the Ruby community on the list.
Ruby.Alltop (http://ruby.alltop.com): Alltop is awesome for getting an overall sense of where the community is right now. It’s Guy Kawasaki’s ‘magazine rack’ of latest Ruby stories…essentially a RSS aggregator. I’ve discovered quite a few blogs I didn’t know about and now keep track of through it. One of my goals with this blog is to get on there someday! :)

I suppose my secondary news sources would be Freenode’s various Ruby channels (mostly #rubyonrails) and the Rails mailing list, but I don’t check those as often. I’ve also heard about a secret channel, but who knows if I’ll ever get in there. Those also don’t have a handy RSS feed, so I tend not to check them as often. So, where do you get news about the Ruby community from?

Calculating Age in Rails

2008-10-13T00:00:00-07:00

You’d think that this would be easy, but for some reason it wasn’t, at least for me. Let’s say you keep track of a User’s birthday with a date field. Great! Let’s show the user’s age.

def age
  Date.today.year - birthday.year
end

Done! Right? WRONG. Worked fine for some users, until one of my coworkers asked me…hey, you’re not 21 yet…how’d you magically gain a year on your profile? Crap. Obviously this will work for everyone’s whose birthday is BEFORE Date.today, but not after.

So, we need a more exact method of calculating the age:

def age
  ((Date.today - birthday) / 365).floor
end

So what this method does instead is use the Rational value given by subtracting two Dates, and divides it by the number of days in a year. Since that number is still a Rational, calling floor on it will round it down to the nearest Fixnum, giving us a (slightly more) precise account of this user’s age. EDIT: But this is still inaccurate!

Yeah, I thought it was easy too. Perhaps this shows that I need to test my app a little more thoroughly! It also would be nice to save the age in an instance level variable, but right now I don’t use the age more than once on a page so it doesn’t matter.

EDIT: It looks like my method is still not sufficient for leap years! The comments have posted MANY great solutions. My method is fine for a general estimation, but the comments have many solutions for that deal with greater accuracy. I’m honestly not sure which is best, so choose carefully when you’re developing your app.

Loading custom code in Rails

2008-09-22T00:00:00-07:00

This is a question I’ve seen asked (including by myself) in #rubyonrails on Freenode quite a few times, and I figured I’d settle it once and for all. There’s a few different ways to get custom code loaded into your Rails app. The first solution to this is understanding how code gets loaded with Ruby in the first place, which I usually get confused with. Let’s do a little recap about your different options that Ruby and Rails provides:

load: Loads and executes the Ruby program in the file filename.
require: Ruby tries to load the library, returning true if successful.
require_dependency: Reloads source files on each request when in development mode, so changes are reflected on the next request.
require_or_load: There doesn’t seem to be much documentation on this, but it doesn’t seem as safe and it may result in your code being loaded twice. Review the code here before you use it.

So, the most ideal keyword to use is require_dependency, since it will reload code during development mode when you make changes. Otherwise, you’ll have to constantly restart your development server/console, and that just sucks. Plus, it’ll work perfectly in production mode and only load the files once.

So, where’s the best place to put the files with your custom code? Well, there’s a few folders that are on the Rails load path in the first place: app, lib, vendor and mock paths (source) you need to add different folders to the load path, that’s more than possible. In your config/environment.rb, add whatever folder you want in the config.load_paths variable. For instance,

config.load_paths += %W( custom )

This will load the custom directory (RAILS_ROOT/custom) to the load path so you can use those files. The problem with files you put in these directories is that they may be in the load path, but you’ll have to require the custom files you want in each class that you’ll want to use them. The solution to this is to get the file required for the entire Rails environment, which is a lot easier than you’d think.

Let’s say we want to load some extensions to String for your app. Being a forward thinking developer, you’ve created a new folder in lib, called core_ext, where you can put other ruby files in the future if you need to. So in lib/core_ext/string.rb you’ve dumped for example:

class String
  def slugify
    self.gsub(/[^a-z0-9]+/i, '-').chomp('-')
  end
end

The folder config/initializers contains files that run once when your Rails environment is getting set up. Create a new file in that folder and this will run through your custom folder and make sure that the files are required properly.

module CoreExtensions
  def require_core_ext
    Dir["#{RAILS_ROOT}/lib/core_ext/*.rb"].each do |f|
      require_dependency f
    end
  end
end
Object.instance_eval { include CoreExtensions }

So now, you can call require_core_ext in whatever class you want, and it will reload all of your custom code if you’re in development mode or if you’re in production, it will only load your custom classes when the file is first loaded. Now you can call String#slugify all you want, and if you make changes to the method in lib/core_ext it will be reflected when you refresh the page.

If you’ve got any other examples of how you bring in custom code, let me know, as I’d love to find out.

Switching to Rails

2008-09-18T00:00:00-07:00

For a while now I’ve been obsessed working with Ruby on Rails. Rails has caused me to switch from doing .NET/ASP.NET development on my desktop PC using Windows XP to owning a Mac Mini and putting Ubuntu on Dell laptop. Obviously, this is a huge change, and I’m going to explain why I’ve switched.

Rails is a combination of software engineering principles and web programming best practices.

In this respect Rails is a dream: Active Record. RESTful architecture. Built-in xml/json/etc web services. TDD/BDD practices. I could go on and on, but all that matters is writing Rails applications is an enjoyable and fun process. You’re not writing scripts for pages, not having to worry about the nuts and bolts of creating a site, or dealing with painful XML files. Convention over configuration is a real path to productivity, and it’s going to take the other competing systems a long time to catch up to the headway that Rails is making on a daily basis. Rails isn’t the solution to everything, and it certainly has had it share of growing pains, but it’s being proven again and again as the most efficient way to create data-driven web applications that are very reliable and follow web standards.

Tools on *nix based systems are a lot better for Rails development.

DHH puts it best:

The stigma of being a Web programmer still using Windows will increase.

For me, it’s not that much of a stigma, but more of a practical issue. The power of the Unix command line combined with tools like Textmate makes development on OSX and Linux machines for Rails a LOT easier. The tools on the Windows side are there, but they’re usually not as powerful and not as easy to set up. Cygwin is piss slow. Most of the non-Visual Studio text editors suck. The command line sucks, and I tried really hard to make it not suck. Even Ruby is slower! All of this pain goes away on OSX/Ubuntu. Rails would be a lot different if it started on Windows, and I wonder if it would really be the same platform. For now though, I’m loving the productivity boost that I’m experencing and trying out different operating systems, and it serves my needs well.

Bleak future of .NET development.

This one will probably get me flamed the most. It’s not that I don’t like .NET, it’s just that I couldn’t see myself using it any more professionally. I’m really not a fan of VB.NET, especially compared to Ruby. It’s a cruft filled language that makes me feel like Mort when writing it. Great things are possible with the language, but the result is so unreadable and ugly that I don’t feel it’s worth it anymore to use, especially if I can choose not to. C# on the other hand I love and always will, especially over Java.

What scares me more about .NET is where’s it’s going: Silverlight and WPF. WPF is supposed to be an awesome new platform that makes it easier for both programmers and designers to collaborate and create great applications. Seriously though, where are the great WPF applications? Why haven’t we heard as much about them, as say, the newest iPhone apps? I could say the same for Silverlight. Oh wait, the Olympics. ooh, Yahoo Messenger! Whatever. Nothing is going to kill Flash’s market share.

I’m sure that things have changed since I was heavy into (bleeding edge) .NET development 6-9 months ago, but still there seems to be no killer app for WPF or Silverlight yet. Until that happens they’ll just suck like everything else. I’d love to be proven wrong on this point, so if you know of one please show me.

If you’ve switched away from Windows or even if you’ve become a Rubyist/Pythonista in recent times, let me know what your experiences have been. For now on my blog posts will hopefully be a bit more frequent, and will chronicle various quirks and fun things I’ve found during my Rails journeys.

Raytracers, snowflakes, and Pac-Man, oh my!

2008-05-23T00:00:00-07:00

So yeah, this is pretty much what I’ve been up to for the past, oh, 3 months/1 quarter of school. These are a few of the projects I’ve done for my Computer Graphics 2 class (which I just got an A in, booyah!)

First up, the classic CG application, a ray tracer complete with phongphongphong shading, procedural shading on the floor, reflection, transmission, and even some tone reproduction.

Secondly, my quarter long personal project, a simple particle system/b-spline curve generator in XNA, dubbed Q-Blizzard. Turned out to be quite pretty, not exactly configurable though.

And finally, an image that won me a $25 Barnes and Noble gift certificate in the Pixar Renderman Shader contest. I won third place out of around 30 images! My roommate noted that I should have added an OM NOM NOM caption in for kicks.

Hopefully this will mark my return to regular blogging (going to try monday, wednesday, friday) for the summer and onward. Hell, if mittens can keep up his Daily GameDev.net postings for 2 months, I can do it too. Right? …Right? (I seem to tell myself every few months or so…)

Rock Band Rocks.

2008-03-27T00:00:00-07:00

It simply does. That is all.

Oh, you wanted to know why! Well, if you’re still reading and not playing it, there’s three reasons why Rock Band is an awesome investment (it’s still $169.99) for your Xbox 360, PS3, or (soonly) your Wii. First off, the UI is a lot cleaner than Guitar Hero 3’s.

Now, do remember that 1-4 people are watching the TV at a time for Rock Band instead of only 1-2 for Guitar Hero 3. However, the Rock Band interface is extremely simple. No complex images on the fretboard, a scoreboard that is easy to see, and the Overdrive meter is so much easier to understand than the star power gauges. All you want to know when you’re playing either of these games is what your multiplier is and if you can use your star power/overdrive or not. With Guitar Hero 3, they’re on complete opposite sides of the screen! Also, the star power gauge is made of lights that fill up, and it’s even harder to see when playing with two players. For Rock Band, all of that information is in one place, at the very bottom of the fretboard, beneath where you’re looking at most of the time to play notes. Obviously, the team behind Rock Band really looked at how people play Guitar Hero and what’s essential to see when you’re playing, and turned that into a brilliant design that’s easy and fun to play.

Secondly, the downloadable content rules. Grant it, I haven’t looked that much into GH3’s available songs, but Rock Band’s library continues to grow. My most recent downloads have been Limelight and Working Man from Rush, Crushcrushcrush from Paramore, and the huge Boston song pack. These new songs bring so much replay value to the game it’s not even funny. Obviously they have all 4 playable parts in the songs, but you can opt to play the downloaded songs in the World Tour mode. So now, I can earn money for new looks and instruments by pretending I’m Geddy Lee.

Finally, the drums just rule. It’s a completely different experience than the lead/bass guitars, and there’s something truly enjoyable about banging pretend drums with real drumsticks. It’s also a huge challenge for me, even on Medium the songs are pretty difficult, especially since the bass pedal is a central component to most songs. It’s a game controller like no other, one you can beat senselessy and not feel bad about it.

If you’re not able to get it yourself, at least visit someone’s house that has it, I assure you that you’ll definitely feel like a rock star, at least for a few minutes. Heck, if they get the new lights and smoke set, all you’ll need are some serious clothes to match.

Why I love Twitter

2008-03-25T00:00:00-07:00

I’ve become quite a twitterholic the past few days. In fact, let’s check the stats. Yeah, I’ve been pretty much addicted the past few days. Why? Well, there’s a few things I love about Twitter:

Twitter is short, sweet, and easy to use.

The concept is simple: 140 characters to tell the world what you’re doing. I don’t think you can get more simple than that. No complex forms, no huge commitments, just a simple request, and your simple answer. It has a wonderful web interface, and the settings allow you completely customize your page’s background along with colors for fonts. It’s just a breeze to use and easy to look at, which is a welcome change compared to Facebook or MySpace.

It’s an awesome way to network with highly connected bloggers.

I think Scoble puts it best:

You’re communicating to the world that you’d like to be listened to (golden rule: treat people how you’d like to be treated).

Twitter is becoming the heart of the Interblag. It’s what bloggers are doing when they’re NOT blogging. Obviously yes, we all have our jobs and commitments, but Twitter is a way to connect with those people between their blog, vlogs, or however they communicate with the internet at large. It’s a way for those who are connected to quickly poll, grow, and comment with their audience. The value to bloggers to be active on Twitter is absolutely critical: these are the people who you WANT to be reading your blog. They’re the people that will link your blog to others, they know where to share it and who to share it with. They’re all here folks. Come and find them.

It’s a great way to keep in touch with friends.

I think Twitter in Plain English hits the nail on head: Twitter is a way to converse with friends in a way that isn’t that important to email them, but doesn’t necessarily demands their instant attention. Of course now, you can use Jabber/XMPP to interface with Twitter. Anyway, I find it to be a neat way to keeping in touch with people I know in the real world online that isn’t exactly bugging them over AIM or Facebook. Also, if you’re concerned about random people like me following your every move, you can make your page private and only allow those you approve to watch your updates.

It’s just fun to use!

What really gets me with this are the fantastic clients that seem to be populating the net. The Twitter API is readily accessible and easy to implement, and that’s extremely important as it seems that most people use twitter through outside clients or through text messaging rather than their web interface. My personal favorite at the moment is Twhirl, which is an Adobe AIR client. It’s got a neat, clean interface and colors are customizable, so I’m having fun with it. I rarely have to go to the website anymore, the API is so open that the majority of the functionality is accessible through outside clients.

So, why haven’t you created a Twitter account yet? I guarantee you that it’ll do nothing but help you get your blog known, and connect with others who are on the same quest. Feel free to follow me as well, I’ll make sure to follow you.

Pimping the Windows Command Line

2008-03-20T00:00:00-07:00

Lately I’ve noticed that a few of my friends have been able to understand or even be aware of the Windows command line. I have a hard time myself pulling myself away from Explorer, but sometimes the command line is just quicker. However, it’s a bit drab by default. Today I’m going to show you just how you can pimp yours out a bit.

First up is a wonderful tool called Console2, which is an open source tabbed command line utility. It allows easy configuration of fonts, colors, the background colors, and even lets you do some really crazy things if you wanted such as adding a background image. The best feature by far though are its tabs, which I’m sure if you’ve ever used IE7+ or Firefox you know how useful they can be for multitasking. Another great feature is that you can set up plenty of keyboard shortcuts if you’re into that sort of thing. Check it out here: http://sourceforge.net/projects/console/

Console is great if you want to fire up a specific program all the time, but I’m used to slamming WinKey + R and typing cmd so much that it’s basically embedded into my muscle memory. So, I was looking for configuring the default prompt instead of running another program. Pimping out my command prompt has taken me quite a while to find the perfect configuration that suits my needs, and it’s constantly changing as I find new things to add. Here’s what I’ve done to trick mine out:

I’m using Consolas as my font. I absolutely love Consolas and I find it much easier to read than Courier New or the default font that the command window has. Consolas is not available by default and requires a simple registry hack along with a reboot in order to work. I haven’t had any issues with it thus far, and I highly recommend following Scott Hanselman’s wonderful tutorial.

I’m not a Windows command line user at heart, I was raised during my Computer Science classes to poke around Linux machines. Sadly, certain commands like ls -la come much more naturally to me than dir /a. My solution to this is installing the CoreUtils for Windows package, which adds most of the core GNU utilities into the command line. This hack requires installing a package from SourceForge and adding to the PATH environment variable, which are covered in this blog post over at AskStudent.com.

Finally, I’m a huge fan of using the pushd/popd commands: push directory and pop directory. Basically it’s a way to return to directories instead of having to overuse cd or even remember where you were. Luckily, there’s an easy way to keep track of the amount of directories that have been pushed onto the stack by changing the PROMPT environment variable to:

$p$_$+$g

Check out the AskStudent tutorial to see how to do get to the environment variables window if you don’t know how. What this does is add + symbols to the command line window as shown in the screenshot. It’s ridiculously useful, and now I just wish I could figure out how to automagically pushd and cd at the same time.

If you’ve got any questions regarding pimping out your command line or other great hacks I’m missing out on, let me know!

Defraggle Rock

2008-03-18T00:00:00-07:00

As always, I’m late to jump on the ~~fail~~boat, and this time I’ve decided to do some serious maintenance on my computer. I’ve had enough of having to rely on System Restore and worrying that I’ve lost all of my data, or that my computer is on the brink of death. So, I’m going to start maintaining my system more, and that’s starting with keeping my hard drive as tidy and speedy as possible.

My buddy Island Dog pointed me towards a great tool called Defraggler, and this started my journey. Essentially, it allows you to really control the defrag process from a drive and individual file level. It also includes the color graph that sadly, Vista removed. Obviously, this tool is pretty much only for power users, as I’m sure grandma doesn’t even know the slightest about what a hard drive even is. Partly I’m glad that Vista streamlined the process of defragmentation, but I have a feeling normal users won’t be doing it regularly until Windows does it for them or it’s watered down to one huge button called “Drive Maintenence” that does Disk Cleanup, a defrag, and whatever else fun stuff Microsoft decides that your drive needs. For users like me however, I like having a bit of control. Not too much though, I’m not a supervillian.

Anyway, Defraggler is a very neat app. It clearly presents the process, what files need to be moved around, and shows your data being moved around. It also allows you to switch the process priority from normal to background so I can actually use my computer during the process. This is nice for XP, while the visualization helps on Vista. I find the color graph absolutely fascinating since I’m scared to death of low level stuff like this, but my mind does wonder how defragmentation works under the hood. Maybe someday I will be a supervillian after all…just definitely not using Linux to control my orbiting brain lasers.

Turning off the Firehose

2008-03-16T00:00:00-07:00

I recently came across this post about a user who decided he had enough of the user-generated news community, Reddit. I’ve been a Reddit user for a quite some time now, and I’ve done my share of down voting Ron Paul stories as well submitting silly pictures that have made it onto the front page. Lately though, it’s become more than a habit to check this site. I have a very compulsive personality, and I tend to find some sort of deep and intensive joy in small, minute improvements and changes. I know this is the reason why over 70 days of my life were wasted on World of Warcraft, and I’m pretty sure it’s the reason why I find programming so fun. Most people would be frustrated by missing a semi-colon and be absolutely stumped by the quest for perfection that compilers demand, but to me it’s another challenge, another hurdle I know I can overcome. It’s also the reason why some days I’d refresh Reddit every 5 to 10 minutes to see if my karma had changed.

Reddit has been sucking up way too much of my time during the day, and I’ve decided to put an end to it. All I did was block it through my hosts file to redirect to 127.0.0.1, which works out well since during my work time it directs me to the website that I’m developing.

So, I’m turning off the firehose. I will probably end up blocking Digg and Slashdot as well, and I need to set up Google Reader for my favorite blogs. Yeah, this means I’ll sacrifice that information intake that my brain is used to, but I feel that time could be used to read the several books I have lying around my room, be it Code Complete or the Mythical Man-Month. My guitar is also gathering plenty of dust, and I have a few side projects that I could be working on as well. Here’s to less distractions! Do you have distractions that you could probably do without?

5 Things That Video Games Do That Really Make Me Angry

2008-03-13T00:00:00-07:00

I’m sure that this list could be a lot longer, but I’m going to focus on six issues that really piss me off when I’m playing video games. If games happen to have more than 2 or 3 of these traits they tend to collect dust in my game cases very quickly, or they will do the same at your local game store. So, without further adieu:

Not being able to skip cut scenes

Sometimes, gamers just want to jump into the action. Yes, I know that designers have spent grueling hours working in their wonderful plot into the game, and skipping cut scenes may mean that the gamer will miss out on crucial story elements and possibly even essential game hints. Well, that’s just too bad, and sometimes I don’t mind taking that kind of chance. Perhaps I just need to vent a bit by blowing up some aliens or lighting a few people on fire. Another gripe I have with this is that some games don’t make the option apparent if it is available at all during a cut scene. Please make them optional. I beg you. One game I played recently that either I couldn’t skip or couldn’t figure out how to skip was Metroid Prime 3: Corruption. It’s now collecting dust in my cd case.

Bad artificial intelligence

This one is probably hated by most gamers, and we’ve all seen it. The AI runs enemy monsters or units into a wall, they can’t figure out how to path correctly to follow you, or perhaps the designer of the game just didn’t test the AI in the way that you think it should work. Well, it pretty much sucks when this happens. Rarely though is it a reason to stop playing a game, but when the AI is good it’s easy to tell, and in some cases it’s actually frightening.

Hard to use menus

This is a killer when you’re trying to get things done fast. One might think that this kind of behavior is a no brainer and should be somewhat of an industry standard by now, but sometimes game designers absolutely fail at the 2D portions of the UI. One example I love is simple and definitely proven are any of Valve’s game menus. They are somewhat of a convention in Valve’s games and they present easy options first for beginner users while also allowing more experienced users to easily whip through menu choices. Crappy menus and other UI options are very easy to spot. One of the worse things you can do is slow down a user as they’re going through the menus. Warcraft 3 does this with the stupid chain menu system, which I’ve grown to loathe. Sometimes games can fail completely in both usability and readability, the biggest example of this I can think of is Dead Rising. I couldn’t even read the menus since the text was horrible and it was laid out poorly. Ugh.

Collect-a-thons

When I was 10, I used be able to stand running around various platformer worlds gathering every last bit that games could offer me. Hell, I even got 101% in Donkey Kong 64, but I wasn’t hardcore enough to get all the stars in Super Mario 64 or all of the golden skulltulas in Ocarina of Time. Now however, I absolutely can’t stand it. Games can get by without them just fine, but for some reason developers continue to inject these endless quests. World of Warcraft could even be considered one giant collect-a-thon. I guess that this mentality appeals to some gamers, but I’m over it. And yes, I did beat Super Mario Galaxy, just with the minimum amount of stars.

Voice chat

Ah, the bane and boon of online gaming. I’ve become somewhat jaded to this miracle of modern technology, and now I’m absolutely sick of it. If I’m playing an FPS, I’m there to snipe someone’s head off or lay a trap to waste them with, and not to listen how their day went or who in pop culture is ridiculously hot and said nerd doesn’t have a chance with. I don’t want to hear about how someone is cheating, hacking, or just being a bag of douche in the game. Get over yourself, and shut up. One of the first things I’ll do with games that have voice chat embedded is turn it off immediately. I’d rather leave voice chat to external programs that can be dedicated to the sole purpose of transmitting voice instead of having to build all of that extra functionality into the game.

What things tick you off about video games? I’m sure there’s irksome moments that occur on a daily basis for any gamer, and here’s your chance to rant about it.

Flash and WPF: A pain in the ass.

2008-03-09T00:00:00-08:00

I could say this about WPF as a whole, but when things actually work with WPF it’s so damn smooth I can’t help but feel somewhat accomplished. Nevertheless, I had a real pain trying to get an embedded flash player into my WPF app. Why Flash? Why not…dare I say, Silverlight? Well, I’m building a small app that plays YouTube videos, so obviously Flash makes sense. First, here’s some lessons I learned while on this wonderfully frustrating journey:

For this instance, the WebBrowser control blows.: My first attempt was to add an embed tag into a WebBrowser control, which is put inside of a WindowsFormsHost control, which is how .NET encapsulates pre-3.0 controls. This did not work in the long run because first of all, IE throws script errors when you try to play YouTube’s .SWF files, and also when resizing the background flashes and looks like utter garbage. Don’t get me wrong, it has its uses. Just not here.
Pre-packaged solutions also suck.: There’s a few flash solutions out there that I tried, either got working and had to pay ridiculous amounts for (oh look, $1000 off this month!), or plainly didn’t work at all. Just don’t use them.
Google is your only hope.: Basically any problem I’d come across I’d have to google immediately, and answers were sparse. The solution I finally ended up with was embedded ActiveX objects, which I also had a lot of trouble with, hence this blog post.

So, here’s an overview of what I did, and how you can get it working. A small note, I’m targeting .NET 3.0.

Reference Interop.ShockwaveFlashObjects and AxInterop.ShockwaveFlashObjects in your project. The latter assembly may only be the necessary one, but back in the 2.0 world the forms designer added both. These DLLs will be included in the download project, but you can usually find them in the COM tab of the Add Reference dialog.
For whatever UserControl or Window you want to show this on, set up a WindowsFormsHost object as well as a AxShockwaveFlash object. (Make sure to include a using AxShockwaveFlashObjects; as well)
In the Loaded event for your UserControl/Window, NOT the constructor, set up these objects and set the Child property of the WindowsFormsHost to the AxShockwaveFlash object you made. If you don’t do it in this order, or do this in the constructor, ActiveX gets quite angry at you.
Make sure to add the WindowsFormsHost to the UserControl/Window…this is one of those gotchas that can save you some time.
Now you can set the Movie property of the flash player, and call Play() and it should work fine. If not, leave a comment and I’ll help you out.

Here’s an example project for you to get started with:

I’m afraid of low level programming.

2007-11-27T00:00:00-08:00

It’s running right now. Beneath those fancy windows. Under the hood. Shifting bits. Moving words in memory. And its scares the crap out of me.

Why? It’s a facet of human nature: what you don’t understand, you’re afraid of. But what can a novice programmer do about it? One of the main reasons I chose software engineering as a major is because I don’t want to have to think about the lowest level of computing power if I didn’t need to. I want to solve problems, help the company I’m at succeed, and enhance my knowledge of the craft.

However, I’m starting to learn that I may need to return to the ‘roots’ of programming. I’m taking a computer graphics course this semester, and it will be the most C/C++ programming that I’ve done in a while. Now grant it, I have had other classes where we did assembly and C, but not the entire course. It just seems to me that in order to really solve a problem efficiently, you should understand some of the underpinnings and inner workings of what you are programming.

So, what’s my solution to this? Well, for now, tinker around with C++ and maybe even poke around the Managed C++ Quake port. Being in the Kingdom of Nouns ruled by Java and .NET is nice though, and it really does let you focus on the problem at hand. Sometimes though, I wonder if escaping from those magical places allows the programmer to really dive into the task at hand and nail it down. I don’t even want to get into some of those esoteric languages that I happen to see way too much about.

One day I’ll get around to reading K & R or CIL Under the Hood, but until then…Are there any other ways to dispel this fear? Let me know what you’ve done to get over it.

Digg Labs: Flash doesn’t suck all the time.

2007-10-31T00:00:00-07:00

Don’t get me wrong. I’m not an expert on Flash. I haven’t even made anything special in flash. Yeah, I can tween a circle and bounce it around the stage, and that’s the extent of my Flash knowledge. One thing I do know about it: if you want to drive traffic from Google searches, you’re better off not using it. Some bloggers even claim its use to be evil. Now I’m sure there’s a lot of Adobe fans are ready and willing to tear me a new one by now with arguments about how Flex and AIR will change the face of the interweb, but it’s my opinion and always will be that your website’s MAIN content should NEVER be in Flash. Let’s look at the letters you type into that address bar of your browser at least once every day: HTTP. Hyper. Text. Not animations, or effects, but text. Until that protocol changes I doubt Flash will ever be used as a serious web design platform.

Once again, don’t get me wrong. Flash has its uses. In fact, it’s completely changed how we use the web. Newgrounds and YouTube immediately spring to mind, as they spawned entire communities and one could say even industries. Flash even has practical uses within sites, such as SWFUpload or various visualization tools that are used even inside of Google’s own pages.

The real magic of Flash is combining its content together with publicly available APIs and doing what Flash does best, even better than Java in some respects: being platform independent. Digg Labs is a perfect example of this, and their contests are a testament to the real future of Flash and its real use on the internet. Digg Labs is the perfect mash-up: content generated by users and displayed in a (semi) useful, interactive, and fun way. Now, you can even get them to be your screensaver on Windows or OSX. I tried for a long while to turn some of the Digg Labs .swf files into screensavers before, but it’s quite a nightmare without the right tools, and all the right data from the Digg servers.

What’s so special about Digg Labs creations is that unlike other visualizations of just raw data, be it traffic to your website or your network speed shown to you on a speedometer, you can actually interact with it. You can see the user who just dugg that story, and you can go check it out for yourself. Yes, it may be flooded with an overwhelming amount of Ron Paul stories at the moment, but at least it’s not the HD-DVD encryption key, or even worse.

Other websites out there really need to look into Flash for this purpose. This is a unique and fun way to engage your community while providing an actual useful way to access your site’s data. Be it Reddit, which I would literally love to see an exact clone of Digg Labs for (or even both together in one app…Blasphemy!), or Facebook, or any Web 2.0 site, they could really use some Flash visualization/interaction apps that can run on your desktop via a screensaver, Flash executable, or AIR. Imagine pictures from your friends on Facebook showing up in real time on your desktop or Del.icio.us links pouring in under a certain tag in a nice animated fashion. All of the buzz about Google’s Open Social and bringing out more APIs into the public for use makes this the perfect environment for more Flash goodness like Digg Labs to happen.

So yeah, Flash doesn’t suck all the time. Its niche on the internet continues to expand, but some part of me hopes I’ll never have to learn more than how to move that red circle around the stage.

Why every programmer should play NetHack

2007-10-29T00:00:00-07:00

I have a place in my heart for an obscure text based game called NetHack. This game is an archetype roguelike game, and I’ve been playing it for over a year now. Not a year in actual game time (yes, I used to play WoW, a lot), but I’ve been into NetHack seriously for the past 6 months or so, and it still kicks my ass. However, I’ve managed to ascend (beat the game) twice, and I can even play it on my Motorola Q.

How has such a game captured my attention for so long and directly apply towards my career as a software developer? Let me enlighten you as to why I think you should play it, and why it still matters so much.

NetHack is HARD.

No, this isn’t really a reason to play the game. However, it is a testament to how NOT to make your software. The amount of frustration I’ve had to go through in order to ascend has been utterly ridiculous. Hell, when I first started playing the game, I didn’t even know there was an ending. I just played because I like to explore. A classic idiom in web development is “Don’t Make Me Think!” I had to do completely the opposite in order to get anywhere in NetHack. One has to remember what monsters do, not to put on that piece of armor because it might be cursed, not to drink from that fountain because snakes might pour out and kill me, and so on and so forth. Well, perhaps under the thousands of lines of C that compose NetHack, someone didn’t think about that, but I for damn well sure am not going to make sure whoever uses my program won’t have to think twice about performing actions.

After 20+ years of development, it still has a vibrant community of users.

This really should be the goal of any community online going forward, be it you’re creating a forum for users of your software to request features, or you’re making a wiki-based community, or any of the above. Where will your community be in 20 years? Will it have vibrant fan-made sites? Will it have a fleshed out wiki? How about a newsgroup? Or will it fizzle and be forgotten? The lesson here is that in order to make your community bloom you need to first plant the seeds. Dig in a bit and you’ll find that behind this game of ASCII characters and telnet terminals there lies a deep and invested group of users passionate about the game and willing to help others how to play. If it wasn’t for the community and the “spoilers” it offers, I’d probably still be wandering around the Dungeons of Doom aimlessly.

“The DevTeam thinks of everything.”

This is a classic motto of NetHack’s development team within the community. The level of complexity of the game is ridiculous. Allow me to elaborate on one specific monster, the cockatrice. This monster is one of the most feared in the game because it can turn you to stone. Ah, but here’s the rub: once slain, you can wield its corpse and stone foes. And this is where the DevTeam starts thinking. You picked it up with no gloves on? You turn to stone. Oops, you tripped down some stairs because you were carrying too much? Stoned. Hit the wrong key and now you’re eating it? Bam, stoned. The list goes on, and on and on. However, the point is clear: the people behind NetHack have really thought of every possible case, every possible scenario in the game, and there’s a consequence or action for it.

I tend to strive for this goal now when I’m coding. I’d be proud if my program was so robust, so tested, and so mature that it could be said that I thought of everything. And even then, that’s still a long shot, perhaps even impossible. In the short term, I find myself trying to think of every possible case that I can while I’m programming, and I hope someday I’ll be known to be able to really “think of everything.”

Not convinced yet? Check out these old articles from GameSpy about NetHack. And if you’ve played NetHack (and/or if you’re a coder), leave a comment and let me know what you think about how NetHack relates to your other 9 to 5 job. And for those of you concerned, there are several GUI versions of the game in the case that you’d rather look at pretty pictures instead of characters.