Prepping for this shit

I made sure I had the following tools before I started (this step is VERY important):

• Enough Coffee
• Get EVERYONE out of the house (Make sure your girlfriend or wife isn’t around. Porting Rails 2 to 3 may in some cases be bad for your relation ship due to shouting, cursing and/or throwing stuff at her)
• Headphones
• Good music — I prefer the following: DI.fm dubstep
• Porn (If that’s what keeps you calm! Hey I’m not saying I’m watching it .. but, you know, if that’s your thing go for it!)

My gems:

Before I started I checked my environment for gems and made sure they were working with rails 3 and moved them over to the new rails project in to the Gemfile. The project uses the following Gems (=> Replaced with):

• pluginaweek-state_machine
• validation_reflection => removed
• authlogic => devise
• searchlogic => meta_search
• compass => more/less
• haml => removed
• formtastic
• will_paginate
• inherited_resources
• responders
• has_scope
• hpricot => nokogiri
• gruff => removed
• rboss
• exception_notifier

Errors Problems (notes)

The problems I’ve run in to are none so far:

SASS to Less

This is an absolute pain, I swear. I haven’t been able to find a tool which can convert SASS to Less so I have to do everything by hand (If at this point you’re thinking, DUDE, you stupid fuck use XXXX for that or use XXX regexp for that. Then please do share!). I did came up with this Regexp which should make it a little bit easier if you’re using TextMate (or any other editor):

Find:

/^(\s*):?(\S*)([\s\S*]*)/i

And replace:

$1$2:$3;

All you have to do by hand is add de brackets around your classes and IDs

Active Record — Custom select

I have the following scope with a custom select:

scope :include_matches_count, lambda {
select("organizations.*, SUM(spider_webs.matches_found) AS spider_matches_found").
joins("LEFT JOIN orders ON organizations.id = orders.organization_id LEFT JOIN spider_webs on orders.id = spider_webs.webs_id AND spider_webs.webs_type = 'Order'").
where('(spider_webs.id = (SELECT id FROM spider_webs AS n WHERE n.webs_id = orders.id AND n.webs_type = "Order" ORDER BY n.id DESC LIMIT 1) OR 1 = 1) AND organizations.customer_id = ?', User.current.customer_id).		group('organizations.id')
}

If you would call this scope (say my model is called `MyObject`) MyObject.include_matches_count.empty? You’ll get the following error:

undefined method `zero?' for #

Hmm now that’s odd. Up on close inspection I noticed I had a very strange select in my console output:

SELECT COUNT(*) AS count_all, organizations.id AS organizations_id FROM `organizations` LEFT JOIN orders ON organizations.id = orders.organization_id LEFT JOIN spider_webs on orders.id = spider_webs.webs_id AND spider_webs.webs_type = 'Order' WHERE ((spider_webs.id = (SELECT id FROM spider_webs AS n WHERE n.webs_id = orders.id AND n.webs_type = "Order" ORDER BY n.id DESC LIMIT 1) OR 1 = 1) AND organizations.customer_id = 3) GROUP BY organizations.id

Huh? Where did my custom select go to? So I checked the rails code and it seems that if the object hasn’t been loaded before .empty? is called, Rails decides to just call count.zero? on the object. Ignoring your select and causing this error.

So if you have a custom select in a scope and you would like to check if the result is empty before displaying it make sure you call “.all” on it first:

MyObject.the_scope_with_a_custom_select.all.empty?

updating while I’m on the train.

In the past we had also tried to create our own concurrency implementation but these either-way failed or were just too specifically designed. If you wanted to do something else than the feature it was designed for; you would have to rewrite parts of the code. You may call this design error, but it was simply not the intention to create a flexible concurrency implementation.

So our search for a new concurrency Gem went on; we tried two and came to the conclusion we would have to write something our self. I was given the task to create a new Gem. A new concurrency (queueing) Gem which would have to be flexible, maintainable and would have to be not as specific as we have been in the past. Or in fact this concurrency Gem had to be able to do all sort of tasks. From sending out mails to importing users from a CSV file.

I’d tried delayed_jobs and liked their implementation very much. The one thing we all agreed at here at the office was we didn’t want to have a separate Rake task which would require to be run in order to do some sort of concurrency. We wanted to be able to have the task been done within the application with whatever concurrency we specified; be it Forking or Threading or a simple yield, it all had to be possible. So with delayed_job in mind I started to design the Gem and came up with the name Runner (obvious name!).

I took me two days to implement a very basic version of the Gem. The only thing it could do back then was fork a method in the background without the need of an additional Rake task. At the current time of writing it has the following features:

• Supports various implementations of Concurrency (forking, threading and yielding. But the last isn’t really concurrency)
• Developers using the Gem may add different kind of concurrency to gem by simply giving the concurrency class the Runner initializer
• It has the ability to queue tasks which means you more or less park the tasks for later.
• It may immediately run tasks in the background using the various concurrency methods.
• Threading tasks requires no changes to your current classes.
• Extending the backend (currently comes with ActiveRecord) only requires you to implement database specific code (scopes, etc.)

As you can see after only a couple of days of hard work it can already do quite some things for any tasks you would like to run in the background. But as you probably wonder how does it really work and what’s the catch. Well there really is no catch, you only either way create a new block which you would like to run in the background or you specify a method to be always run in the background or you may call a method on the “chainable” spawn method as you will see below in the example code.

Getting the gem

If you like to try the Gem in an existing or new Rails 3 project you could add Runner to your Gemfile like so:

gem 'runner', '0.1.4', :git => 'git://github.com/stygeo/runner.git' 

Or you could install it from the command line like:

gem install runner

The examples

Please note: the following class implementation of user will be used throughout the examples

# User.rb
class User
  def self.send_mass_mail
    # This tasks requires a lot of processing time
  end

  def say_hello
    puts "Hello"
  end

  def say_goodbye
    puts "Good bye"
  end
  handle_asynch :say_goodbye
end

You may immediately notice the handle_asynch class method. In short what this method does is it creates a new method on the class for the method you specify (in the case `say_goodbye`) which will handle all the background stuff. So if you’d do:

# example.rb
require 'user.rb'

u = User.new
u.say_goodbye

It will automatically run the method `say_goodbye` in the background in a separate process or thread. There are times you’d like to run a method in the background at all times, such as say_goodbye. But there are times you’d like to run a method depending on some condition (background or not). If this is the case you could use the method `spawn` which is usable on every class (it’s included in class Object). This is how you could use spawn:

# example.rb
u = User.new
u.spawn.say_hello

The spawn method uses a ProxyObject which creates a new PerformableMethod. PerformableMethod encapsulates your class (in this case `user`) and serializes the PerformableMethod with your class and the method you’d like to call. Once serialized it’s saved as a task in your database. Once it has been saved to the database it uses a TaskHandler which on its turn forks or threads a new process which deserialize your class’ as a PerformableMethod. PerformableMethod plays a key role in the method calling. Here’s what it holds:

• Your class
• The method to call (`say_hello`)

The TaskHandler calls `perform` on the deserialized object (which is a PerformableMethod) in order to run the method you specified for the class you wanted to serialize. In some pseudo code this would be: PerformableMethod (:class => user, :method => say_hello).perform { class.send(method) } This is how Runner runs the tasks in the background in a nice and convenient way.

If you’d like to “park” a task in the queue (meaning you don’t run it immediately) you could pass :queue as the :method to spawn:

u.spawn(:method => :queue).say_hello

or you could do

u.queue.say_hello

The method `queue` is just short-hand for spawn(:method => :queue). When you queue a call it gets parked in a Task which you may resume to run at a later time. For example imagine that you’d like to, after a user signs up, the user receives an instruction manual at night by email. You could queue each `mail` method and, at night, use a Rake tasks (which you could set up with cron to run at night) which handles all tasks that are currently queued.

Early I talked about the different concurrency methods you may use with Runner. Runner supports by defaults 2 real concurrency method and a way to yield. You may use a fork or threading as concurrency methods, but you’re free to improve up on it if you so wish (more on that later). To use other than the default method (defaults can be set in the Runner initializer) you could pass the :with option spawn:

# example.rb
u = User.new
u.spawn(:with => :thread).say_hello

The <code>:with => :thread</code> option forces the task to run as thread instead of the default.  If you created a new concurrency method and added it to Runner (see below) you could also use the :with to force your own concurrency. For example you created the concurrency class Fibers (ConcurrencyFibers, Concurrency prefix is required) you could pass :fibers to the :with options so it will use your ConcurrencyFibers class as concurrency handler. (Please note: This feature is not yet supported, you could however pass your newly created concurrency method as the default, which does work.)

So this is how Runner works and how you may use it. For more information about the Gem or if you have a feature request you could go see the Github page . If you’d like to know more about the Gem’s internals, check out the code from github:

git clone git://github.com/stygeo/runner.git

and start reading from the message.rb file. This is the entry point and holds the spawn method, from there on you could just follow the code.

It somehow saddens my heart to do it though, I mean I had some good times with Objective-c and a couple bads. I’ve honestly also lost a little interest in Objective-c. Yes, Objective-c. Not Apple development as a whole. I’m hoping it will be possible to get Ruby to the iPhone in the near future. So please for love of god Apple get Ruby to the iPhone, hot-cocoa is awesome!

Anywho, I hope some of you will stick around for Ruby’s sheer awesomeness!

Meta programming, who hasn’t heard of it these days? You see it everywhere, you perhaps do so your self without even knowing. But what exactly is this thing called Metaprogramming. In Ruby; it’s probably you best friend. And if it’s not, I’m pretty damn sure it will be! It’s hotter then your girlfriend or perhaps your boyfriend. Hell, it’s probably even hotter then your sister hottest girlfriend and that other girlfriend .. well you catch my drift! But in all seriousness it’s somewhat makes Ruby the awesome programming language as it is. But before we can actually use metaprogramming in language, you must understand the very basics of how Ruby works.

Metaprogramming in one sentence

Metaprogramming — Writing code that writes code.

Something which you have to understand about programming is that, mostly, or in some cases you try to make things a little easier for your self or perhaps others, no matter what language you program in. Take C for example; C is pretty close to machine code and thru machine code you try build abstract bridges from the silicon world to the more fluid word we inhabit. However the distance between those two world are rather large. But what if there were languages that were closer to application domain? Take Ruby for example, Ruby provides a much higher-level abstraction and lets you write code which is much closer to the target domain, which is why people consider higher-level languages. Who can blame them? Have you ever seen C code (I remember so well; I was so against high-level languages when I was doing C because it wasn’t cool enough)?

But when you metaprogram, you are no longer limited to the set of abstractions built to your programming language. Instead, you can create new abstractions that are integrated into the host language. In effect, you’re creating a new, domain-specific programming language — one that’s designed to let you express the concepts you need to solve your particular problem.

Programming Ruby 1.9 — The pragmatic Programmers’ Guide

Ruby actually makes metaprogramming rather easy. Most advanced Ruby programmers mostly use metaprogramming in order to simplify their code or more dynamic.

Meet the Classes and Objects

Ruby is mostly all about Classes and Objects. There are a lot of different kind of types: classes, objects, class objects, instance methods, class methods, singleton classes, and virtual classes. But actually, Ruby is just basic. It has only one single underlying class and object structure

A Ruby object is nothing simply nothing more than: a set of flags, instance variables, and an associated classes. A Ruby class is an object of class Class. It has a set of method definitions and a reference to a superclass, which is a class itself. That’s basically all there is to a Ruby class.

Me, self and I .. and Methods … and calling them, too

Something which you might not know about ruby is that it has the concept of current object. The current object in Ruby is a read-only variable and you’ve probably been using it a lot. The current object is referenced by self.

The current object is taking care of a couple things. First off it controls how Ruby calls methods. In Ruby, as you might know, all method calls are done on some object. The object is also called the receiver. Second; the current object also controls how Ruby finds instance variables. When you access a variable it’s looked up in the current object by Ruby.

For example, if you make a method calls such as puts “Hi there”, there’s no explicit receiver. In this case, Ruby looks for the method “puts” in the current object as the receiver. It goes to self’s class and looks up the method (“puts”). If it can’t find puts in self’s class it’s being looked up in the superclass and so on. But what happens is that if you specify an implicit receiver such as item.size the process is very similar as calling a method without an implicit receiver. The only change is — however a vital one — is that the current object is being changed, for the duration of the call. Before the method lookup self is set to the receiver by Ruby (the object which is being referenced by the method). Once the method returns self is set back to what it once was.

Here’s a simple program

class Test
  def variable_test
    @var = 100
    two
  end

  def two
    @var
  end
end

test = Test.new
test.variable_test

This produces:

100

On the first line we create a new class of Test, assigning the return value, a new instance of Class Test, to test. On the second line we call variable_test with an implicit receiver which is test. When method variable_test is invoked, Ruby sets the current object to test. Inside variable_test we create a new variable @var and assign 100 to the newly created variable. @var Is created on the current object, and since the current object wasn’t changed since it’s set to instance test it will be created on instance test. After assigning @var method two is called, and since it has no explicit receiver it’s invoked on the current object, which is still our instance of class Test.

So now you know how Ruby looks up methods and assigns new variables. In the next in the Metaprogramming series I’ll discuss Class definitions, Singletons and probably also Inheritance. I hope you enjoyed the first one, and hopefully it has helped you a little bit in understanding the strange world of Ruby and Metaprogramming!

Klass.spawn.my_method

Which forces “my_method” to be executed in the background.

Queue’ing methods

With Runner it’s also possible to queue calls which will be executed at a later given time. For example you would like to do some very CPU intensive, long running method to be executed daily at 12AM:

class User
def takes_long_time
2 + 2 # I 'm not kidding!
end
end

# somewhere in your code:
user = User.new
user.spawn(:method => :queue).takes_long_time # => The method is now queued and won't be run

# In a rake task witch is run by cron at night
runner = Runner::TaskSpawner.new
runner.start_handlers # => All queued tasks are now being forked and run asynch in the background

For more information and features about the Gem please go to the github repo.

== About Ruby 1.9.2

Ruby 1.9.2 is mostly compatible with 1.9.1, except the

following changes:

* Many new methods

* New socket API (IPv6 support)

* New encodings

* Random class that supports various random number generators

* Time is reimplemented. There is no longer the year 2038 problem.

* some regexp enhancements

* $: no longer includes the current directory.

* dl is reimplemented on top of libffi.

* new psych library that wraps libyaml. You can use the library instead

of syck.

So if you live in the Netherlands and happen to be somewhere near Hoofddorp, and you like .. no, absolutely love ruby then perhaps this might actually be a job for you! For more information you could look on our website and apply if you’re interested.

Sorry ’bout the Dutch

Ruby on Rails vacatures

Noxa is hard op zoek naar nieuwe programmeurs!

Ben je geïnteresseerd in 1 van deze vacatures, neem dan contact met ons op via het contactformulier.

Ruby on Rails programmeur

Vanaf jonge leeftijd altijd bezig geweest met programmeren? Toen knutselen met HTML/Javascript en nu je ouder bent op goed niveau programmeren met bijvoorbeeld C++ en Java? Dan kunnen wij jou een hele leuke dynamische baan aanbieden! Wij zijn namelijk op zoek naar een slimme collega die zich graag wil ontwikkelen in Ruby on Rails bij een jong bedrijf.

Voor de verbetering en aanpassing van onze applicaties voor onze projecten gebruiken wij Ruby en het Rails framework. Het gebruik van Ruby on Rails zorgt ervoor dat we productief zijn en dat we meer lol hebben in programmeren.

Samen met 5 collega-programmeurs (gemiddelde leeftijd 25) draag jij zorg voor een state of the art omgeving en adviseer jij het management over de inrichting van applicaties en de implementatie van nieuwe features. Op het gezellige en informele hoofdkantoor van ons zusterbedrijf StudentenWerk werken inmiddels meer dan 100 collega’s.

Arbeidsvoorwaarden

• Uitstekend marktconform salaris, van € 2000,- tot € 4000,- bruto per maand
• Goede secundaire arbeidsvoorwaarden binnen een snelgroeiende, jonge en informele organisatie

Entire job description

objectiveresource does it need rails?

This query got me interested in trying out Objective resource without rails, and technically it should be possible because ObjectiveResource just requires the fetched XML to be in a specific format. So what we can do is create a simple XML document in the same format as Rails out puts its XML. And while we’re at it, let’s create a simple webserver which outputs the XML (honestly I just don’t have Apache working here on my laptop and I seriously can’t be arsed to set it up, and its way too much fun to create a simple Ruby webserver.). So let’s get started!

The Webserver

require 'socket'
webserver = TCPServer.new('127.0.0.1', 7125)
while(session = webserver.accept)
	session.print "HTTP/1.1 200/OK\rContent-type:text/xml\r\n\r\n"
	session.print <<-XML
		<sessions>
			<session>
				<name>Jeffrey Wilcke</name>
				<password>secter</password>
				<email>someemail@gmail.com</email>
			</session>
		</sessions>
	XML

	session.close
end

Well ain’t that a pretty small web server? ;)

Now let us fire up XCode, create a new project and create the necessary files and classes (I’m not going to demonstrate how to set up your entire project, you should know how to do that your self) and don’t forget to create the sessions file/class

#import <Foundation/Foundation.h>
#import <ObjectiveResource/ObjectiveResource.h>

@interface Session : NSObject {
	NSString *sessionId;
	NSString *email;
        NSString *password;
}

@property (nonatomic, retain) NSString *userId;
@property (nonatomic, retain) NSString *email;
@property (nonatomic, retain) NSString *password
@end

Now implement that file, load up your project and if you did everything correctly your OS X/iPhone application should display your sessions.

So what did actually happen? Our tiny little server accepts any HTTP requests and outputs our session (the path doesn’t matter). So when our iPhone or OS X application does a request for the session resource the server response with our session’s XML and ObjectiveResource parse the XML just as if it came from rails.

That proves ObjectiveResource doesn’t need rails!

PS. I hope that the user that did the search query found this helpful! :)

RVM — Ruby Version Manager

Straight from the RVM Website:

RVM is a command line tool which allows us to easily install, manage and work with multiple ruby environments from interpreters to sets of gems. RVM itself is easy to install!

I couldn’t have explained it better my self. So let’s get started! In order to install RVM just download the gem
sudo gem install rvm

The gem it self allows you to run the installer script, which setup the RVM environment  for you. Run it with rvm-install (Do NOT sudo it, it installs locally in your home folder). Once the installer is done you’re ready to install ruby 1.9 and rails 3 :)

Before I’ll explain how to use RVM let’s install Ruby 1.9.2 and while it compiles you may keep on reading. So if you haven’t loaded your shell do it now and type rvm install 1.9.2 (at the time of writing 1.9.2 is the latest version Ruby). Now jump over to the RVM Basics page in order to understand more about RVM (I could copy and paste it here, but I’m sort of lazy and don’t wanna take credits for something I didn’t write)

Alright, so once you’ve read the basics about RVM let’s change our Ruby environment (if Ruby is done compiling and installing) with rvm use 1.9.2 or shorter rvm 1.9.2. Now in order to install Rails 3 we first need to install some deps because rails pre doesn’t do it for you:
gem install tzinfo builder memcache-client rack rack-test erubis mail text-format bundler thor i18n
gem install rails --pre

Note that you don’t install the gems with sudo simply because rvm has its own directory for this. It installs all your gems in its own .rvm directory in your home dir (~/.rvm/). Once the Rails 3 gems have been installed you’re ready to go. Run rails -v just to make sure, if it’s correctly shows you 3.0.0 RC2 you’re ready to create a new rails project with rails new <Project name>.

Enjoy rails 3 and ruby 1.9.2 :)

Rails 3 and Ruby 1.9.2 links

Upgrading to rails 3 part 1 and part 2 (Railscasts)
Rails 3.0 release notes (RoR Guide)
Changes in Ruby 1.9 (Eigenclass, Must read)

By forcing me in to the ruby world again I’ve come to realize the magical wonders of Ruby and Ruby on Rails again. And this is also where I’ve become lazy. Objective-C in all it’s awesomeness is still so much more complicated and requires so much more work in order to do something as`simple` as “a” + “b”.

I’ve been wanting to write about my `new` found love for Ruby for quite some time but I got put of by it somehow. To be honest however I don’t think this love is quite new. I think I had just lost my love for Ruby somewhere along the way, or perhaps I just came to accept the fact that ruby just is as how it goes with many good things in life. However my new-found love is definitely for Ruby 1.9(.2) and the latest and greatest Rails version (3.0.0 RC 2). So in that way, it’s new.

First I thought that perhaps I should create a new blog for Ruby specific things but then I thought, why? I’ve this blog and although the blog title is “Cocoa” why the fuck couldn’t I just use this for programming in general? Or to be more precise; Objective-C, Cocoa, Ruby and Ruby on Rails. Those 2 framework and programming languages I’ve come to love in the last 2 and a half-year (I’ve only been doing Obj-C for less than a year and Ruby for nearly 2 and a half) would go together, it’s ok for me to have more than one lover, wouldn’t you agree? So from this day forth, this blog will be used for everything programming related.

Oh and since I’m on the personal/emotional tour anyway; I’d like to thank the people that have put their faith in me (You know who you are!) and giving me the opportunity to actually learn something new. Trust seems, almost, impossible to earn these days.

Peace out my brother and sisters! And if you haven’t already check out Ruby 1.9 and Ruby on Rails 3 pre with RVM (more on that in the next post).