There have been some interesting discussions recently on Twitter about IronRuby and Rails.  The IronRuby team has been plodding along and with IronRuby 1.0 RC2 out I wanted to see if it could truly run a Rails application.

In case anyone does not know what IronRuby is, it is a project from Microsoft to bring Ruby into the .NET platform.

Installing IronRuby

Installation of IronRuby is pretty straightforward using the MSI installer from Microsoft available on Codeplex.  The installation is just like any Windows installer, follow the prompts and when complete IronRuby binaries should be in your path, something like C:\Program Files\IronRuby 0.9.4.0\bin.  Notice the version, 0.9.4, odd for a 1.0 RC2.  The installation says the same:

I installed IronRuby and looking at the directory of the IronRuby binaries, I see all commands are preceded by an ‘i’.  So for those familiar with Ruby-related commands we get igem, irake, iirb and etc, not a big deal but something that needs to be remembered.  There is not a Ruby.exe either, but rather an ir.exe which we use to execute commands.  Also note that RubyGems comes bundled with IronRuby, no need to install this ourselves, which is nice.

Installing Rails

Installing Rails is not hard but make sure IronRuby is in your path and install with the following command:

igem install rails

This installs all dependencies and documentation.  It is interesting to note that we aren’t left with the normal (if you are familiar with Rails on OS X or Linux) rails command but rather irails.  In order to find the installed Rails version we type:

irails –v

We should see Rails 2.3.5 as a result.  I find it interesting Microsoft trying to create a Ruby which developers want to use, yet deviate the way command are run.  Maybe it will change in the official release.

Creating a Rails Application

Creating a Rails application under IronRuby is pretty much the same as on any platform with the exception of the ‘i’ in front of the command.  I decided to just create a throwaway application called ‘testapp’, just to prove Rails worked.   The command:

irails testapp

Runs and throws up a bunch of files created.  No magic here, but found some interesting things when trying to run the application.

Running the Rails Application

The default database these days used by Rails 2.3.x is SQLite3 and use this most of the time when building applications since it just works and I don’t need to deal with MySQL or PostgreSQL.

I grabbed the latest sqlite3 binary and DLL’s from the SQLite web site where you can download precompiled binaries for Windows.  I put the contents of the two zip files in the IronRuby bin directory.  Any location in your path should work.

Normally we need to install a gem named ‘sqlite3-ruby’ which is our Ruby driver for the sqlite3 database.  Doing so under IronRuby results in a fine installation but a failure when accessing our development.sqlite3 database, creating in particular.  Running the command to create our development database:

irake db:create

Provides a nice error ‘no driver for sqlite3 found’.  Well, this is an interesting problem I was happy to not have to search very long to resolve.  It seems some has forked the original sqlite3-ruby project on GitHub and created sqlite3-ironruby.  A quick:

igem install sqlite3-ironruby

Does the trick by retrying the irake db:create command and we are in business.  Our last step to prove Rails works with IronRuby is running our WEBrick server from within our ‘testapp’ directory:

ir script/server

The server starts and loads up our little test application.  Those of use used to running Ruby on most platforms are used to just using script/server without the ‘ir’ in front of it or maybe using the ‘ruby’ command with it, ‘ir’ is your ‘ruby’ and you need to precede your commands with it to ensure you have the the right Ruby binary.

If all things go well, popping open a browser and putting http://localhost:3000 in your address bar should give you a running Rails application:

Granted, it doesn’t do anything but it is a start and proves it loads.  I created some models and controllers and the ir script/generate commands worked like a charm.  All commands seemed to run as fast as, if not faster, than those in MRI 1.8.6. 

IronRuby has come a long way and we may see some production Rails applications running in IIS7 before too long.

I mentioned my lofty goals for 2010 in a previous blog post.  One of the goals is moving some efforts from freelancing work to products which can happen in a couple of ways; either by developing products yourself or by acquisition.  Acquisition is how we are introducing the first product in our company.

Why Expens’d?

We welcome Expens'd as our first product.  Expens’d is an application for tracking expenses, which sounds a bit boring but is a task many salespeople, consultants, freelances and just about anyone in business needs to do.  I personally think so many applications which are accounting systems also track expenses but do it in a way which is cumbersome and ordinary, we want to change this.

In the weeks and month ahead we will be introducing many new features to the application and changing some that already exist.  Thanks to our users feedback we have some clear guidance on what they want to see and plenty we want to explore.

Why Acquisition?

I have had the idea of a carefully crafted expense tracking application on my mind for a very long time but failed to set aside the time to pursue it.  When I found out Robert Dempsey of Atlantic Dominion Solutions was going to shutter Expens’d due to other interests, I jumped on the chance.  Expens’d had a great start with a good feature-set and knowing Robert, had a great code base.  This would get me part of the way there.

This is a huge advantage when building from scratch wasn’t really an option due to some time constraints.

The Future

I see many great things that can be done in this market.  Things that can make the task of data entry much more streamlined that can be extended to other applications.

Readers can follow what is happening with Expens’d on my company blog which will be updated as new features come out.  Thank you and stay tuned.

It has certainly been a while since I published anything on InfoQ but I had the opportunity recently to talk about Scout with Andre Lewis, the co-founder of the company.  The interview titled Scout – Extensible Server and Application Monitoring went up this morning.

I have had the opportunity to use Scout and witness the power of the application.   One of the most impressive aspects I see is the plugin system.  Scout offers a bunch of plugins, all open source.  Developers can also freely develop their own plugins for their own purposes and are welcome to contribute them as open source.  An all around win.

Please go give it a read.

The Ruby on Rails 3 beta was released recently and has been in development for the past year, longer if you take into account Merb.

I decided I wanted to start playing around with the release for a few reasons:

• In order to see what issues developers may face moving to Rails 3 with existing applications.
• I wanted to see the new architecture changes from Rails 2.x
• I also wanted to see first-hand creating a simple application and all that is involved.

There are plenty of tutorials about how to setup Rails 3 and I won't go into details here but wanted to share the method I used and one particular error I received and how I resolved it. Jeremy McAnally has some great coverage of using Rails 3, both new projects and upgrades. His rails_upgrade gem is a great place to start when beginning to look at moving an existing Rails project to Rails 3.

Setup

I decided to use the awesome Ruby Version Manager (RVM) to manage testing Rails 3 on different flavors of Ruby. The first thing to know is Rails 3 requires Ruby 1.8.7 and above, so no 1.8.6.

Ryan Bates has a great intro to setting up Rails 3 with RVM in his latest Railscast titled Rails 3 Beta and RVM.

I decided to use Ruby 1.8.7 for initial testing. There are a bunch of gem dependencies when working with Rails 3, as you might expect. There is a gem called rails3b which installs the necessary dependencies in one swoop. These two command should do the trick:

gem install rails3b
gem install arel --pre

After these commands finished and I closed and reopened my terminal prompt, a quick rails command gave me the following error:

/usr/local/lib/ruby/site_ruby/1.8/rubygems.rb:827:in `report_activate_error': Could not find RubyGem rails (>= 0) (Gem::LoadError)
from /usr/local/lib/ruby/site_ruby/1.8/rubygems.rb:261:in `activate'
from /usr/local/lib/ruby/site_ruby/1.8/rubygems.rb:68:in `gem'
from /usr/local/bin/rails:18

Some Googling did not return any usable results from anyone with this error. I really didn't expect anything, things are just too new. Thinking back to another way to install Rails 3, I decided to try this instead:

gem install tzinfo builder memcache-client rack rack-test rack-mount erubis mail text-format thor bundler i18n
gem install rails --pre

After running these two gem commands the new rails command works as expected. I'm not really clear what the difference was which fixed the rails command, but I don't know if I need to.

Do keep in mind the default database provider is Sqlite3 so you need to install that gem (sqlite3-ruby). Probably one of the biggest tips is to make sure you don't use sudo when installing gems under RVM managed Ruby installation, just use gem install <gem name>.

UPDATE: Jeremy McAnally points out the rails3b gem installs the dependencies for the Rails 3 beta, not Rails itself.  This would certainly explain why my initial attempt failed and only worked after INSTALLING RAILS.

If you are a web developer, you know the pain that is Internet Explorer 6. You know how hard and tedious it is to add support for IE6 to your web application and maintain it once released.

All of the recent browser improvements to Chrome, Safari and Firefox give developers the opportunity to create very rich browser-based applications leveraging HTML5 and JavaScript. The recent announcement from Apple that the new iPad will not support Adobe Flash say a lot, HTML5 is the future.

When the major browser developers standardize on these technologies, our jobs as web developers will begin to get a bit easier. I received an email from Google recently which reflects their stance:

Dear Google Apps admin,​

In order to continue to improve our products and deliver more sophisticated features and performance, we are harnessing some of the latest improvements in web browser technology. This includes faster JavaScript processing and new standards like HTML5. As a result, over the course of 2010, we will be phasing out support for Microsoft Internet Explorer 6.0 as well as other older browsers that are not supported by their own manufacturers.

We plan to begin phasing out support of these older browsers on the Google Docs suite and the Google Sites editor on March 1, 2010. After that point, certain functionality within these applications may have higher latency and may not work correctly in these older browsers. Later in 2010, we will start to phase out support for these browsers for Google Mail and Google Calendar.

Google Apps will continue to support Internet Explorer 7.0 and above, Firefox 3.0 and above, Google Chrome 4.0 and above, and Safari 3.0 and above.

Starting this week, users on these older browsers will see a message in Google Docs and the Google Sites editor explaining this change and asking them to upgrade their browser. We will also alert you again closer to March 1 to remind you of this change.

In 2009, the Google Apps team delivered more than 100 improvements to enhance your product experience. We are aiming to beat that in 2010 and continue to deliver the best and most innovative collaboration products for businesses.

Thank you for your continued support!

Sincerely,

The Google Apps team

This announcement is actually huge, in my opinion, because IE6 is the single browser that haunts web developers daily. Once IE6 is gone we can settle down and forget it once and for all. Google has a nice advantage here, so many people use Gmail, Google Docs and other Google Apps everyday that they will be force to upgrade to a modern version of IE or switch to a different browser altogether, great for us.

The news here seems to finger IE6 but it also notes removal of support for other older browsers too. Good times ahead.

2009 was a very interesting year, a year of some realization and a year which helped lay the foundation for the year ahead and hopefully the future.

I decided to document here a bit of what I have on my mind for 2010, not New Years Resolutions, I hate those and never do them. I have gained a fair following of loyal readers over the years and think of you as family, so I thought I would share with my blog family.

Freelancing

As I said in my previous post, I have been freelancing for many years and in 2009 I realized the ability and desire to continue with freelancing as a full-time endeavor was difficult. I will not be pursuing freelancing full-time in 2010 and as the year progresses I see the time spent freelancing to be less and less.

I will continue to work with selected clients as I have a vested interest in their success. In time I imagine their need for my services will be less and less.

I will be open for consulting opportunities with the possibility of part-ownership in a product and/ or for projects that need help figuring out difficult problems in areas I have expertise in but not limited to .NET to Rails migrations as well as scalable ecommerce systems.

Products

Even before I was in college I have always wanted to have an idea for a product, develop it, successfully market it and support it. I have been involved in a product company in the past but not my own individual ideas. I am sure this sounds self-serving, and it is, but there comes a time when we need to decide what is important and do it.

So, my goal is to primarily be a product company by the end of 2010. The company is Still River Software Company, LLC, which has been the umbrella I have been providing freelance services for the past 3.5 years.

Things are progressing nicely in a couple of exciting areas, so new product announcements will be coming soon. Very soon, but not just yet.

Blogging

I have not blogged a lot lately, been too busy with the business side of life. I will be blogging here, mainly about technology trends and my usual odd opinions about some aspects of technology and may begin to add some business writing as well which covers certain aspects of running a software company.

I will also be opening up a new blog for Still River Software which will discuss very company-specific information, including product releases and such. I will announce it here when it's ready, please check it out.

Conferences

I have not attended as many conferences as I hoped to in 2009, the ones I did attend were developer-related, mainly Ruby. In 2010 I intend to attend more conferences but probably more in line with running a business or software company more specifically. I hope to see you there.

So, I hope the ride is nice and I hope I can report back great success at the end of the year, I certainly expect it.

I stumbled upon an interesting essay by Zed Shaw recently titled "The Master, The Expert, The Programmer" pointed out by Avdi Grimm. One part that stuck out in my mind was this excerpt:

What I notice is that my peers are progressing to more and more complicated and convoluted designs. They are impressed with the flashiest APIs, the biggest buzzwords, and the most intricate of useless features. They are more than happy to write endless unit tests to test their endless refactoring all the while claiming that they follow XP’s “the simplest thing that works” mantra. I’ve actually seen a guy take a single class that did nothing more than encapsulate the addition of two strings, and somehow “refactor” it to be four classes and two interfaces. How is this improving things? How can more somehow equal simpler? This should never be the case.

These are the actions of an expert. These experts are very smart, capable, and skilled, but they are too busy impressing everyone to realize that their actions are only making things worse for themselves. In the end all of their impressive designs are doing nothing but making more work for themselves and everyone around them. It’s as if their work is only designed for getting them their next job, rather than keeping them in their current one.

I agree and have always thought the same. I have seen people turn something simple into something complex that will be difficult to maintain. One of my previous enterprise clients produced solution after solution which was so complex that adding a field to a form took a day with all of its levels of indirection.

So many programmers are like sheep, they follow the herd because they think they should and feel if they don't they will be left behind. In my opinion, developers should stand back from the crowd and be an individual and do those things that work for them.

Personally, I will do the simplest thing I can do to solve a problem within the constraints of the problem domain. This is my best interest because I can better maintain code later and it is the best interest of the client because it costs them less and more likely someone else can support it later.

Solutionist

I currently am working on a project that is filled with tests, some created in TDD fashion, some created after the fact. It seems to me, from someone coming in from the outside, that these tests were created for tests-sake and done for the right reasons. The tests are spread out across the project and are not complete and don't cover all of the necessary business rules. When I look at this it seems like it was a waste of the clients money. If we can't rely 100% on what the tests are actually testing, then why do them at all?

I am also working on a project with very little tests, almost none. This project works very well and shows almost no ill-effects of not having a test suite. I will not get into a holy TDD war, it's not my point. I'm just pointing out how two diverse projects from a test perspective can provide value.

I look at the work I have done over the years, some with full test suites and some without and realize what was done was done with a certain business situation in mind. We don't live in a perfect world business is not perfect, projects aren't perfect and neither are solutions.

We are solutionists and we do the best job we can from the experience we have garnered and what the client can afford. I think this is an important point here, we can't really bang our fist on the table demanding TDD from a client who may not have the budget.

I think we should be creating the simplest solutions we can to fit the needs, and budget of the client. If simple is a one form application, then do it. If simple is a 20 form application with full test suite, then do it. Simple is what gets the job done.

Well the past 12 months have gone by really fast, again. It seems I always tell myself this each New Year's Eve. So looking back on 2009:

Ruby on Rails Consulting

I have made many changes in the past year from a business standpoint, taking on more Ruby on Rails projects and less .NET projects. I think the decision to transition to more Rails projects has been a welcomed change from .NET if only to be doing something new. I have to say the quality of potential .NET projects is a lot higher than Rails, but I'm not sure why. I tend to think it might be because Rails tends to attract too many clients with little or no money, but this is just a guess based on observations.

iPhone Development

I signed up in the later part of 2008 for the iPhone Developer Program with the intention of putting my stake in the ground and implementing some ideas I had for mobile applications I thought would be good on the iPhone.

To say the least I was disappointed by the way Apple has been processing app store submissions and subsequent seemingly random rejections. It would take a lot for me to spend 3-6 months writing an app *hoping* Apple is kindhearted enough to accept it into their store for someone to possibly find. Not going to happen.

I may revisit the platform at a later time if the approval process changes because I think it is a great platform for developing apps, I am just not into playing the app store approval lottery.

Freelancing

I have been doing full-time freelancing for over three years now and 2009 really was a pinnacle of the realization how difficult it can be. The year started off very well but as summer came and things slowed down to a crawl but picked up again in the Fall. It was really a feast or famine time and it has made me realize just how hard it is to juggle the "feast" portion of freelancing.

It has made me realize how much consulting or freelancing does not scale. I can't work 80 hrs a week for any number of clients, the work suffers, health suffers and overall life suffers. A freelancer can only work so many hours at full-speed but when times are tough, it gets really tough.

Unless you can juggle getting work, doing the work and getting more work in a reasonable time frame, it can be tough.

Looking Ahead

I think this is one aspect I need to change in my approach for 2010. Things are already in the works but I won't go into detail right now, but expect news in the coming weeks.

I wish every one of my readers a happy and healthy new year and look forward to 2010.

Recently I ran into a problem on my MacBook Pro running Snow Leopard when trying to connect to a MySQL database.  The current version of the gem (2.8.1) installed fine but when trying to use it, I received the following error:

uninitialized constant MysqlCompat::MysqlRes

When trying to spin up a Rails application on my Mac.  I am running Snow Leopard and already had the MySQL gem installed.  A bit of searching around the web led to some information that this is an issue to do with the MySQL driver, in particular mysql-2.8.1.  The explanation came from a thread on StackOverflow.com:

As it turns out, that class should not exist; the error message is caused by a problem with the latest Mysql driver. mysql-2.8.1 looked for my libraries in a directory named with an extra level of 'mysql' at the end. For instance, my libraries (under MacOS X 10.5.8), are in /usr/local/mysql/lib, but the mysql.bundle library looks for the MySQL libraries at /usr/local/mysql/lib/mysql ... which is wrong.

I tried some of the suggestions in the thread which suggested a straight install of the MySQL 2.7 gem but the result was the same.  It seems things are treated a bit differently on OS X 10.5.x and 10.6.x because of the 64-bit goodness we now have, but I was able to resolve the issue.  The first step was to uninstall my current MySQL gem:

sudo gem uninstall mysql

The command is a bit long but we basically want to install the version 2.7 of the MySQL gem and tell it where the MySQL main directory is located as well as where the configuration is located.  This command should be entered in a single line from a Terminal prompt (broken up here for display purposes):

export ARCHFLAGS="-arch i386 -arch x86_64" ;sudo gem install --no-rdoc --no-ri 
 -v=2.7 mysql -- --with-mysql-dir=/usr/local/mysql 
 --with-mysql-config=/usr/local/mysql/bin/mysql_config

Anyone who reads this blog knows I work with quite a bit of different technologies, some I love and some I just tolerate.  One of the technologies I love is Ruby on Rails, for many different reasons, but one huge reason is the way it allows the developer to interface with a database.   When I create a Ruby on Rails application with even a single migration, I have access to my database tables as objects in my application with very little work.

Now transition to the life of a .NET developer.  Someone given the task of creating a database application with the job of simply adding, updating and deleting records from a database is faced with many choices with very few offering the elegance of a tool like Ruby on Rails.

I was hired recently to create a new web application which required it to be written in ASPNET with C#.  This gave me the opportunity to look at all the key aspects of the application and the first to get stuck in my mind was data access.  Which tool to use on .NET?

I write both Ruby on Rails and ASP.NET applications and transitioning between the two is often difficult when faced with the plethora of ways to access data in .NET, most seem to be more complicated than necessary. 

Microsoft Data Access

Technologies created by Microsoft only seem to make it to market if they are complicated and cumbersome to use, these include:

ADO.NET – Using stored procedures for example.

LINQ to SQL – In my opinion, a real clumsy attempt to give a way to access almost anything by a query language implemented in C# or VB.NET.  You can see by example that no one should have to write these things all day:

var q =
   from c in db.Customers
   where c.City == "London"
   select c;
foreach (Customer c in q)
   Console.WriteLine(c.CompanyName);

Entity Framework – Oh please.  I have only given this technology a cursory look and just have to shake my head in disbelief that Microsoft would create such a mess of complexity, but they do complexity best.

Non-Microsoft Data Access

There is hope though for developers wanting something better.  Technologies like SubSonic and NHibernate offer very different solutions to Microsoft’s vision of how data access should be done.  Both of these are open source projects and have their strengths and weaknesses, and both have their own learning curve.  I have spent some time with SubSonic and it is good product with active development.  I can’t say I have done very much beyond the experimentation stage with NHibernate but I know many folks who love it.

I had been a bit oblivious to work being done with data access and object relational mapping (ORM) in the .NET space.  I came across one tool from Mindscape, a New Zealand based company, with an ORM tool called LightSpeed.  I was a little reluctant because of my assumed learning curve and could not have been more wrong.  This is a commercial product but Mindscape offers a free version that is full-powered but only allows for up to 8 database tables, which would be fine for smaller projects or to try it out.

After speaking with some other developers who have been using LightSpeed I decided it was the right tool for the job.

LightSpeed in Action

The project I had in mind was indeed a new project but I inherited an existing SQL Server 2005 database full of tables.  This application will consume many of the existing tables read-only but we create new tables to store our application-specific data.

This is not a tutorial on how to use LightSpeed but how I am using the tool.  I am sure there are many ways to configure the tool to use the data most efficiently.  I am sure the purists will complain about doing model-driven design, but I don’t care.   I was looking for a tool to get up and running with the least effort, we will tweak later.

LightSpeed comes with a really nice designer which allowed me to pick and choose various tables I wanted to use in my application.  Notice how the designer picks up the existing relationships from the database:

Once the designer is saved it quickly creates some very clean C# to represent the schema in code.   A few entries in the web.config and everything is ready to write some code.  Mindscape has a nice Getting Started screencast which shows how easy it is to go from zero to code.  The screencast is just over 11 minutes long and is enough to get up and running.  

Setup Code

A bit of setup code in my application gives us access to our database and a place for our objects to interact with:

Once we have a Context property setup this will be the basis for all database access.  Notice it is created only once.

Retrieving Entities

All the code is very simple but does a lot.  We need an entity here for a certain ID and we are using the LightSpeed method of query, you could just as easily use LINQ queries.  I choose to stay away from them and use the cleaner method of retrieving an entity object.

Creating Entities

Passing in an instance of our entity, adding to what is referred to as a UnitOfWork and just calling SaveChanges does the job.

Deleting Entities

Deleting is as simple as adding, pass an instance of our entity and remove from the UnitOfWork and SaveChanges and the entity is gone.

Finally

This tool is really a pleasure to use.  I don’t know if I am partial to it because of my work with Ruby on Rails or just the beautiful simplicity, but it is worth a look.   Don’t get me wrong, it does not lack features but its features don’t get in your way.  I can tweak all I want, something the Rails community refers to as convention over configuration.

The amount of time to go from database to working application was cut probably almost in half.  No stored procedures were created in the making of this application.  This fact alone should be a good enough reason to move from traditional designs to using an ORM to avoid stored procedures and save some time.

Why should managing data from an application in .NET need to be such a task, which is one we repeat over and over.  Using LightSpeed has eased the pain to get an application done rapidly and is a welcomed tool to my toolbox when I need to get .NET work done.