How do you feel during your daily Ruby programming workflow? Do you feel fun or productive? Either way, you’ve got to feel grateful!

After several years not doing any serious PHP programming, today I get curious.

Right now, PHP has evolved. PHP programmers are not “script kiddies” anymore, they’re professional programmers with quality MVC web frameworks.

Now it won’t be fair if I compared Ruby on Rails with PHP, as that’d be like comparing apples and oranges. So I have to pick some killer app written in PHP that competes directly with Rails, as long as it’s not WordPress or Drupal.

So I checked out Symfony, the most popular PHP web framework out there. I’ve never programmed Symfony, but I’ve heard a lot of good things about it.

After initial reading on the documentation, it seems the good things I’ve heard about it are true. The development model is very similar to Ruby on Rails. Scaffolds and plenty of helpers.

However, the syntax is unbearable. (at least for me!) Check out this tutorial example code:

// apps/frontend/modules/job/templates/showSuccess.php
<?php slot('title') ?>
 <?php echo sprintf('%s is looking for a %s', $job->getCompany(), $job->getPosition()) ?>
<?php end_slot(); ?>

slot() and end_slot() aren’t even a proper block construct. They’re just two separate functions made to look like they’re blocks.

Compare with how to do the same in Ruby on Rails:

# app/views/jobs/show_success.html.erb
<% content_for :title do %>
  <%= @job.company %> is looking for a <%= @job.position %>
<!-- or: <%= "#{@job.company} is looking for a #{@job.position}" %> -->
<% end %>

It might be a simple example, but that begs your gratefulness even more: Imagine coding a much more complex web application!

I certainly won’t blame it on Symfony. Its developers have done a great job releasing an excellent web framework using PHP language as its foundation.

However, the PHP programming language (at least in its current incarnation v5.x) while makes great things possible unfortunately make them greatly ugly at the same time. To be fair, it’s not hard to abuse Ruby if you want to get cryptic. But at least, Ruby programming language when used properly will yield beautiful and highly readable code like the above example.

What’s your take? Time to get opinionated, guys!

Image credits

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Just got a server hard drive crash

We should be back operational soon. In the mean time please bear with us. Thank you.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Recently I got a task which involves moving, or let’s say copying, an entire Subversion repository with history to another server. Problem is, I didn’t have access to the server itself, which means I couldn’t do a regular “svnadmin dump”.

SVK comes to the rescue!

To make it work, first of all you need to install SVK. In Ubuntu it goes like this:

sudo aptitude install svk

When you first run svk it’ll ask you to create a local depot, you can simply agree to its suggestion.

Now we mirror both of the Subversion repositories we’re trying to import and export from and to. Note that you need to create the destination repository first.

svk mirror //source http://svn.source.com/project1/
svk mirror //dest http://svn.dest.com/newproject/

A bit of niceness with this method instead of a regular svn dump/load procedure is that:

• you can import to a different folder/subfolder instead of the root folder
• you can do a partial export (subfolder of project repository)

Before doing the actual migration process, let’s sync these mirrors first:

svk sync //source
svk sync //dest

And then you’ll do the real thing. But we can simulate it first by using “–check-only”, kinda’ like when you simulate a DVD burning session before actually writing it.

svk smerge //source //dest --incremental --log --sync --verbatim --track-rename --baseless --check-only

There are several switches that I used above, feel free to use them only as needed:

• -I [--incremental]: apply each change individually
• -l [--log]: use logs of merged revisions as commit message
• -B [--baseless]: use the earliest revision as the merge point
• -s [--sync]: synchronize mirrored sources before update
• –verbatim: verbatim merge log without indents and header
• –track-rename: track changes made to renamed node
• -C [--check-only]: try operation but make no changes

After you’re ready, redo the above command without “–check-only”:

svk smerge //source //dest --incremental --log --sync --verbatim --track-rename --baseless

Simply wait several minutes–or possibly hours (or days!) if your project is sufficiently large–for SVK to do its job for you!

Are there disadvantages of using SVK to a “genuine” SVN dump/load? Sure, among them is that the original author names are lost.

Good luck!

Related articles and resources:

• HomePage – SVK Wiki
• An introduction to git-svn for Subversion/SVK users and deserters
• Distributed development with SVK
• An SVK primer | Tools | New Artisans LLC
• Make it happen: Using SVK for offline access to subversion
• jkraemer.net: Work offline with SVK and Subversion
• SVK – Mirror Subversion Repositories Locally and More at sablog.com

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

I’d like to express a warm notice that AdaRuby.com might be down intermittently as we’ll be having major rearrangement and server upgrades of our hosting facilities in the coming days.

The upside is, when it’s done (and oh YES it will be done!), I’ll be providing you interesting information on the stuff that we’re doing, especially our experience regarding the hosting services that we have been using all this time.

Looking forward to hearing you share your experience as well!

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Design Patterns in Ruby documents smart ways to resolve many problems that Ruby developers commonly encounter. Addison-Wesley Professional press has this exciting book, authored by Russ Olsen.

Russ Olsen has done a great job of selecting classic patterns and augmenting these with newer patterns that have special relevance for Ruby. Most design pattern books are based on C++ and Java. But Ruby is different—and the language’s unique qualities make design patterns easier to implement and use.

In this book, Russ Olsen demonstrates how to combine Ruby’s power and elegance with patterns, and write more sophisticated, effective software with far fewer lines of code.The book especially calls attention to Ruby features that simplify the use of patterns, including dynamic typing, code closures, and “mixins” for easier code reuse.

Design Patterns in Ruby also identifies innovative new patterns that have emerged from the Ruby community. These include ways to create custom objects with metaprogramming, as well as the ambitious Rails-based “Convention over Configuration” pattern, designed to help integrate entire applications and frameworks.

More resources:

• “Design Patterns in Ruby” at Amazon.com
• Review at barnesandnoble homepage

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

You know what, I really wanna learn this whole JavaEE-related thingy……

For some reason it’s unavoidable……. it’s bound to be touched by me……

You see, the trend is going RIA. MVC is going away. AJAX ain’t gonna compete. At least not fully. And will lose in many ways in respect to something like Adobe’s Flex. (Unfortunately there’s not much competitor better than Flex, and fortunately it’d probably be “standard” in the near future). Esp. with Flex going open source. Flex will need a backend, since it’s not a server-side product. There is Flex LiveCycle Data Services ES (what a name!!) by Adobe. There’s also BlazeDS open source. There’s also the excellent WebORB, which is free and open source for Rails and PHP. Oh yeah, it’s free for Rails!

Sure you can go with plain Rails, but it’s maybe too much work, when WebORB already does it for you.

This is wonderful, but it only gives you plain RPC. It’s traditional (legacy?) synchronous RPC camouflaged as “asynchronous”.

Real asynchronous power comes from Messaging. And the buzzword is now Comet. The latest Jetty already supports Comet technique, which can continuously “streams” asynchronous messages and data to (instead of being pulled) your client-side web UI… (that might just be a Flex app)

Simple messaging is fine, but the real power of messaging comes from features that had existed for a long time it’s actually legacy, such as publish/subcribe, message routing, and reliable delivery and timeouts. Fortunately, we have ActiveMQ, and yes we have activemessaging library for Ruby and Rails plugin.

Unfortunately messaging servers have different protocols. Although there are “universal” protocols like Stomp and AMQP (backed by RabbitMQ), you can also use an ESB like Mule or OpenESB or Apache ServiceMix if your component needs to talk to components with a different protocol. Oh yes they’re from the Java world.

Even as we’re embracing THE ActiveRecord, the Java community coming up with an also-cool solution called JPA, supported by all popular Java ORM tools such as Hibernate and TopLink; Microsoft strikes back with the invulnerable LINQ.

Yet we still have too many queued messages and database records to handle, we need to know how to make use of them. EDA comes to the rescue, like what Esper does. And of course BI and reporting tools such as JasperReports, Pentaho and Ruby’s Ruport.

We like REST’s simplicity over WS-* for enterprise-y SOA apps. Microformats is very nice with just a little Hpricot and Mofo goodness. And thanks to Mechanize or Scrubyt or openkapow and the good ole’ RSS, mashup is always getting easier. Let’s hope Atom’s APP really does take off as well. But sometimes we want more flexibility, we want BPM-powered workflow. No worries, we have JBoss’ jBPM. Our Ruby community also has OpenWFEru!

Everybody hates the login form, especially if it comes more often than we brush our teeth. We want SSO, be it CAS, OpenID, SAML, or plain LDAP (with OpenLDAP), we want it now.

And no, I haven’t forgotten Android, nor iPhone, nor Symbian, nor Windows Mobile. The mobile space is getting more, not less, fragmented. All because they know the market is growing. Everybody wants a pie. (me too!)

You’ve heard him. Not all startups are profitable. Especially not when we’re fighting with each other. The “enterprise”, and corporate, has money… (unfortunately not all of us do, no matter how much we [all] want it…)

Users are getting more demanding and demands are getting more complicated, so are the technologies. We probably should embrace these technologies and the people who work on them (whether paid or unpaid or voluntary or forced…!) more so than we criticize and demotivate each other.

Ruby is a great tool, and so is Java (JVM) and so is JRuby and its close mates like Groovy, Scala, Jython, and Rhino with ECMAScript 4 and E4X support. Some people are also starting to fall in love with Erlang.

Oh well… This isn’t a rant. It’s just a brain-dump from me. Hope somebody finds it useful. Good morning guys

UPDATE: Clarifications regarding WebORB and messaging protocols.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

There’s a common pattern for developing DSL (Domain Specific Language) in Ruby. It’s used in RSpec, the Statemachine Gem, and Unclebob’s Clean Code talk at RailsConf 2007. The name for this pattern is the DSL Block Pattern.

RSpec

describe "Bowling Game" do
    it "should score 0 on a gutter game" do
        game = Game.new
        20.times { game.roll(0) }
        game.score.should eql(0)
    end
end

Statemachine

sm = Statemachine.build do
trans :locked, :coin, :unlocked
trans :locked, :pass, :locked
trans :unlocked, :pass, :locked
trans :unlocked, :coin, :unlocked
end

Parser

parser = Args.expect do
    boolean "l"
    number "p"
    string "d"
end

You’ve got to write code for specific domain such as writing specifications (RSpec), defining a Statemachine, or defining command line arguments (Unclebob’s Clean Code talk). These domains have a contained and well defined terminology set. Often the cleanest, most elegant way to express this code is to create a DSL.

We can see that the Order object is doing all the work. It’s got the responsibility of interpreting the DSL, so let’s call it the Interpreter Object. The Module::order method simply creates an instance of Order and calls istance_eval on it. This causes the block to execute using the binding of the Order instance. All of the methods on Order will be accessible to the block.

For more information, read Ruby DSL Blocks article by Micah.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Robert Thau from Smartleaf proposes a cool idea for implementing DSL for use in Active Record permissions. It makes it easy for a lot of users to have access rights and very exciting at the same time…

This is the Tease….

class Order < ActiveRecord::Base

  access_control_keys ['id', 'owner_id', 'paid']

  require_privilege :place,
    :for_action => :create,
    :to_update_attribute => [:payment_authenticator, :paid]

  require_privilege :edit,      # LineItem also checks this for attr changes
    :to_associate_as  => ['LineItem#order'],
    :to_dissociate_as => ['LineItem#order'],
    :to_update_attribute => [ :shipping_address ]

  require_privilege :ship,       :to_update_attribute => :shipped

  ...

end

 

The implementation:

• Data model
• Checking privileges: does user x have privilege y on this order?
• Finding all orders where user x has privilege y
• Adding privilege checks in interesting places…
  • On events: create, update…
  • On attribute sets
  • For associations

It’s just Ruby! Class variables and class methods:

• All declared privileges (for choosers in the UI)
• Dual-keyed hash: reflected_privilege[type][key]
• … e.g., reflected_privilege[:read_attribute][attr]
• … e.g., reflected_privilege[:associate][assoc_key]
• Class helpers (permits_update_attr?, etc.) just read the hash, and do the appropriate check.

Read more on:

http://www.smartleaf.com/rst/perm_present/perm_present.html

No downloadable code (yet), but still cool

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Any Ruby on Rails programmer would have touched Active Record, probably in a very early phase. Active Record deals with everything that’s related to the database of your Ruby on Rails applications, and in many ways a bit more.

Apress recently launched Pro Active Record: Databases with Ruby on Rails, which I can honestly say, is the most exhaustive, if not the only, book about Active Record I’ve ever known to date.

The book starts with a little bit of a “wow” factor, especially true if you’re new to Ruby on Rails: demonstrating the ease of use of Active Record itself. No configuration needed! Seriously, that’s not the claim of the book but it’s fact of Active Record: all you need is your database credentials and name of the table you want to work with. Everything else is almost magical.

The next sections deal with installing and configuring Active Record. I have to say sometimes (based on my own experiences) it’s not that trivial, especially on Windows. The book guides you through installing drivers/adapters for common and less popular DBMSes. OK, let’s name them: DB2, Firebird, FrontBase, MySQL, OpenBase, Oracle, PostgreSQL, SQLite, Microsoft SQL Server, Sybase, they’re all covered! I was wondering if I can connect to ODBC?

The second chapter deals with the “simple” things, namely, how to do SELECT, UPDATE, DELETE, INSERT, or what you cool guys usually call “CRUD”, the Active Record-way. This information is usually taken for granted, but it’s explained quite deeply in this book.

The next chapter guides you to design your tables so they work smoothly with Active Record. Although you can use legacy designs just fine with Active Record, your life will be much, much easier if you follow Active Record conventions. This book shows you just how, and in many cases, why.

Chapter 4 shows you how to use core Active Record features, including triggers and validations. If you’re asking that question, then the answer is yes, it’s almost completely overlapping with native but proprietary DBMS functionality such as PL/SQL, DBMS triggers, and constraints. The book doesn’t seem to explain much of this holy war, but I encourage you to ask Google why stored procedures are evil.

Chapter 5 gives you a view of Active Record “bonus features”. I think the chapter title is a misnomer because these features are not just bonus, but one of the greatest strengths of Active Record (compared to other ORM). Things like nested sets, lists, observers, aggregations, and little bit of extending Active Record: these are things that you’ll do, and use, daily — not something you try to avoid. They make your life as a DB integrator easier, not the other way around.

You want to make sure your app works fine, chapter 6 covers unit testing very thoroughly, down to the descriptions of errors (i.e. Active Record Exception objects) you may encounter.

If you already had a previous database, as most of us are, no worries, chapter 7 will guide you how to work with them. This is one of the most useful chapters in this book, because there is less information on the Internet on this topic, but it’s very common that everybody is bound to meet this problem. Come on, who actually learned Active Record before hearing the word DBMS?

The last chapter talks about issues that you’ll encounter in the “real world”, including alternatives and related enhancements to Active Record. What follows is the appendix, which is a really useful quick reference.

The book is really, really good. Full of core information, and related information that aren’t readily available even after asking Mr. Google a hundred times. Despite being written by 3 different developers: Kevin Marshall, Chad Pytel, and Jon Yurek; the entire book is nicely structured and feels cohesive. It will save you lots of time in times of frustration, you can look up the information much quickly here than does a search engine.

Interested already? You can get more information about Pro Active Record book on Amazon, and buy it there too of course. It’s also available on Apress official site.

Personal minor gripe, not a flaw, is there wasn’t a (detachable) cheatsheet. A poster-sized, deluxe exclusive cheatsheet would be a tremendous killer plus to this book. I really think Apress should make this kind of thing mandatory in the future, not only regular Appendixes.

Other resources related to this book:

• James Stewart’s review
• Inside Apress blog

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

microformats has been only two years old, yet it has brought significant changes in a relatively short time.

What is it, actually? According to microformats.org, “[microformats is] designed for humans first and machines second, [they] are a set of simple, open data formats built upon existing and widely adopted standards.”

Enough with the fluff, let’s see how it actually works, microformats in action:

Flickr picture source

The above picture is me browsing to the LinkedIn profile of one of Indonesia’s renowned Ruby on Rails experts, Arie Kusuma Atmaja. The overlay window that contains these semantic information is not a LinkedIn feature. Rather, it is the easily usable, cross-browser Microformats Bookmarklet by LeftLogic. Go on… try it if you haven’t!

As you can see, the mere act of clicking the bookmarklet shows you some important facts about Arie (or any microformats-enabled you’re currently at). In case of a microformats-enabled resume page like in LinkedIn, it shows you where he works, when, education information, and related stuff. For fun comparison purposes only, my LinkedIn profile has more detailed information than his, hehe

The best part is not only that the information is human-readable, but it can also be extracted and processed automatically by machines or software. The primary distinguishing trait of a microformats-enabled HTML page is that it has semantic meaning. A microformats processor can know the difference between a name, an e-mail address, a street address, a job, a university, and so on; while in plain HTML, all you can infer are things dealing with paragraphs, tables, lists, and so on.

Making microformats-enabled pages aren’t hard at all, actually it is very easy! It’s even much easier than CSS.

To see how simple it is, let’s see a snippet of a real-world microformats, still courtesy of Arie:

<div id="masthead" class="vcard contact">
  <div id="nameplate">
    <h1 id="name"><span class="fn n"> <span class="given-name">Arie</span> <span class="family-name">Kusuma Atmaja</span> </span></h1>
      <p class="headline title"><strong>Senior Ruby Developer at IMT</strong></p>
    <div class="adr">
      <p class="locality">Indonesia</p>
    </div>
  </div>
</div>

Most of the above snippet is just HTML. The microformats part is simply the class=”something“ convention. Simple, and it gets the job done.

Some more commonly used microformats specifications include:

• hCard for people and organizations
• hCalendar for calendars and Events
• hCalendar for calendars and Events
• VoteLinks and hReview for opinions, ratings, and reviews
• XFN for social networks
• rel-license for licenses
• rel-tag for tags, keywords, and categories
• XOXO for lists and outlines
• …and more…

Despite all these specifications, “who uses it?” is a good question. It turns out, there has been many, and more and more sites are adopting it. LinkedIn with hResume is one example, along with Google Maps, Yahoo, Flickr, and all these cool guys have been using them. Why shouldn’t you?

Interested? Here are some stuff to get you started:

1. Online Tools
   1. Microformats Bookmarklet by LeftLogic
      A handy microformats explorer bookmarklet. Useful also if you’re on the go and you want to check out some microformats. No need to install anything fancy on the computer.
   2. Operator Firefox Extension
      Microformats explorer extension for Firefox. Whether you’re a web developer or simply want to check out this latest technology, this is a very useful tool.
   3. Tails Firefox extension is another microformats Firefox extension
   4. Almost Universal Microformats Parser is a useful web-based tool to parse microformats.
2. Tutorials and Resources
   
   1. Microformats, what they are and how to use them, by Smashing Magazine
   2. Microformats Tutorial by XFront
      This is a very extensive tutorial. The complete tutorial package including the example files is a 13 MB download!
   3. How to Use Microformats by Vitamin Features
   4. Introduction to Microformats by WhyMicroformats.com
   5. The Big Picture on Microformats by Digital Web Magazine
   6. Another by Digital Web Magazine: Microformats Primer
   7. Back to the future: Mozilla Firefox 3.0 Does Microformats
      Read/WriteWeb’s articles also touched microformats-related stuff quite often.
3. Microformat Parsers
   1. Mofo Ruby Gem and Rails Plugin
      Of course, this is Ruby on Rails blog! Mofo is a microformats parser for Ruby and it also doubles as a Rails plugin. Check out Chris Wanstrath’s post for more information.
      There are also microformat parsers for other languages:
   2. Sumo is a microformats parser for JavaScript
   3. hKit is a microformats parser for PHP
   4. Microformats Parser is another parser for PHP
   5. Microformats Parser for Python
   6. Hpricot Ruby Gem
      Found a bizarre microformat or inventing your own? No problem, Hpricot comes to the rescue. Parse any HTML-ish document as you see fit… More info available from this RedHanded post.
   7. scrAPI is another Ruby library for parsing HTML that can be useful for processing microformats.
4. References
   1. Microformats.org
      “Official” web site of Microformats. You can read everything about microformats, current specifications and newly proposed specs.
   2. “Microformats: Empowering Your Markup for Web 2.0″ Book by John Allsopp
      <br />
      This is the first book dedicated to, and is a comprehensive guide to, microformats. It explores why, in Bill Gates’s words, “We need microformats”; how microformats work; and the kinds of problems microformats help solve. the book covers every current microformat, with complete details of the syntax, semantics, and uses of each, along with real-world examples and a comprehensive survey of the tools available for working with them. the book also features case studies detailing how major web content publishers such as yahoo put microformats to work in their web applications.
   3. Brian Suda’s microformats cheatsheet
      For people who likes it quick and done, this is perfect. It lists microformats properties by format and also lists each format and the hierarchy. This includes elemental microformats, compound microformats and some of the standard design patterns used.
   4. Dave Child’s microformats cheatsheet is another good reference
   5. And more cheatsheets on microformats.org wiki
   6. Gleaning Resource Descriptions from Dialects of Languages (GRDDL) is a recently approved W3C Recommendation that can be used, among others, for extracting semantic information (including microformats) from HTML pages.
   7. microformatique. A blog about all things microformats!

Feel free to add more resources as you see fit, in the comments!

Updates:

1. I originally thought I was gonna list 10 resources… But it seems there are much more
2. More links to John Allsopp’s resources

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.