Intridea - Blog

Intridea in the Community

2008-10-06T00:48:00Z

Intridea believes in supporting the local tech community and will be sponsoring and participating in several upcoming conferences, events, and competitions in October and November.

Ruby DCamp

Intridea is proud to be a platinum sponsor of the first RubyDCamp , an OpenSpace Ruby Conference to be held October 11-12 just outside of Washington DC in Arlington, VA. Ruby DCamp will be a weekend full of Ruby learning, teaching, and hacking and should be a great event for Rubyists of all abilities.

Ignite Baltimore

On October 16th, Intridea will be sponsoring Ignite Baltimore, a high-energy event where 16 of the area’s most interesting people give short 5-minute talks. With topics varying from technology to culture to business to philosophy, it’ll definitely be a night to remember!

BarCamp DC2

BarCamp DC2 is another OpenSpace event Intridea is happy to be sponsoring. At a BarCamp, attendees self-organize to determine the topics they are interested in hearing. Everyone is required to help lead a session or participate in a panel. BarCamp DC2 will be held on October 18th.

South Carolina Ruby Conference

Also on October 18th, Chris and Adam will be speaking in Columbia, SC about becoming a more blissful developer at the South Carolina Ruby Conference . The talk is titled “Remove the Suck – On How to Become a Blissful Developer.”

Rails Rumble

To make the October 18-19 weekend even busier, Intridea will be sponsoring the 2008 Rails Rumble, as well as entering three teams. The Rails Rumble is a weekend event where teams of up to 4 people design, develop, and deploy a working Rails app within 48 hours.

Social Dev Camp East

SocialDevCampEast is a place for east coast developers and technology business leaders to come together for a thoughtful discussion of the ideas and technologies that will drive the future of the social web. Intridea is looking forward to sponsoring and being part of the discussion. SocialDevCampEast will be held on November 1st.

Update: Michael Bleigh will be giving the talk “Hacking the Mid-End: Advanced Rails UI Techniques” at the Great Lakes Ruby Bash on October 11, 2008. If you didn’t get a chance to make it all the way to Berlin for RailsConf Europe, catch the talk again in a longer format!

Slides & Code from Rails Internals Tutorial

2008-09-21T16:39:00Z

Better late than never—here are the slides and the code from the The Renegades Guide to Hacking Rails Internals, the RailsConf Europe 2008 Tutorial given by Pradeep Elankumaran & Michael Bleigh.

Click here to download

Sorry about the delay—the files have also been uploaded to the RailsConf Europe website, though we are not sure when that site will be updated.

Conference Comparison

2008-09-19T17:19:00Z

Last week, along with a few of my Intridea colleagues, I had the opportunity to experience two entirely different Ruby-related conferences. The first was RailsConf Europe, an international Ruby on Rails conference in Berlin Germany. After giving our RCE talks, Pradeep and I got on planes and flew to Austin, TX for the Lone Star Ruby Conference, where Intridea presented a full-day training session. Both conferences had their own unique feel, and it was interesting to compare the community eco-systems inherent in each.

At RailsConf Europe, Intridea had two talks accepted – Michael and Pradeep gave a tutorial on Rails Internals, and Michael and I presented a talk and coding session on Mid-End Rails Development. For our talk, the crowd was attentive, but very quiet. Generally when speaking in a packed room, there will be a quiet rumble as attendees comment on the ongoing presentation. The entire event had more of a formal feeling to it. This could perhaps be due to the language barrier brought on by attendees from all over Europe, the US, and the world coming together – but it was a departure from my other presentation experiences.

Likely related to the varied backgrounds, the RailsConf Europe crowd did not seem to be very cohesive – there appeared to be fewer hallway hack sessions and in-depth discussion that you often find at similar events. The venue also contributed to lack of cohesion. The hotel did not offer breakfast, so attendees didn’t have that early morning mingling that usually occurs. Being held in a hotel in downtown Berlin, there were also many potential distractions. A quick nap in the room, a run out to the street corner bratwurst vendor, a wide variety of local pubs – there were many opportunities to be drawn away from the conference.

Because of the variety of backgrounds, along with the number of distractions, the community feel seemed to be a bit lacking.

The Lone Star Ruby Conference was an entirely different experience, I think a large part due to the venue. At LSRC, the venue was not attached to a hotel, all meals were provided, events were scheduled from morning until night, and there was not a great deal to do within walking distance of the venue – not to mention it was almost too hot to go outside! All of these contributed to a more cohesive group that grew even stronger as the event went on.

Adam, Pradeep, and I presented our full-day training – Rails Refactoring: Triage, Prevention, and Performance – to a great group of developers. Having just come from RCE, where people were from all over, it was different to have a class full of people mostly from the same geographic area (Texas). Perhaps the nature of a training vs a session, but there was much more communication going on between attendees and instructors. The vibe was definitely more laid back.

That vibe extended to the rest of the event – there were lots of hallway hacking sessions, people helping other developers with code problems, and many in-depth technical discussions outside of the actual talks.

Overall, both events offered some great technical talks and the opportunity to meet some great Ruby/Rails minds – but for a community feel, Lone Star wins hands-down.

Present.ly Launches

2008-09-16T14:23:00Z

We have officially opened Present.ly to the public!

You can sign up for an account at the plans page. All accounts come with 60-day trials (you don’t even need a credit card), so what are you waiting for? Get in the Present.ly!

If you still need a little more information about what Present.ly is and how it works, we have just added a videos page with a new screencast.

Thanks for your interest, and we look forward to seeing many of you as users in the near future.

Congratulations, Yammer, But Get Ready To Rumble!

2008-09-11T17:28:00Z

Last night when Yammer won the TechCrunch50, our interest was more than a little piqued. Today we’re officially taking the wraps off of Present.ly, our “Twitter for Businesses” product that we’ve been working on in stealth mode for the last several months and are launching on September 16 at the Web 2.0 Expo in New York.

It’s great to see that short-form communication for businesses is so promising as to win top honors at such a competitive conference. We’re extremely passionate about the field because it has the potential to really transform how people communicate inside an organization. So congratulations are in order to the Yammer team for bringing so much exposure to the field.

One of the reasons that we were so surprised to see Yammer among the TechCrunch50 is because Present.ly was submitted to be included as well! Unfortunately, we never got the chance to demo our product for the TC50 experts (something that was supposed to be part of the process). We didn’t receive a clear response back as to why, but it would have been great to have the chance to go head-to-head with Yammer in the preliminaries of TechCrunch50 or on stage at the conference.

It’s Still On, Though

Be that as it may, it’s certainly been a shot of adrenaline for our team to have a surprise competitor mere days before we are set to launch. We’ve had some time to examine Yammer, and we’re ready for some competition! So how do they stack up against each other?

Security and Control: Present.ly is built to be an official means of communication for a business, rather than an ad-hoc network of employees. User accounts on Present.ly are created only through administrator invitations, and accounts are secured using SSL encryption.

Collaboration: Present.ly has hash tags, like Yammer. But it also has groups, private messaging, and media/file sharing built in. We built Present.ly from the ground up to have powerful features tailored specifically for business use. Present.ly accounts can also be extended beyond a single e-mail domain, allowing you to include clients, consultants and other collaborators effortlessly.

Platform Approach: Starting from day one Present.ly has an API that is fully compatible with the Twitter REST API. This means that existing Twitter applications can work instantly with Present.ly with almost no modification. Through the API, Present.ly can easily integrate with all parts of your business.

The Power of Context: Present.ly automatically analyzes each post for context, automatically separating out questions, replies, and urgent messages. Our robust notifications system allows you to receive updates via E-Mail, SMS, and IM based on this context.

We’re really proud of Present.ly and think that it can enable great new things for companies of all sizes, from 5 employees to 50,000. On September 16, get ready to start using the REAL Twitter for Business.

Intridea World Tour: Berlin, Texas, and DC

2008-09-06T00:01:00Z

It’s been a busy week at Intridea. Michael, Pradeep, and Chris presented a couple of talks in Berlin. Then, Chris and Pradeep met up with Adam in Austin, Texas for a full-day training session. Back in our DC headquarters, I was one of the panelists for the Future of Software event organized by Potomac Tech Wire. Japan and China next year? We are definitely getting our name around.

The Future of Software event was attended by over 200 tech executives in the area. The discussion revolved around technology trends, business model implications, and funding software companies. There was a lot of discussion on open-source and software as service (SaaS) models destroying the lucrative, traditional perpetual license models. I was really surprised by how much discussion we had on Ruby On Rails (and I didn’t even have to start it!), both among the panelists and the audience. It’s nice to know that ROR is hot in this area flooded with defense contractors.

Here are some of my thoughts I prepared for the meeting:

Three Software Trends

Cheap, easy-to-use consumer software will continue to make in-roads into the business world. Google Apps in the enterprise will fundamentally change the way we collaborate inside the companies as well as personal life (e.g. Gmail, Calendar, GChat, Apps, Sites, etc)

Building applications on top of open platforms with existing user bases will continue (e.g. iPhone Apps, OpenSocial, Facebook apps, Linkedin). Innovation and the killer apps come from the development community rather than the platform companies. It’s still hard to make money on these platforms.

Software as Service is finally taking off (Salesforce, Google Apps, Basecamp, ...). Even small companies can buy enterprise software.

Commoditization & Business Models

Commoditization is inevitable. Companies will need to aggressively focus on customer value and innovate more rapidly.

Software as Service is finally taking off (Salesforce, Google Apps, Basecamp, ...). Even small companies like us can buy enterprise software like SalesForce.

The freemium model is also popular on the web. You attract the users with the free version and then upsell them through value-added features.

Servicing open-source apps is great way for new companies to compete with the large companies. Even using this approach you need lot of energy to promote the technology, build a multi-vendor eco-system, and convert the leads into sales.

Fate of big software companies (Microsoft, Oracle and SAP, etc) in 10 years:

Ten years is a long time in software business. Probably a couple of players will be still very strong. Probably 25% will fail. The remaining players will not be so dominant. They will continue to survive through acquisition of innovative companies. New leaders will emerge. Second comings like Apple are going to be rare.

Advice to new startups:

Don't under-estimate the need for marketing and sales. After your initial beta launch, the interest will wane. You have to promote the product pretty heavily to get the traction you wanted. It will take time to succeed. Ideas are cheap and execution is hard.

Find a business partner. Start-ups can be a roller coaster ride, it helps to have someone to brainstorm ideas and to share the ups and downs.

I think entrepreneurship is the best way to compete in the global marketplace.

Updates from Lone Star RubyConf 2008

2008-09-05T15:51:00Z

Greetings from blazing hot Austin, TX where Chris, Adam & I are attending Lone Star RubyConf 2008. We gave the Rails Refactoring—Triage, Prevention & Performance tutorial yesterday to about 25 attendees of the conference, which was quite exciting and enjoyable.

Personally, I really like the small regional-conference feel of Lone Star RubyConf. The ambiance is much more laid-back than the two Railsconfs and networking is effortless. It doesn’t hurt that the conference is located in Austin, which is a real foodie heaven (especially barbeque), with a very cool and friendly Ruby/Rails community.

This year, the conference seems to have attracted a good set of speakers—I saw many prominent Rubyists walking the halls, and talking to many of the speakers was quite informative. Matz is here, and we’ve taken to thanking him for Ruby every time we’ve run into him in the hallway, which is honestly the least we could do without feeling like stalkers.

Highly recommended if you’re thinking of attending next year.

RailsConf Europe 2008: Hacking the Mid-End

2008-09-03T10:36:00Z

Michael Bleigh and Chris Selmer gave a talk at RailsConf Europe 2008 entitled “Hacking the Mid-End: Advanced Rails UI Techniques.” If you had a chance to attend, please take a moment to evaluate the session. If not, hopefully this post will help you understand a bit of what you missed!

This talk was aimed at being an introduction to the role of a mid-end developer; someone who facilitates the back-end and front-end developers and also writes the javascript interaction layer using Unobtrusive Scripting. You can view the slides embedded below, or you can download the slide deck directly.

The Rails app that we developed during the talk is available on GitHub with all of the completed code. If you have any questions or comments, we’d love to hear from you. Thanks to everyone who came and saw the talk!

Railsconf Europe 2008 Updates + Lonestar RubyConf

2008-09-03T05:26:00Z

Greetings from still sunny Berlin, where Michael & I wrapped up our Hacking Rails Internals talk yesterday. We would love to hear comments from those who attended—we are actively working on getting the slides and demo code to you as soon as possible. Please rate our session if you did attend, so that we can get some constructive feedback.

Today, Chris & Michael will be presenting Hacking the Mid-End : Unobtrusive Scripting & Advanced UI Techniques in Rails. This 45-minute talk will be a discussion of the “Mid-End”—advanced user interface problems that don’t fit the traditional ‘back-end’ and ‘front-end’ categorization. You can find more details on the RailsConf site.

Chris & I will also be flying out today from Berlin to Austin, TX for the Lonestar RubyConf. Along with Adam Bair, we’re giving a 6-hour mid-level training session on refactoring Rails apps. We will be talking about how to effectively rescue horrid codebases, prevent your codebase from turning into a monster and performance issues—we’re quite excited.

While we’re sad to leave Berlin so quickly—we got the chance to checkout some excellent street food in the city. Next time you’re in Berlin, give yourself a break for one night from expensive restaurants and indulge in Doner Kababs and Bratwurst (usually found with a few blocks of your hotel). Highly recommended. We also saw some yellow watermelon, but that’s not much of a story.

Michael will be here in Berlin till the end of the conference on Thursday—please come say hello if you can at either conference!

Greetings from Berlin!

2008-09-01T16:40:00Z

Chris, Michael & I are at sunny/rainy Berlin, Germany at Railsconf Europe 2008. This year, the conference is being held at the Maritim proArte Hotel right in the middle of Downtown Berlin. Great food and interesting people around—we’re looking forward to speaking at the conference tomorrow and the day after.

If you’re attending the RailsConf tutorials, come see Michael & I speak tomorrow (Sept. 2, 2008) about hacking and tweaking the Rails internals for your project’s benefits. We have a nice mixup of slides and livecoding sessions ready, and will be running through some hardcore Rails internals material including the Rails class loader and the ever-confusing Routes implementation.

Chris & I will be attending Bratwurst on Rails, so if you would like to meetup, find us there. Bratwurst On Rails

Stay tuned for more coverage of Railsconf Europe and Lonestar RubyConf!

Intridea at RailsConf Europe and Lone Star Ruby

2008-08-31T18:06:00Z

Intridea will be speaking at two Ruby/Rails conferences this week. If you're attending either conference, make sure you come by and say hi!

RailsConf Europe

Pradeep Elankumaran and Michael Bleigh will be presenting their RailsConf Europe tutorial: The Renegade's Guide to Hacking Rails Internals, on September 2nd.

This far-reaching tutorial will give Intermediate and Advanced Rails developers a crash course in hacking and extending Rails internals. The topics covered will include: Ruby Meta-programming Techniques; Rails Abstractions, Idioms & Mixins; Rails Structure & Initialization; A Tour of the Rails Class Loader; Plugin Locators and Loaders; Codebase Modularization using Rails Plugins; Extending ActionView Form Builders; Site-wide Settings; and much more…

Michael Bleigh and Chris Selmer will be presenting a RailsConf Europe talk: Hacking the Mid-End: Unobtrusive Scripting and Advanced UI Techniques in Rails, on September 3rd. Here's the talk overview:

As web application development advances beyond the static page, a whole new field of development is emerging. In the Javascript behavior layer and markup abstracting helpers lie the ’Mid-End’: advanced user interface problems that don’t fit traditional ‘back-end’ and ‘front-end’ models. Explore this new field with case studies and real code such as usage of Lowpro Javascript behaviors to keep the behavior separate from the markup. Learn how to give back-end developers the tools to create simple, repeatable, quality markup through block-accepting helpers. Discuss the methods that allow for rapid development of complex interactions in new and exciting ways and see real examples. Finally, look into the future of the Mid-End and what lies ahead for user interface development.

The Lone Star Ruby Conference

Adam Bair, Pradeep Elankumaran, and Chris Selmer will be leading a training on the first day of the LSRC. The training is titled: Rails Refactoring: Triage, Prevention, and Performance. And the overview:

Maybe you inherited a mess of a Rails project – or perhaps your own codebase is poorly-tested, not very DRY, or just generally confusing. Worse yet, maybe your Rails site has slowed down to a crawl or even stopped working entirely. Whatever the reason, it’s time to consider refactoring these rough spots and boosting your site’s performance.

In the first half of the day we’ll go through real-life examples of (shameful) code we’ve written and refactored, give tips on how and when to start, and show you how to avoid the need for a future refactor. In the second half, we’ll introduce common Rails performance pitfalls, how to diagnose them, and how to solve them. We’ll also talk about other ways to speed up your app.

Colorist: Color Manipulation For WebHeads

2008-08-18T15:43:00Z

While writing color customization code for a recent project, I once again ran into the fact that the existing color gems for Ruby seem to be built for vastly different purposes. To that end, I decided to write a new library for dead-simple manipulation of colors with an emphasis on ease-of-use and being useful for web developers.

Installation

gem install colorist

The Basics

To instantiate a color in Colorist, you use a number of methods:

require 'colorist'
include Colorist

red = Color.new(0xff0000)
red = 0xff0000.to_color
red = "red".to_color
red = "#f00".to_color
red = Color.from_rgb(255,0,0)

Note: I include Colorist in these examples, but there’s no reason you can’t leave it namespaced i.e. Colorist::Color instead.

The idea is to give maximum flexibility without making it complicated. Once you’ve instantiated a color, you can figure out a few tidbits about it and perform some basic operations:

red.brightness # => 0.299
red.r # => 255
red.invert # => #<Color #00ffff>
red.text_color # => #<Color #ffffff>
red.to_s # => "#ff0000" 
red.to_s(:rgb) # => "1.000, 0.000, 0.000"

Operations

The real value of Colorist comes in comparison and addition. You can use normal operators with the colors to add them together, subtract them, and compare them based on brightness. You can also do this with the string or numeric representations of colors:

red = 0xff0000.to_color
green = 0x00ff00.to_color
yellow = red + green
yellow = "red".to_color + "green" 
yellow.to_s # => "#ffff00" 
red - 0.2 # => #<Color #cc0000>

Comparisons work off of the brightness of a given color. You can also calculate the contrast between two colors using the W3C’s formula:

red = "red".to_color
red > "black".to_color # => true
red > "white".to_color # => false
red.contrast_with("green".to_color) # => 0.500653594771242

Get Coloring!

That’s most of the basic functionality, for all of the details you can view the RDoc on RubyForge. The source is available on GitHub and there is a Lighthouse project for any bugs or feature requests. Enjoy!

Fetches: Bringing Your ActionController its Slippers

2008-07-28T18:45:00Z

There is a piece of code that shows up more than 80% of the controllers that I write, and it goes a little something like this:

class UsersController < ApplicationController
  def user
    @user ||= User.find(params[:id])
  end
  helper_method :user
end

A simple memoization method to allow me to easily grab the parameter-referred user in all of my actions. If I’m using nested routes, that means I can write two, maybe three of these methods into a controller. I’m basically using slight variations on the same code 20 different times in an application. Since we live in a world that loves to be DRY, I thought, “I can do better.”

Fetches: Memoizing Your Parameter Record Retrieval

Fetches is a simple extension to ActionController that lets you simply define those kinds of fetch methods on a one-line command. For the example above, I can rewrite it like so:

class UsersController < ApplicationController
  fetches :user
end

That’s pretty useful! Not only can I call the “user” method from the controller, but it’s automatically helperized so that I can use the same call in my views. Of course, there are times when more advanced fetching is called for, say using a method other than find or storing to a different variable name. Let’s take a look at a slightly more complex example:

# assuming a route like /users/:user_id/articles/:id
class ArticlesController < ApplicationController
  fetches :user, :as => :author, :from => :user_id, :using => :find_by_login
  fetches :article
end

Now if I were to call “author” in any of my controller actions, it would be equivalent to User.find_by_login(params[:user_id]). Similarly, calling “article” is equivalent to Article.find(params[:id]). The “from” option can also take a Proc in case your fetching is not simply a parameter key:

class UsersController < ApplicationController
  fetches :user, :from => Proc.new{ |c| c.params[:user_id] || c.params[:id] }
end

The main advantages to fetches are brevity, clarity and DRYness. I’ve found that this method covers every use case for parameter-based fetching that I’ve needed, and as such provides a much simpler, more readable, and shorter way to fetch models for use in your controller and views.

Installation

Fetches is available as a gem as well as in traditional plugin format. To install as a gem, add this to your environment.rb:

config.gem 'mbleigh-fetches', :source => 'http://gems.github.com', :lib => "fetches"

To install it as a traditional plugin:

script/plugin install git://github.com/mbleigh/fetches.git

Resources

The source is available on GitHub, the Acts As Community project is there for general discussion, and the Lighthouse is there for bugs and feature suggestions.

UPDATE: A commenter requested that the plugin be able to handle creation of new records in addition to fetching existing records. I have added in the :initialize option to do just this. Examples:

fetches :user, :initialize => true # initialize from params[:user]
fetches :user, :initialize => :author # initialize from params[:author]
fetches :user, :initialize => Proc.new{ |c| {:login => c.params[:login], :email => c.params[:email]} }

Using HTTP Status Codes for Rails AJAX Error Handling

2008-07-23T15:05:00Z

A problem that often arises in AJAX-based web applications is how to handle it when things go wrong. The user should be informed of the problem in a descriptive manner, but obviously the internal workings of the application should not be revealed. A generic and useful way to handle this problem is to use HTTP Status Codes to indicate the type of failure, and use the javascript to cope appropriately.

In this example I will be using jQuery, but the principles behind are just as applicable to Prototype or any other Javascript library.

Your Friends 403 and 500

Anyone who’s built a Rails site is familiar with the 500 error. That’s the generic exception code thrown whenever something goes wrong in your application. Users should, hopefully, never ever see this when they’re using the site. However, oftentimes there are exceptions or errors that users should experience just as result of improperly filling out fields, permissioning, etc. So how do we differentiate?

The Rails render method has the ability to render out an arbitrary HTTP Status Code (i.e. 500 for error, 404 for not found, and many more). The “403 Forbidden” code means that the server understood the request made of it, but is refusing to complete it. This sounds like an apt description for typically “caught” exceptions. So let’s use the 403 code to intelligently handle the exceptions that we want to be seen by the user.

In the controller

Let’s take the simplest example, an invalid record. If you are creating a record via AJAX, a flash[:error] with a render :action => "new" is not going to suffice. Let’s try something like this instead:

class ItemsController < ApplicationController
  def create
    Item.create!(params[:item])
    # continue on your merry way if it works
  rescue ActiveRecord::RecordInvalid => e
    respond_to do |format|
      format.html { 
        flash.now[:error] = "There was a problem creating the item." 
        render :action => "new" 
      }
      # Render out the validation failed message with a
      # 403 status code.
      format.js { render :text => e.message, :status => 403 }
    end
  end
end

All right, now that we’ve got it handled on the controller side, it’s time to work some Javascript magic on our AJAX call.


$('a#ajax_link').click(function() {
  $.ajax({
    url: '/items', 
    success:function(data, textStatus) {
      // do success things
    },
    error:function(request, textStatus, errorThrown) {
      // Use the specific message for a 403, but
      // a generic failure message for a 500
      var message = (request.status == 403) ? 
        request.responseText : "An unknown error occurred. Support has been contacted.";
      // Simple alert for example, but you can handle
      // however you want, such as populating an error message
      // div and making it appear.
      alert(message);
    }
    return false;
  });
});

Now when your AJAX request fails, it will render a user-friendly error message if it’s an ‘expected’ error or a generic message if the request fails with an unexpected exception.

This is a simple example, but by building a general framework for error expectations you can make it much easier to provide user-friendly error handling that gives them all of the information they need without revealing any of your internal processes.

Mobilize Your Rails Application with Mobile Fu

2008-07-21T16:20:00Z

Let's face it, iPhone interfaces are awesome, but they can only cater to a fraction of the mobile market. What are you to do if you want to satisfy the rest of the mobile world? Mobile Fu helps to make this job much easier by automatically detecting mobile devices that access your Rails application. People can access your site from a Palm, Blackberry, iPhone, Nokia, etc. and it will automatically adjust the format of the request from :html to :mobile.

Learn Mobile Fu

First off, just install the Mobile Fu plugin into your Rails application.

script/plugin install git://github.com/brendanlim/mobile-fu.git

Start by adding this one line to your ApplicationController.

class ApplicationController < ActionController::Base
  has_mobile_fu
end

Once this is in place, any request that comes from a mobile device will be be set as :mobile format. It is up to you to determine how you want to handle these requests by creating the .mobile.erb versions of your views that are to be requested. Also, I recommend that you setup a before_filter that will redirect to a specific page depending on whether or not it is a mobile request. How can you check this?

is_mobile_device? # => Returns true or false depending on the device

You can also determine which format is currently set in by calling the method below.

in_mobile_view? # => Returns true or false depending on current req. format

If you want the ability to allow a user to switch between ‘mobile’ and ‘standard’ format (:html), you can just adjust the mobile_view session variable in a custom controller action.

session[:mobile_view] # => Set to true if request format is :mobile and false
                           if set to :html

What About Custom Mobile Styling?

Different devices need different styling. Don’t worry though, we’ve got this baked in to Mobile Fu (thanks to Intridea's own Michael Bleigh, who created Browserized Styles for letting me modify his code). If you are including a css or sass file via stylesheet_link_tag, all you have to do is add _device to the name of one of your files to override your styling for a certain device. The stylesheet that is loaded is dependant on which device is making the request.

Supported stylesheet override device extensions at the moment are: blackberry, iphone, mobileexplorer, nokia, palm

e.g., Accessing a page from a Blackberry.

<%= stylesheet_link_tag 'mobile.css' %>  

Ends up loading mobile.css, and mobile_blackberry.css if the file exists.

Feature Requests

You can check out Mobile Fu's very own project page at Acts As Community. If you have any problems or would like me to add a certain feature, please create a ticket at http://blim.lighthouseapp.com/projects/14490-mobile-fu/. Also, feel free to fork Mobile Fu and make any enhancements you please from its GitHub location at: http://github.com/brendanlim/mobile-fu/tree/master