It has been a month now since my iOS card game app based on Rook, Blackbird, has been approved in the App Store. It has been a blast! It is definitely the funnest project that I have worked on. I think that is mainly due to the fact that I did it all myself and the App Store is a big market. Well, I can’t really say that because I’ve had lots of input and help with testing from friends and family – mostly my dad who is a big Rook fan. I thought I’d just write up a quick post on some things I’ve learned, and throw in some app statistics.

Some things I have learned

I chose to write an iOS app simply because I have an iPhone and most of my family have iPhones.

I didn’t use a cross-platform developer tool like Titanium that would allow me to write code once and deploy to iOS and Android. This was a very hard decision for me, but I’m glad I went the XCode/Objective C route. Here are my reasons: (Whenever I say, “Titanium”, I really mean any project like it. They all work very similarly.)

• The Objective C language is really growing on me. It’s very different at first and has some concepts that are unlike any language that I’d learned before. But I really like it now. So I’m glad I took the time to learn.
• I have a computer playing AI that I want to be as fast as possible. Even though they translate the JavaScript into native code, I can write native code that performs faster for my specific tasks than Titanium can. I feel comfortable that when I need to work on performance, I can get every inch of performance possible.
• I have a problem feeling restricted to the currently implemented features. I worry about running into a situation where I want to use a feature that is supported by the platform, but not implemented by Titanium. This may be an irrational fear, but I still have it.
• I have recently talked to people who have worked on Titanium projects and they have told me that they both love it and hate it. They say that some bugs are really hard to track down because you’re not sure if the bug is in your code or theirs. They also say that you still end up writing a lot of platform-specific code. You also have to pay for their nicer versions and you have to write modules to support native iOS features that aren’t yet implemented by Titanium.

The up side of writing in a language I’m already familiar with (JavaScript) and deploying to multiple platforms at the same time just isn’t worth it to me.

When I released the app, it had relatively few features. I knew that there were several things that would be in high demand, but I released it without them anyways. I’m really glad I made that decision. The feedback has poured in and it has definitely steered me in a different direction that I would have taken on my own.

I haven’t done any marketing yet. I’ll be interested to see if I can get some app review sites to review my app and what effect that will have. I expect that a multi-player mode and a universal app will also have a big impact. So, I’m excited for the future!

Statistics

Here are several statistics so far:

Initially approved for sale in the App Store: Sept 29, 2012
Total downloads: 561
Updates approved: 3
App store rejections: 0
Most sessions in 1 day: 979
Median session length: 6.3 mins
Total time spent in app yesterday: 5 days 14 hours
iOS versions: 88.9% iOS 6.0, 10% iOS 5.1.1, 1% iOS 5.1 (my app requires iOS 5.1)
Users with a device that cannot upgrade to iOS 6: 1%
Countries of users: USA, Canada, Japan, Australia, Hong Kong, Kuwait

There isn’t any documentation on the ReactiveCocoa README on how to install it and there are many ways. I tried CocoaPods but it added and changed a whole bunch of stuff. It made me uncomfortable, and I’m the kind of person that likes to know exactly what’s going on, so I decided to do it on my own. I did it the same way the RACiOSDemo project was setup.

Create a Git submodule

Create a folder called external in the project’s root folder. Then, run this to add the submodule:

$ git submodule add https://github.com/github/ReactiveCocoa external/ReactiveCocoa
$ git add .gitmodules external/ReactiveCocoa
$ git commit -m "Add ReactiveCocoa as a submodule"

If you’re not familiar with submodules, submodules are simply a way of embedding a git repository inside another. If you’re still curious, I recommend reading the Git book’s chapter on submodules.

Now, anytime you clone your repository, you’ll also need to run these two commands to set up the submodule again:

$ git submodule init
$ git submodule update

Setup ReactiveCocoa correctly in your project

Next we need to get the project to appear and build inside our project. In your XCode project, right-click on the Frameworks folder and choose “Add Files to [project]…”. Navigate to external/ReactiveCocoa/ReactiveCocoaFramework and choose ReactiveCocoa.xcodeproj.

Now we need to setup the our project’s main target to link to the framework. Click on your project in the project explorer. Then, click on your main target and make sure you’re on the Summary tab. Scroll down to the “Linked Frameworks and Libraries” section. Click the plus and add libReactiveCocoa-iOS.a.

Apparently, for now, we also need to add a linker switch for it to compile the ReactiveCocoa stuff correctly. Go to the Build Settings tab now and scroll down to the “Linking” section. Find the “Other Linker Flags” setting and double-click in the field to the right. Add the -ObjC flag and the -all_load flags.

The last thing we need to do is tell XCode where to look for the framework and header files. Still in the Build Settings tab, scroll down to the “Search Paths” section. Find the “Framework Search Paths” and enter the value, “$(PROJECT_DIR)/external/ReactiveCocoa/ReactiveCocoaFramework”. Then put the same value in for the “Header Search Path”.

That’s it. Now, you can happily use Reactive Cocoa all you want!

Here are some links to the different parts of this post:

• Why use these technologies?
• The server
• PostgreSQL
• Nginx
• Unicorn
• Capistrano

Here are some resources I used to get everything setup the way I wanted:

• Setting up Unicorn with Nginx
• Setting up PostgreSQL on Ubuntu
• Lighting fast, zero-downtime deployments with git, capistrano, nginx and Unicorn

I took my approach from many different places and I’ll explain why I did what I did.

Update – I have since watched a few Railscasts that are very well done and explain most of the same concepts. There are several things that he recommends doing that I will definitely do. He is charging money to see those episodes ($9/month), so I would feel a little guilty posting what I learned here.

• Deploying To A VPS
• Nginx & Unicorn
• Capistrano Recipes

Why use these technologies?

Hosting

Originally, I wanted to host my website on Heroku. Heroku is easy, awesome, and really simple. One web dyno is free and it can scale really easily. For the foreseeable future, however, I will have very low traffic and I want it to be as cheap as possible.

My problem with Heroku came when I realized that I needed more than 5MB of database space. The next tier up gives me 20GB and costs $15/month. This is way more space than I need and costs a lot more than I want to pay.

So, I started looking at VPS hosting since I can get a cheap VPS and have more than 5MB of space for my database, plus I can use it to run jobs if I want, etc. I looked at the cheapest offered solutions at Linode, Dreamhhost, MediaTemple, Amazon, and Rackspace. Rackspace beats them all with 256MB of RAM and 10GB Disk for $11/month + $0.18/GB of bandwidth. I highly doubt that I’ll even use 1GB of bandwidth. Plus, if I do need to scale, it will be really easy to do it with Rackspace Cloud Servers.

Web Framework

Honestly, my main reason for doing my site in Rails is because I love Ruby and Rails is fun to work in.

Http Server

My reasons are better stated by others:

• Thin vs. Unicorn
• Unicorn!
• Mongrel vs. Passenger vs. Unicorn

Since this is for a low traffic site, I went on the word of others. If I was expecting a lot of traffic, I probably would have done more research and some of my own benchmarks. That said, I do feel pretty confident in this setup even though I didn’t do that. Let’s get started!

Justification

I am a Mormon.  No one is paid to do anything at my church.  So, we have to setup all the chairs for everyone every Sunday.  We have split into different groups so that we really only have to come setup chairs once every month.  I am in charge of reminding my group that it’s our turn.  These groups change pretty often with people moving in and out, so we keep the list of groups in a Google Spreadsheet.  I often forget that I need to remind everyone until it’s inconvenient for me.  I have often looked up the list in the Google spreadsheet on my phone and copied them, 5 at a time, into Google Voice to send texts.  It feels painful.

Solution

To make this easier for me, I decided to write a simple website that would read the data from the Google spreadsheet for me. Then, I could type type in my message and click “Send SMS” and be done.  I was able to do this in about 4 days in my spare time, but there are some caveats.  I’m going to give a brief tour of this tiny little site.  I’m not going to talk about any of the code, but it’s up on GitHub.  If you’re interested, I used Sinatra with Haml, the Google Spreadsheet API via the Google API Ruby client and Faraday, Moonshado SMS, MongoDB with Mongoid on MongoLab, the Twitter Bootstrap, and Heroku.  It was all free!!!  If you want my code, go here.

Short Tour

The home page is just a simple page with a random quote about time that changes every time you come to the page and a link to the contact page.  I’m guessing that I might add more tools like this in the future.

When you click on the “Contact the quroum” link it takes you to a Google page where it tells you that I’m asking for permission to use your spreadsheets.  If you give permission, it takes you to the only other page in the app, the contact page.  You can select from a bunch of preset groups of contacts or you can manually click on the names to add them or remove them from the list.  You can see who has an email or phone number in the spreadsheet with the icons next to each name.  Then, you type in your message and click the SMS button if you want it to send a text message.  Or, click the Email button if you want to send an email.  The site responds to your browser size too.  So, if you are on a mobile phone, it’s still pretty usable.  Pretty simple.  (I removed a bunch of names and changed the names in the screenshot below).

One caveat is that right now, I can only send 17 text message a month for free.  I have 19 people in my group.  Also, when it sends the text, it adds “Msg&data rates may apply txt STOP to opt-out.”  That’s kind of crappy.  Also, if I’m asking a question and they want to reply, their reply won’t make it to my phone.  So, I’m thinking of changing from using MoonShado SMS to Twilio.  With Twilio it won’t be free, but I’ll get everything that I want for about $1.17/month.  I’m still deciding if it’s worth it to me.  Either way it was a fun project and I’ll still use it!

SELECT "envelopes".*, COALESCE(SUM("transactions"."amount"), 0) AS total_amount
FROM "envelopes" LEFT OUTER JOIN "transactions" ON "envelopes"."id" = "transactions"."envelope_id"
WHERE "envelopes"."user_id" = 3
GROUP BY "envelopes"."id", "envelopes"."name", "envelopes"."user_id", "envelopes"."income", "envelopes"."unassigned", "envelopes"."parent_envelope_id", "envelopes"."expense", "envelopes"."created_at", "envelopes"."updated_at"
ORDER BY "envelopes"."name"

Don’t try to read that. It looks more complicated than it is because it’s long. In my application, users have envelopes and those envelopes have transactions and transactions have a cash amount. Basically, I’m getting all the envelopes owned by a user and the total amount for each envelope (a SUM of all the amounts of all the transactions in those envelopes). This query is definitely more complicated than the typical query, but as far as SQL goes, it’s still pretty simple. Here were my priorities for this:

• One query that gets the job done. Not more than one query.
• Use ActiveRecord to consume the query. I still wanted to work with Envelope objects even though I also wanted the total.
• No extensive use of strings because I use SQLite3 for development and Postgres for production. There are differences in syntax (quoting, etc.) that I don’t want to worry about.

My first attempt was just creating a SQL string to see if I could just use the find_by_sql method to get all the data back and still access the total.

sql = 'SELECT "envelopes".*, COALESCE(SUM("transactions"."amount"), 0) AS total_amount FROM "envelopes" LEFT OUTER JOIN "transactions" ON "envelopes"."id" = "transactions"."envelope_id" WHERE "envelopes"."user_id" = 3 GROUP BY "envelopes"."id", "envelopes"."name", "envelopes"."user_id", "envelopes"."income", "envelopes"."unassigned", "envelopes"."parent_envelope_id", "envelopes"."expense", "envelopes"."created_at", "envelopes"."updated_at" ORDER BY "envelopes"."name"'
envelopes = Envelope.find_by_sql(sql)

This worked great. It turns out that all the columns returned were accessible. For example, when I have an envelope populated with data from this query, I can just say envelope.total_amount to get the value and it doesn’t do any other queries even though total_amount isn’t a column in the envelopes table. To make this access even nicer, I added a method to my Envelope class.

def total_amount
  @total_amount ||= read_attribute(:total_amount) || transactions.sum(:amount)
end

read_attribute is what is called behind the scenes whenever you access your data. I call that since it won’t get to method_missing anymore when I try to access total_amount. If that value wasn’t provided in the query that populated this envelope object, then I get it by summing all the transactions’ amounts. Either way, I memoize the value in an instance variable. If the instance variable is set, it will return it’s value before doing anything else. Using a tip found on Jamis Buck’s blog was very helpful in testing this to make sure it was working. To see all the SQL queries that are run, you can just run ActiveRecord::Base.logger = Logger.new(STDOUT) in the Rails console.

This solution is nice because it solves the first two concerns I had. However, it isn’t very portable. The whole query is just a string. So I looked through the Rails documentation to see if it was possible to build this query just using the Active Record Query Interface. The things that I was having a hard time figuring out how to do was getting all of the envelopes columns while summing the transactions as well as getting an outer join in the query. If there aren’t any transactions, I still want the envelope to return (inner join doesn’t work). I could get it to do an outer join if I used the includes method and I put something in the where that required the included table. Anyways… I decided to just build the SQL string using ARel and just plop it into the find_by_sql method. After a lot of digging through ARel documentation and looking through the source code, I finally found a way to do it. Here it is:

et = Envelope.arel_table
tt = Transaction.arel_table

envelopes_columns = Envelope.column_names.map {|column_name| et[column_name.to_sym] }
    
sum_function = Arel::Nodes::NamedFunction.new('SUM', [tt[:amount]])
aggregation = Arel::Nodes::NamedFunction.new('COALESCE', [sum_function, 0], 'total_amount')

sql = et.project(et[Arel.star], aggregation)
        .join(tt, Arel::Nodes::OuterJoin).on(et[:id].eq(tt[:envelope_id]))
        .where(et[:user_id].eq(user_id))
        .group(*envelopes_columns)
        .order(et[:name]).to_sql

Envelope.find_by_sql(sql)

There are a couple of tricks that I learned worth mentioning. The first one that appears in the code above is that you can get ARel to do any function supported in databases even if ARel doesn’t natively understand it. Just use the NamedFunction class and pass in all the arguments for that function as an array. The 3rd argument is an optional alias. Even though SUM() is natively supported, I had to add it this way because it puts an alias in the wrong spot if I used the native way since I want the SUM() inside the COALESCE(). I want the COALESCE() because if it returns null, then I’ll do another database query in my total_amount function.

The next trick is that you can do et[Arel.star] to generate "Envelopes".*. This is nice because the Envelopes table is quoted in the database-specific way (for sqlite here) and the splat is not quoted.

The last thing that if you want to use an outer join, just pass in the join class you want to use as a second parameter to the join method… easy!

That’s it. This worked. (If you’re wondering about the *envelopes_columns part, you need to go through Try Ruby).

This actually met all of my initial priorities, but something didn’t sit right with me. I didn’t like how this query was not chainable like all of the other ActiveRecord queries. I can’t use any of my other scopes with it. So, I went back to the ActiveRecord Query Interface and this time, I dug into the documentation more and looked through some Rails code. I found a way to make it all work using a combination of ActiveRecord and ARel.

et = Envelope.arel_table
tt = Transaction.arel_table
    
envelopes_columns = Envelope.column_names.map {|column_name| et[column_name.to_sym] }
    
sum_function = Arel::Nodes::NamedFunction.new('SUM', [tt[:amount]])
aggregation = Arel::Nodes::NamedFunction.new('COALESCE', [sum_function, 0], 'total_amount')
    
select([et[Arel.star], aggregation])
  .joins(Arel::Nodes::OuterJoin.new(tt, Arel::Nodes::On.new(et[:id].eq(tt[:envelope_id]))))
  .group(envelopes_columns)

I’m not going to explain all of this, but it’s pretty cool that all of the ActiveRecord methods take ARel as parameters. Notice that the where clause is missing from this. That’s because I moved it out into its own scope that I can chain on when I want. This also now uses my default scope which just specifies the order.

I think that this is great because it works with all my scopes and it’s chainable and everything. I hope that this can be of some use to someone other than me. I learned a lot while trying to do this and I’m actually pretty surprised that it is all possible. I was half expecting to just have to use my string SQL query and leave it at that.

Probably the biggest surprise for me was that I expected for all of the sessions to be centered around Ruby and for everyone to discourage all other languages, but they weren’t and they didn’t.  Here is a short list of things that I noticed:

• Ruby coders are not Ruby exclusive.
• Coding is actually called hacking.
• Ruby really is a community (so many things about what everyone considers “core” to Ruby were contributed by other people).
• Bioinformaticians exist.  I met one and he enjoys his job in Arizona!
• There are lots of Ruby on Rails jobs in Utah.
• Ruby development is largely Mac-centric with some linux.  Windows users are made fun of (light-heartedly).
• Everyone is nice and willing to help you and eager to learn (MINASWAN).
• IRC is a great way to ask/collaborate with other developers.
• There is a big community of Ruby developers in Utah at URUG that meet together monthly.
• Twitter is used way more than I thought.

I tried to keep that first list to things that were less techy.  Here is a list of more technical cool things that I learned:

• There are lots of well-developed Ruby interpreters (MRI, JRuby, Rubinius, MacRuby, Maglev).
• If you’re unhappy with your tools, you should write your own.
• Citrus is a great way to parse.
• I want to participate more in the community (ie. Rails Mentors or Ruby Summer of Code among other things if they do it again).
• I want to try Redis and MongoDB.
• You can create a website using GitHub pages for free.
• There is a cool Ruby University that is free called Ruby Mendicant University.
• Learn 7 languages in 7 weeks.
• There are better ways to handle concurrency than just using threads (read more).

I also learned some quirky things about the guys in general.  They like:

• Minecraft
• sparkly unicorns
• beer
• random animal sounds
• sombreros

Overall, it was a really interesting, fun experience.  I’m glad I went.  I learned lots of interesting things and it changed my outlook on different languages and programming in general!

I left it for a while, but then I decided to see if I could contribute my solution to the Ruby on Rails source code. It was a fun process. I had to learn how to use Git a little more. I had to learn more about the way Rails works. But, I was finally able to submit a patch that was accepted and will be incorporated in version 3.0.2 of Rails.

Edit: It is now incorporated into Rails. You can see my change in the documentation here.

An Overview of What I Did

Here are the basic steps that I took:

1. Searched for existing tickets and conversations about the issue.
2. Researched and learned the way that the function was currently working.
3. Planned out a solution based on research of how it should work.
4. Cloned the Rails repository and made my changes.
5. Created a patch and attached it to a ticket to be reviewed by the Rails team.
6. Implemented feedback from the Rails ticket and submitted patches until it was accepted.

That is a lot of steps, but the actual process didn’t take very long. I started researching it and thinking about it on Friday, October 29 and it was accepted into Rails on Tuesday, November 2. So, that’s only 5 days and I wasn’t doing it all the time.

A Little More Detail

I thought I would describe in more detail what I did, so that you can do it too, if you want. First of all, I found out that different open source projects want you to contribute in different ways. Obviously, I’m going to describe the Rails way. They have an article (http://guides.rubyonrails.org/contributing_to_rails.html) on how to contribute to Rails that I looked at quite a bit.

Research Current Conditions

I did a lot of Google searches to see if others were seeing the same problem as me and if there was anyone that had already attempted to fix it. I did find a lot of people with their own little hacks to get it to work the way they wanted. I also found one person several years ago that submitted a patch to fix it, but it went stale and never got incorporated. It was a good way to learn what people wanted and to see suggestions on how it should work.

Learn And Research Rails

All of the Rails code is open source (duh, that’s why I can contribute). It’s all hosted on GitHub. So, I went to the code and started getting familiar with how the number_to_currency function worked. I found the file I needed to change fairly easily by looking at the documentation for the function. The path to the file was right there when I clicked view source. Finding the files where the tests were stored was a little more challenging, but not too hard.

Researched Best Solution

I knew that this was not a simple issue to resolve. Well, it was a simple issue to resolve, but not a simple issue to decide what the best resolution would be especially because of how much it can vary by locale. So, I looked at other languages to see what they did to determine how to format negative currencies. I looked at all of the people that I found had issues with it and how they wished it would work and I decided what I thought would be the best way to do it.

Fix It

Finally, it was time to get my hands dirty. I already had Git installed on my computer and I already had a GitHub account (it’s free). I went to the Rails repository on Git and I clicked “Fork.” This basically creates a copy of the repository under your name. I don’t know if I would do it this way again, though. In other open source projects, you fork and then when you’re done, you send a pull request. That’s not how Rails does it. With Rails, you just make your changes and submit a patch. So, it’s not necessary to create your own copy under your account.

Once, I had my forked copy, I cloned it onto my computer.

$ git clone git://github.com/dontangg/rails.git

As I’m sure you know, this basically puts a copy of the repository on my computer in a folder named rails. It also creates a link (called a remote in Git) to the origin on GitHub.

Since we need to make sure that what we have is always in sync with the actual rails repository, we have to add another remote.

$ git remote add upstream https://github.com/rails/rails.git

This creates another remote called upstream (call it what you want) to the main rails repository. Now, we can pull the source from the main repository to make sure we have the latest stuff (if we don’t I’d be surprised).

$ git pull upstream master

This pulls the code from upstream into our master branch in our local repository. Now, we can create a branch for our fix. We’ll call the branch currency-fix.

$ git checkout -b currency-fix

Now, I was ready to make my changes. Once the changes were made, I modified Rails tests to help prevent regression (breaking functionality later on). To run the tests, first I had to make sure that I had all the gems I needed. This is easy now with bundler. Make sure you have bundler.

$ gem install bundler

Then, to install all the needed gems:

$ bundle install --without db

Now, with all the prerequisites installed, I went to the actionpack/test/ directory in rails and ran this command:

$ ruby -I . template/number_helper_test.rb
Loaded suite template/number_helper_test
Started
....................
Finished in 0.459888 seconds.

20 tests, 212 assertions, 0 failures, 0 errors, 0 skips

Sweet, all the tests passed including the ones I added. We just need to make sure that we still have the latest rails stuff and then we’re ready to go! Let’s switch back to the master branch and get the code again. Then we’ll have to switch back to our branch and “rebase” our branch on the master.

$ git checkout master
Switched to branch 'master'
$ git pull upstream master
...
$ git checkout currency-fix
Switched to branch 'currency-fix'
$ git rebase master

Rebase basically rewinds our changes back to where we branched from master originally. Then, it applies changes made to the master branch and then it applies our changes again. This way our branch has the latest stuff from the master branch (that it got from the Rails repository).

Create A Patch And Create A Ticket

Creating a patch is pretty simple. Just run this:

$ git format-patch master --stdout > my_new_patch.diff

That creates a patch in the directory that you run the command. The Rails community like you to create a ticket in Lighthouse and describe the issue and attach your patch. You can see the ticket I created here.

Implement Feedback and Submit More Patches

I got some feedback and I had to make a couple more changes and resubmit patches a few times, but the process was always the same. I thought it was a lot of fun and kind of rewarding to see my changes actually get implemented into Rails. My name is now also on a list of 1,693 people that have contributed to Rails. That’s a lot of people, but I’m one of them. It was a fun little project for me. I enjoyed it a lot.

Managing your money is obviously a very important thing to do. Everyone comes up with a different way of doing it. I have asked lots of people how they do it and I don’t think that any one method is the best for everyone. Some people do it in Excel. Some use Quicken or Mint.com. Some have so much money, they don’t need to think about it. Others have even more money and they pay people to think about their money.

Behind all of these different ways to manage your money, there are two main philosophies behind them. You either create a budget at the beginning of the month and try to spend less than the money you’ve budgeted in each category. Or, you “cash” your paycheck and allocate your cash into different “envelopes” and when you go somewhere you only spend out of that cash that you allocated for that expenditure.

Why Use Envelopes?

Here again, everyone has a different preference. I prefer using envelopes. Here’s why I like it:

• You can always be confident that you’re not using money that you don’t have. When you use a traditional budget, you may budget $400 for the month for groceries. That doesn’t mean that you can go spend all $400 at the beginning of the month. You probably don’t have all the money you budget for the month at the beginning of the month. When you use envelopes, you are limited to the money you have in the envelope and you know how much you can spend.
• It makes it easier to make the once-in-a-while expenditures. Every year, we have to renew the registration on the car. Who knows how much it will be, but I know it happens every year. Without envelopes, I can budget to set aside a little money every month, but there is no simple way to set that money aside and know how much you’ve set aside. With envelopes, I put money in that envelope every month and I can completely forget about it until time comes to pay it. It’s nice not to panic or worry about having money for Christmas, or oil changes.
• Your bank account balance grows (which makes you happier and safer). We’ve been doing this for a while now and every month, we have all the money that we’ll spend at the beginning of the month. For example, November just started and all the money that we need for November is already in our bank account. If something bad happened, we have savings, but on top of that we could already last at least a month.
• Financial communication is easier. If you are married and share funds with your spouse, you have to communicate what you’re spending to the other person. With envelopes, you still have to communicate, but you both know by just looking in the envelope how much you have left for that category of purchases.

The downside to this is obviously that you have to go to the bank to get cash every time you get paid and that you have to find a really safe place for your money in your house.

To solve this, there are some computer websites and programs that simulate the act of putting money into envelopes. All of your money stays in your bank and the website just manages what envelopes it is all split into. When you go to buy something, you just have to check how much is in the envelope and force yourself not to spend more.

The Ideal Setup

I have personally used mvelopes.com for a while now. I had a friend that got me to sign up during a promotion where I paid $60 for a year (a year usually costs $130). I like that it is online and I can access it anywhere and that it is an envelopes budgeting system. However, there is plenty that I don’t like. I don’t like the cost. I don’t like that it is all done in Flash. There are lots of features that I don’t use that confuse me every once in a while (how to handle credit card payments, for one). And there are more negative sides to it that I won’t talk about because I’m not really intending to review mvelopes.com. My point is that I don’t like what I’m using.

I have found other solutions (like You Need A Budget), but I haven’t found one that I want to stick with. My ideal setup would be like this:

• Online so that I can access it from my phone, work, or home without requiring any synchronization.
• Not in Flash or Java. Those technologies are great, but something like this can be done with HTML, CSS, and JavaScript and when something online can be done without Flash or Java, it should be.
• Very simple. I want my wife to feel completely comfortable and safe logging in to check balances of our envelopes. Mvelopes.com is too complicated. I know, I know… it’s not that complicated, but it needs to be more simple and it can be.
• Free. Obviously.
• Budget using envelopes. Mint.com is awesome except in this one category. I really like Mint.com, but I like to budget using envelopes even more.
• Generate monthly reports. Since we’re not actually using envelopes and spending with cash, it’s easy to make a mistake and overspend in an envelope. It’s nice to evaluate how we did at the end of every month.

Since I have not found anything that suits all those categories and envelopes budgeting websites are hard to come by, I have decided to write my own. Guess what language I’m using to write it in? If you know me, you probably already knew I was doing this. If you don’t know me, you can probably guess since my last few posts have revolved around it. Ruby on Rails!!! and I’m having a blast doing it. Our year of mvelopes.com will expire within the next couple of months, so I’m really hoping to have it done soon. I’ll let you know when I’m done and I’ll post some screenshots or something.

• Pause the code in the middle of execution (breakpoint)
• View the contents of variables (locals, watch, etc.)
• Run one line of code at a time (step over, step into, etc.)
• Run my own code while the program is paused

Just to be clear, this is not a tutorial on how to use the gem ruby-debug. This is also not a tutorial on how to use irb. There are a lot of great tools and methods out there for debugging, but this is just about how to use the built-in ruby debugger. I am also only going to talk about the basics of debugging in Ruby. The built-in debugger, does much more than what I will show you. Learn more here: http://www.ruby-doc.org/docs/ProgrammingRuby/html/trouble.html.

Here is the code I’m going to be working with:

# lottery_numbers.rb
def next_lottery_number(last_number)
  case last_number
  when nil
    4
  when 4
    8
  when 8
    15
  when 15
    16
  when 16
    23
  when 23
    42
  else
    nil
  end
end

current_number = 1
while current_number
  current_number = next_lottery_number(current_number)
  puts current_number
end

Basically, all that it should do is output the lottery ticket numbers that would make you win the lottery (4, 8, 15, 16, 23, 42). When I run the program nothing outputs. It doesn’t work and I can’t figure out why. So, we’ll debug it.

To start the debugger, we just type:

ruby -r debug lottery_numbers.rb

The -r option tells Ruby to require a library before it runs my program and I specified to require the debug library.

When I run that, it responds with this:

Debug.rb
Emacs support available.

lottery_numbers.rb:2:def next_lottery_number(last_number)
(rdb:1)

It shows the line that it is about to execute. Of course, it skipped the first line because it was a comment and we are now looking at line 2. Just to feel safe that we are where we think we are, lets run ‘list’ to see for sure. (Also, the commands I type all start with (rdb:#). Everything else is output by the debugger.)

(rdb:1) list
[-3, 6] in lottery_numbers.rb
   1  # 4 8 15 16 23 42
=> 2  def next_lottery_number(last_number)
   3    case last_number
   4    when nil
   5      4
   6    when 4

Yep, that’s where we are! Ok we’re not too interested in this line. This line is just going to define a method, let’s go to the “next” line.

(rdb:1) next
lottery_numbers.rb:21:current_number = 1

It skipped the entire method definition because it doesn’t execute anything inside the method until the method is called. So, now we are on the line that defines our variable. We are definitely interested in this. Let’s tell it to keep us updated on the contents of that variable by running the “display” command.

(rdb:1) display current_number
1: current_number =

Currently, our variable doesn’t have anything. That will change when we go to the next line (“n” is a shortcut for the next command).

(rdb:1) n
lottery_numbers.rb:22:while current_number
1: current_number = 1

Alright, now we can see that our current_number has the value of 1 in it. Everything is going the way we planned it. I’ll keep going to the next line until I see something suspicious.

(rdb:1) n
lottery_numbers.rb:23:  current_number = next_lottery_number(current_number)
1: current_number = 1
(rdb:1) n
lottery_numbers.rb:24:  puts current_number
1: current_number =

Uh oh! For some reason, current_number was set back to nothing before anything was output. We also learned that the next (n) command steps over methods. It didn’t take us into the next_lottery_number method. Let’s quit the debugger, and debug again. This time we’ll step into the method.

(rdb:1) q
Really quit? (y/n) y
$ ruby -r debug lottery_numbers.rb
Debug.rb
Emacs support available.

lottery_numbers.rb:2:def next_lottery_number(last_number)
(rdb:1) b 23
Set breakpoint 1 at lottery_numbers.rb:23
(rdb:1) c
Breakpoint 1, toplevel at lottery_numbers.rb:23
lottery_numbers.rb:23:  current_number = next_lottery_number(current_number)

Notice that this time, I set a breakpoint on line 23 (b 23) then I told the program to continue (c) until it hit that breakpoint. Now, we’re ready to step in with the step command (“s” is the shortcut).

(rdb:1) s
lottery_numbers.rb:3:  case last_number
(rdb:1) l
[-2, 7] in lottery_numbers.rb
   1  # 4 8 15 16 23 42
   2  def next_lottery_number(last_number)
=> 3    case last_number
   4    when nil
   5      4
   6    when 4
   7      8

Alright! We’re in the method now. Now we can follow it to see what went wrong.

(rdb:1) disp last_number
1: last_number = 1
(rdb:1) s
lottery_numbers.rb:24:  puts current_number
1: last_number =

Oh, I guess the way that I wrote it, we don’t really get to see much by stepping into the method. Let’s experiment. I’m going to quit the debugger, go back to line 23 and manually set current_number to 4 before it calls the method to get the next number.

(rdb:1) q
Really quit? (y/n) y
dons-macbook:Sites don$ ruby -r debug lottery_numbers.rb
Debug.rb
Emacs support available.

lottery_numbers.rb:2:def next_lottery_number(last_number)
(rdb:1) b 23
Set breakpoint 1 at lottery_numbers.rb:23
(rdb:1) c
Breakpoint 1, toplevel at lottery_numbers.rb:23
lottery_numbers.rb:23:  current_number = next_lottery_number(current_number)
(rdb:1) current_number = 4
4
(rdb:1) disp current_number
1: current_number = 4
(rdb:1) l
[18, 27] in lottery_numbers.rb
   18    end
   19  end
   20
   21  current_number = 1
   22  while current_number
=> 23    current_number = next_lottery_number(current_number)
   24    puts current_number
   25  end
(rdb:1) n
lottery_numbers.rb:24:  puts current_number
1: current_number = 8

To run my own line of code, all I had to do is type in the code that I wanted to run! That’s pretty easy, right? And look! When I started out as 4, it correctly set the next number to 8. Well, as you probably noticed, I originally thought that I would pass nil into the function the first time through. That changed when I got to the bottom and I realized that I couldn’t pass nil in if I wanted to use it in the while loop the way that I did. Then, I just forgot that it would affect the method that I wrote. Let’s make a small change to line 4 to check for the number 1 instead of nil.

def next_lottery_number(last_number)
  case last_number
  when 1
    4

$ ruby lottery_numbers.rb
4
8
15
16
23
42

Awesome! When we run the program now, it works!

This was a pretty basic example and it doesn’t show all the commands you can use with the built-in debugger. I hope it can be a quick helpful tutorial for people trying to debug their Ruby code.

This would actually be a fun way to debug: YouTube clip.

Binary Art

“When you don’t create things, you become defined by your tastes rather than ability. your tastes only narrow & exclude people. so create.”
_why the lucky stiff

I like this quote. One of the reasons the I like programming on the computer is because it is my way of being creative. What do you think of this quote?

It kind of reminds me of this quote from the movie Dead Poets Society:

“We don’t read and write poetry because it’s cute. We read and write poetry because we are members of the human race. And the human race is filled with passion. And medicine, law, business, engineering, these are noble pursuits and necessary to sustain life. But poetry, beauty, romance, love, these are what we stay alive for. To quote from Whitman, “O me! O life!… of the questions of these recurring; of the endless trains of the faithless… of cities filled with the foolish; what good amid these, O me, O life?” Answer. That you are here – that life exists, and identity; that the powerful play goes on and you may contribute a verse. That the powerful playgoes on and you may contribute a verse. What will your verse be?”
John Keating

I’d like to think that there are many ways that I have contributed a verse, but one of them is definitely through the web development and computer programming that I have done. For me, writing code is my way of being an artist and my art project consists of different layers of beauty:

• How nice and usable is it for the user?
• How well does it serve the needs of the user?
• How beautiful is the actual code? Is it efficient? Is it well documented? Does it look nice?

I can’t say that I’ve always had the time or been in the mood to do this well every time, but it important to me.

I’m going to try to quickly explain the languages that I have experience with what I like or don’t like about them. This isn’t going to be an in-depth analysis of them… just a little bit about them… the main reasons that I have.

My Experience With Different Languages

I started telling the computer what to do when I was 10 years old and I used HyperCard. It used a language called HyperTalk and it was based on a concept that a program consists of a stack of user interfaces. It was a good place to start for me. It is what got me excited about programming. It’s too bad they don’t make it anymore.

Then I found a book in my school library (in 6th grade I think) on BASIC with tutorials on how to create games. I learned the basics of subroutines/functions as well as command line input/output. I had a blast with that one, but beyond that book, I didn’t have much resource for learning more.We didn’t have the internet (even if we did, I don’t think that there would be much of a resource back then). Today, I definitely don’t like VB.Net very much. C# is much better. In VB, you have to put “Then” after your If statement among many other syntax vegetables.  Yuck!

Here is a little BASIC. Kind of nostalgic…

INPUT "What is your name: ", UserName$
PRINT "Hello "; UserName$
DO
  INPUT "How many stars do you want: ", NumStars
  Stars$ = STRING$(NumStars, "*")
  PRINT Stars$
  DO
    INPUT "Do you want more stars? ", Answer$
  LOOP UNTIL Answer$ <> ""
  Answer$ = LEFT$(Answer$, 1)
LOOP WHILE UCASE$(Answer$) = "Y"
PRINT "Goodbye "; UserName$

For my math classes in Junior High and High School I had a TI-85 and I created some games on my calculator. I don’t know the name of the language used on the calculator. Luckily, the calculator came with a great little book with descriptions on all the commands you could issue to the calculator. This was awesome because I was great at math and finished my assignments quickly which left plenty of time for more work on my calculator during class!

My dad noticed my interest in programming and he wanted to learn too. So, we went to the bookstore and bought a book on C that we read together and did the exercises together. I loved learning C more than any other language to that point.  It was the first language that I appreciated not only for what I could tell the computer to do with it, but also the way that it looked. To this day I like the wide range of ways that you can accomplish things. Programming in C/C++ feels like I’m breathing a cleaner air and that I have more freedom than any other language.

In High School, I had a computer science class and we learned both C++ and Pascal. I liked Pascal, but I loved C++.

Of course, when I went to college, almost all of the computer science classes were in Java. I really liked Java. Of all the other languages I had learned to that point, it reminded me most of C++. I know that’s weird, but think it was just because it’s object oriented. I don’t understand why, but I have this weird opinion of Java. I really enjoy programming in it, but I don’t enjoy using programs created with it. Maybe I should figure out why, but I don’t really care. In college, I also had classes on C++, Python, and Perl. Python and Perl were okay languages to use, but for some reason I found myself avoiding them rather than interested in them.

During college, but my job provided an opportunity to learn how to do web development. At first, I didn’t like it very much. It didn’t feel like programming to me. I kept doing it anyways, and I eventually learned to appreciate PHP and I learned to love JavaScript, HTML, and CSS. Today, I feel neutral about PHP, but I really like HTML, CSS, and JavaScript. It is so easy and fun to deliver a great experience to people on the web.

When I graduated, I got a job doing web development with ASP.NET using C#. I really like C# because it reminds me of C++.

And Then There Was Ruby

With all the web development that I’ve done, at some point, I stumbled across Ruby on Rails. It has taken me a little bit of writing, but that is actually the reason I wanted to write this post. I love Ruby and I love Rails! I still love C++, but I feel like Ruby gives me a lot of what I love about the beauty of code that I enjoy about C++. And, when you pair it with Rails, I get HTML, CSS, and JavaScript too.  Everything that I love.

A man named _why said, “To write Ruby code is to love… to feel passion.” I don’t know if I would use the same words, but I feel similarly. I really feel like I’m creating a work of art when I write Ruby code. It’s like I’m creating an awesome sculpture for the city square or painting the ceiling of a chapel. I know that may sound crazy or stupid. I may be exaggerating a little too, but it definitely is more for me than just getting to the end result.

If you want to try Ruby or learn more about Ruby on Rails, here’s where I would start:
Try Ruby: http://tryruby.org/ (this is a quick, fun, and easy way to try Ruby)
Railscasts: http://railscasts.com/
Rails for Zombies: http://railsforzombies.org/
Rails Guides: http://guides.rubyonrails.org/
Agile Development with Rails: http://pragprog.com/titles/rails3/agile-web-development-with-rails-third-edition