Impossible is Impossible

creating images from unicode text using rmagick

noreply@blogger.com (Arunkumar) — Mon, 31 Aug 2009 17:43:00 +0000

To create images from the unicode text, we can use the "encoding" method for the Draw object.

Example:

require "RMagick"

def show_textimg
bg = Magick::Image.new(120,20){self.background_color = "#9E9E9E"}
text = Magick::Draw.new
text.encoding = "Unicode"
text.text(23,14,"ドの半角⇔全角")
text.draw(bg)
bg.write "#{RAILS_ROOT}/public/images/text.jpg"
end

Top Ten Mistakes in Web Design

noreply@blogger.com (Arunkumar) — Mon, 28 Jan 2008 09:28:00 +0000

Top Ten Mistakes in Web Design

Summary:
The ten most egregious offenses against users. Web design disasters and HTML horrors are legion, though many usability atrocities are less common than they used to be.

1. Bad Search

Overly literal search engines reduce usability in that they're unable to handle typos, plurals, hyphens, and other variants of the query terms. Such search engines are particularly difficult for elderly users, but they hurt everybody.

A related problem is when search engines prioritize results purely on the basis of how many query terms they contain, rather than on each document's importance. Much better if your search engine calls out "best bets" at the top of the list -- especially for important queries, such as the names of your products.

Search is the user's lifeline when navigation fails. Even though advanced search can sometimes help, simple search usually works best, and search should be presented as a simple box, since that's what users are looking for.

2. PDF Files for Online Reading

Users hate coming across a PDF file while browsing, because it breaks their flow. Even simple things like printing or saving documents are difficult because standard browser commands don't work. Layouts are often optimized for a sheet of paper, which rarely matches the size of the user's browser window. Bye-bye smooth scrolling. Hello tiny fonts.

Worst of all, PDF is an undifferentiated blob of content that's hard to navigate.

PDF is great for printing and for distributing manuals and other big documents that need to be printed. Reserve it for this purpose and convert any information that needs to be browsed or read on the screen into real web pages.

> Detailed discussion of why PDF is bad for online reading

3. Not Changing the Color of Visited Links

A good grasp of past navigation helps you understand your current location, since it's the culmination of your journey. Knowing your past and present locations in turn makes it easier to decide where to go next. Links are a key factor in this navigation process. Users can exclude links that proved fruitless in their earlier visits. Conversely, they might revisit links they found helpful in the past.

Most important, knowing which pages they've already visited frees users from unintentionally revisiting the same pages over and over again.

These benefits only accrue under one important assumption: that users can tell the difference between visited and unvisited links because the site shows them in different colors. When visited links don't change color, users exhibit more navigational disorientation in usability testing and unintentionally revisit the same pages repeatedly.

> Usability implications of changing link colors
> Guidelines for showing links

4. Non-Scannable Text

A wall of text is deadly for an interactive experience. Intimidating. Boring. Painful to read.

Write for online, not print. To draw users into the text and support scannability, use well-documented tricks:

subheads
bulleted lists
highlighted keywords
short paragraphs
the inverted pyramid
a simple writing style, and
de-fluffed language devoid of marketese.

> Eyetracking of reading patterns

5. Fixed Font Size

CSS style sheets unfortunately give websites the power to disable a Web browser's "change font size" button and specify a fixed font size. About 95% of the time, this fixed size is tiny, reducing readability significantly for most people over the age of 40.

Respect the user's preferences and let them resize text as needed. Also, specify font sizes in relative terms -- not as an absolute number of pixels.

6. Page Titles With Low Search Engine Visibility

Search is the most important way users discover websites. Search is also one of the most important ways users find their way around individual websites. The humble page title is your main tool to attract new visitors from search listings and to help your existing users to locate the specific pages that they need.

tag and is almost always used as the clickable headline for listings on search engine result pages (SERP). Search engines typically show the first 66 characters or so of the title, so it's truly The page title is contained within the HTML microcontent.

Page titles are also used as the default entry in the Favorites when users bookmark a site. For your homepage, begin the with the company name, followed by a brief description of the site. Don't start with words like "The" or "Welcome to" unless you want to be alphabetized under "T" or "W."

For other pages than the homepage, start the title with a few of the most salient information-carrying words that describe the specifics of what users will find on that page. Since the page title is used as the window title in the browser, it's also used as the label for that window in the taskbar under Windows, meaning that advanced users will move between multiple windows under the guidance of the first one or two words of each page title. If all your page titles start with the same words, you have severely reduced usability for your multi-windowing users.

Taglines on homepages are a related subject: they also need to be short and quickly communicate the purpose of the site.

7. Anything That Looks Like an Advertisement

Selective attention is very powerful, and Web users have learned to stop paying attention to any ads that get in the way of their goal-driven navigation. (The main exception being text-only search-engine ads.)

Unfortunately, users also ignore legitimate design elements that look like prevalent forms of advertising. After all, when you ignore something, you don't study it in detail to find out what it is.

Therefore, it is best to avoid any designs that look like advertisements. The exact implications of this guideline will vary with new forms of ads; currently follow these rules:

banner blindness means that users never fixate their eyes on anything that looks like a banner ad due to shape or position on the page
animation avoidance makes users ignore areas with blinking or flashing text or other aggressive animations
pop-up purges mean that users close pop-up windoids before they have even fully rendered; sometimes with great viciousness (a sort of getting-back-at-GeoCities triumph).

8. Violating Design Conventions

Consistency is one of the most powerful usability principles: when things always behave the same, users don't have to worry about what will happen. Instead, they know what will happen based on earlier experience. Every time you release an apple over Sir Isaac Newton, it will drop on his head. That's good.

The more users' expectations prove right, the more they will feel in control of the system and the more they will like it. And the more the system breaks users' expectations, the more they will feel insecure. Oops, maybe if I let go of this apple, it will turn into a tomato and jump a mile into the sky.

Jakob's Law of the Web User Experience states that "users spend most of their time on other websites."

This means that they form their expectations for your site based on what's commonly done on most other sites. If you deviate, your site will be harder to use and users will leave.

9. Opening New Browser Windows

Opening up new browser windows is like a vacuum cleaner sales person who starts a visit by emptying an ash tray on the customer's carpet. Don't pollute my screen with any more windows, thanks (particularly since current operating systems have miserable window management).

Designers open new browser windows on the theory that it keeps users on their site. But even disregarding the user-hostile message implied in taking over the user's machine, the strategy is self-defeating since it disables the Back button which is the normal way users return to previous sites. Users often don't notice that a new window has opened, especially if they are using a small monitor where the windows are maximized to fill up the screen. So a user who tries to return to the origin will be confused by a grayed out Back button.

Links that don't behave as expected undermine users' understanding of their own system. A link should be a simple hypertext reference that replaces the current page with new content. Users hate unwarranted pop-up windows. When they want the destination to appear in a new page, they can use their browser's "open in new window" command -- assuming, of course, that the link is not a piece of code that interferes with the browser’s standard behavior.

10. Not Answering Users' Questions

Users are highly goal-driven on the Web. They visit sites because there's something they want to accomplish -- maybe even buy your product. The ultimate failure of a website is to fail to provide the information users are looking for.

Sometimes the answer is simply not there and you lose the sale because users have to assume that your product or service doesn't meet their needs if you don't tell them the specifics. Other times the specifics are buried under a thick layer of marketese and bland slogans. Since users don't have time to read everything, such hidden info might almost as well not be there.

The worst example of not answering users' questions is to avoid listing the price of products and services. No B2C ecommerce site would make this mistake, but it's rife in B2B, where most "enterprise solutions" are presented so that you can't tell whether they are suited for 100 people or 100,000 people. Price is the most specific piece of info customers use to understand the nature of an offering, and not providing it makes people feel lost and reduces their understanding of a product line. We have miles of videotape of users asking "Where's the price?" while tearing their hair out.

Even B2C sites often make the associated mistake of forgetting prices in product lists, such as category pages or search results. Knowing the price is key in both situations; it lets users differentiate among products and click through to the most relevant ones.

Source : http://www.useit.com/alertbox/9605.html

'send' in Ruby

noreply@blogger.com (Arunkumar) — Fri, 04 Jan 2008 06:25:00 +0000

send

Calling a method when method name is stored as a string object in a variable i.e. you can not see which method to call.

example 1
when method name is simply stored as a String object

class C
def wish
p "hello world"
end
end
a = "wish"
c = C.new
c.send(a)

example 2
making set method at runtime

class C
attr_accessor :name
end
c = C.new
a = "name"
c.send(a + "=", "Arun")
p c.send(a)

example 3
this is interesting, when attribute name itself is send

class C
attr_accessor :send
end
c = C.new
a = "send"
c.__send__(a + "=", "Arun")
p c.__send__(a) # => Arun

Difference between Strings and Symbols in Ruby

noreply@blogger.com (Arunkumar) — Thu, 29 Nov 2007 09:40:00 +0000

Symbols have two nice properties compared to strings which can save you memory and CPU time:

Memory

For every unique string value, there is a unique symbol object. Three strings with the same value can use up to three times the memory of three symbols with the same value. This is because those three symbols are actually the same object.

p "blah".object_id #=> -605600196

p "blah".object_id #=> -605618816

p "blah".object_id #=> -605637168

p :blah.object_id #=> 4071694

p :blah.object_id #=> 4071694

p :blah.object_id #=> 4071694

p "blah".to_sym.object_id #=> 4071694

p "blah".to_sym.object_id #=> 4071694

p "blah".to_sym.object_id #=> 4071694

I think now you can understand

Symbol objects are created on-demand behind the scenes for new unique string values. Once a symbol exists for a particular string value, it will continue to be used for that value rather than creating more symbols for it.

Of course, this has a disadvantage: Ruby keeps symbols around forever (well, until the end of your program anyway), in case they are needed again.

That’s fine if the number of unique symbols is relatively small and you expect to keep reusing them. However, if you have an unlimited number of string values, and/or you only use each one briefly (for example, lines arriving on an input stream), symbols are not the tool for you. You’ll just use up all your memory.

CPU Time

Testing two symbol values for equality (or non-equality) is faster than testing two string values for equality, because Ruby only needs to do a single test. Checking two strings for equality is more complicated; every individual character in the string has to be checked until a difference is found.

As noted above, each unique string value has an associated symbol. This means that checking whether two symbols have the same string value or not is as simple as checking whether they are the same object or not.

One comparison:

:Worcestershire == :Worcestershire

Easy peasy. They’re the same object, so they’re equal.

Sixteen comparisons:

"Worcestershire" == "Worcestershire"

With strings, Ruby has to dig into the objects to check their contents. Since in this case they’re different string objects with the same length, it’s got to check all fourteen characters in each string to make sure that they really are equal.

However, what symbols don’t give you is lexical comparison. You can do "foo" > "bar", but not :foo > :bar. They’re digested. Their original string values are a memory which can be resurrected only via Symbol#to_s.

The Right Tool for the Job

If you have a modest number of unique string values that you want to use over and over, and will mostly be using them as-is (i.e. not concatenating them, uppercasing them, etc….), then symbols are the right tool for you.

Method names (such as those given to Module#attr_reader, or Object#send) are a good example of this; in fact, Ruby uses symbols internally to remember method, variable, and constant names.

Otherwise, stick with strings. Strings are not that much slower than symbols, and many times the extra limitations of symbols aren’t worth it.

Rails 2.0 - Preview Release

noreply@blogger.com (Arunkumar) — Wed, 14 Nov 2007 04:37:00 +0000

Its time to feel the Real Power of Rails.
The Rails 2.0 preview version is just released.

I've listed down some of the important updates of Rails 2.0 here

Action Pack - Multiview

In Rails 2.0, the format of the template is separated from its rendering engine. So show.rhtml now becomes show.html.erb, which is the template that’ll be rendered by default for a show action that has declared format.html in its respond_to. And you can now have something like show.csv.erb, which targets text/csv, but also uses the default ERB renderer.

So the new format for templates is action.format.renderer. A few examples:

show.erb: same show template for all formats
index.atom.builder: uses the Builder format, previously known as rxml, to render an index action for the application/atom+xml mime type

Action Pack: Record identification

Piggy-backing off the new drive for resources are a number of simplifications for controller and view methods that deal with URLs. We’ve added a number of conventions for turning model classes into resource routes on the fly. Examples:


# person is a Person object, which by convention will
# be mapped to person_url for lookup
redirect_to(person)
link_to(person.name, person)
form_for(person)

Action Pack: HTTP Loving

New module is added in Rails 2.0 to work with HTTP Basic Authentication, which turns out to be a great way to do API authentication over SSL. It’s terribly simple to use. Here’s an example (there are more in ActionController::HttpAuthentication):


class PostsController < password = "dhh" except =""> [ :index ]

  def index
    render :text => "Everyone can see me!"
  end

  def edit
    render :text => "I'm only accessible if you know the password"
  end

  private
    def authenticate
      authenticate_or_request_with_http_basic do |user_name, password|
        user_name == USER_NAME && password == PASSWORD
      end
    end
end

Active Record: Sexy migrations

There’s a new alternative format for declaring migrations in a slightly more efficient format. Before you’d write:

create_table :people do |t|
t.column, "account_id",  :integer
t.column, "first_name",  :string, :null => false
t.column, "last_name",   :string, :null => false
t.column, "description", :text
t.column, "created_at",  :datetime
t.column, "updated_at",  :datetime
end

Now you can write:

create_table :people do |t|
t.integer :account_id
t.string  :first_name, :last_name, :null => false
t.text    :description
t.timestamps
end

And hundreds upon hundreds of other improvements

We’ve got literally hundreds of bug fixes, tweaks, and feature enhancements crammed into Rails 2.0. All this coming off the work of tons of eager contributors working tirelessly to improve the framework in small, but important ways.

So how do I upgrade?

If you want to move your application to Rails 2.0, you should first move it to Rails 1.2.3. That’ll include deprecation warnings for most everything we yanked out in 2.0. So if your application runs fine on 1.2.3 with no deprecation warnings, there’s a good chance that it’ll run straight up on 2.0. Of course, if you’re using, say, pagination, you’ll need to install the classic_pagination plugin. If you’re using Oracle, you’ll need to install the activerecord-oracle-adapter gem. And so on and so forth for all the extractions.

To install the preview release through gems, do:

gem install rails --source http://gems.rubyonrails.org

To try it from an SVN tag, use:

rake rails:freeze:edge TAG=rel_2-0-0_PR


Thanks to David Heinemeier Hansson and the core team of committers and hundreds of open-source contributors

Another IDE for Rails - NetBeans 6.0 Beta

noreply@blogger.com (Arunkumar) — Mon, 08 Oct 2007 04:57:00 +0000

NetBeans is an open-source IDE written in Java (somewhat like Eclipse, but not the same), and version 6.0 is the first with a Ruby-specific edition that focuses solidly on the things that Ruby and Ruby on Rails developers need. The NetBeans team have just released the first beta version.

NetBeans is a free IDE. You can create Ruby and Rails projects, run Ruby files, configure interpreters (MRI and JRuby), install Gems graphically, run tests, run RSpecs, debug Ruby code, run Rails apps, and so on, all from the IDE.

You can download it from here .

Rails Validations

noreply@blogger.com (Arunkumar) — Sun, 12 Aug 2007 02:51:00 +0000

Validation is nothing but a set of methods to ensure the integrity of information in the database. It forms a minimum standard that all records must meet before they can be saved.

Validation takes place before a model is saved. If the model being saved doesn’t meet its validation requirements, it will NOT be saved to the database. Attempts to save an invalid model return false. This allows for the “if-save” convention:

if @object.save
# object was valid and saved
..
else
# object was invalid, not saved
..
end

You can trigger validation manually by calling the models validate method.

@object.validate

But likely more useful would be to call valid?, which runs validate then returns true or false.

if @object.valid?
...

Avoiding validation

You can skip validation by passing false to save.

@object.save(false)

Similarly whenever "update_attribute" method is used, the validation for the
corresponding object is skipped. But if you use "update_attibutes" method,
It will trigger the validation methods for that object.

Note:
Skipping validtion may result (obviously) in invalid data being
recorded to the database.

Validation in Controllers:

When a model is validated, any validation errors will be collected in the models errors object.
you can use validation methods for an object in the controller class itself by just inspecting the object ( conditions ), and adding the errors to that object like this

@object.errors.add(:attribute,"#{error_messages}")

Compression in RMagick

noreply@blogger.com (Arunkumar) — Thu, 19 Jul 2007 16:26:00 +0000

Whenever you upload an image, and resize it using rmagick library, it will do the resize operation with default compression techniques. Sometimes the user may upload images which are directly from digital cameras, these images contain lots of metadata including color profiles. Anyway We don’t need any of these color profile information in the resized images :)

You can remove those color profiles from your images using the RMagick method called "delete_profile" (an instance method of Image class in RMagick library).

or You can use the method "profile!("*", nil)" to delete all the color profiles.

you have to use the above methods like this

image.delete_profile(profile_name)

if you put a specific profile name like "IPTC" or "ICC", it will delete the specified profile.

if you use image.delete_profile("*"), it will delete all the profiles.

image.profile!("*", nil)

This will remove all the profiles of the images.

Note :

RMagick does not automatically remove profiles when resizing images. If you are trying to make your JPEG thumbnail images as small as possible, use profile! to remove any profiles from the image as well.

And there is one more method called "strip!" strips an image of all profiles and comments.

image.strip!

This will Strip an image of all profiles and comments.

UJS for Rails

noreply@blogger.com (Arunkumar) — Thu, 28 Jun 2007 22:29:00 +0000

Unobtrusive Javascript for Ruby On Rails

UJS for Rails makes it easy to apply behaviour to your page. Simply specify the element(s) of your page that you want the behaviour to apply to using CSS-style selectors and the event that you want to trigger the behaviour, and the Javascript that you want to run. In addition, you can write your behaviours using RJS-style Ruby to Javascript proxies.

Installation

You can install the UJS plugin from our Subversion repository with Rails’ plugin script:

ruby script/plugin install http://source.ujs4rails.com/current/unobtrusive_javascript

After Installing the plugin, run the following command

rake unobtrusive_javascript:install

If  "lowpro.js" is copied to your system means, installation is perfect...otherwise
please do the installation again :)

Once you’ve confirmed that lowpro.js is installed, the final
installation step is to open your routes.rb file and add the following
line into the Routes.draw block

ActionController::Routes.draw do |map|
UJS::routes
# your routes here.
end

Including The Scripts

Simply use javascript_include_tag to add the UJS scripts into the document’s head tag as shown:

<%= javascript_include_tag 'prototype', :unobtrusive %>

You can safely use :defaults and :unobtrusive together in the same javascript_include_tag call.

Applying Behaviours

`apply_behaviour(css_selector, javascript, options={})`

The first argument of apply_behaviours is an event:Selectors style selector that specifies both the CSS selector for the elements to target and the event to attach the behaviour to in this format: css_selector:event

The second argument is the behavior to apply. Pass a string to specify the JavaScript code to execute directly. There are two variables available to the behaviour JavaScript. In the JavaScript code, this refers to the triggering element and event refers to the JavaScript event object.

For Documentation, please refer this url -

http://www.ujs4rails.com/resources/usage-documentation

Note: UJS (and the lowpro extensions) requires at least Prototype 1.5.0 RC0.

finder_sql in HABTM

noreply@blogger.com (Arunkumar) — Tue, 19 Jun 2007 20:56:00 +0000

Using this "finder_sql", you can override ActiveRecord's associations in your models. Use it to manually specify the association that should be returned.

Important Note: if you need to do any variable interpolation in the string , make sure to use single quotes instead of the usual doubles:

has_many :books, :finder_sql => 'select * from books where author_id=#{id}'

When you use double quotes, the string interpolation happens immediately (when the class is first loaded), thus obtaining the object ID of the class in memory. Using single quotes, the interpolation occurs within the context of your object instance, which is what you're expecting.

Enjoy Agile Programming!!!

Safari for Windows

noreply@blogger.com (Arunkumar) — Tue, 12 Jun 2007 18:16:00 +0000

Apple is releasing the public beta of Safari for Windows today.

Steve gave demos of Safari, claiming that it screams:

ibench html performance: IE 4.6 sec, FF 3.7, Safari 2.2 seconds
javascript: IE 2.4 sec, FF 1.6, Safari 0.9 seconds

Safari has always been the fastest browser on the Mac and now it’s the fastest browser on Windows, loading and drawing web pages up to twice as fast as Microsoft Internet Explorer 7 and up to 1.6 times faster than Mozilla Firefox 2.

Google Gears

noreply@blogger.com (Arunkumar) — Mon, 11 Jun 2007 16:46:00 +0000

Google announced an early beta of Gears, a "browser extension that enables web applications to provide offline functionality using following JavaScript APIs:

Store and serve application resources locally
Store data locally in a fully-searchable relational database
Run asynchronous Javascript to improve application responsiveness"

Google Gears is an open source browser extension that lets developers create web applications that can run offline. Gears provides three key features:

A local server, to cache and serve application resources (HTML, JavaScript, images, etc.) without needing to contact a server
A database, to store and access data from within the browser
A worker thread pool, to make web applications more responsive by performing expensive operations in the background

Google Gears is currently an early-access developers' release. It is not yet intended for use by real users in production applications at this time.

Google Gears extends browsers by making new APIs available to JavaScript code. Like all APIs, they must be used explicitly. To take advantage of the offline features provided by Google Gears, you'll need to add or change code in your web application.

Only web sites that have been specifically designed to use Google Gears can take advantage of its offline capabilities.

Rails Rake Tasks Reference

noreply@blogger.com (Arunkumar) — Fri, 01 Jun 2007 17:18:00 +0000

rake cache:clear
# Clears all cached pages
rake db:bootstrap      
# Loads a schema.rb file into the database and then loads the initial database fixtures.
rake db:bootstrap:copy_default_theme
# Copy default theme to site theme
rake db:migrate
# Migrate the database through scripts in db/migrate. Target specific version with VERSION=x
rake db:schema:dump
# Create a db/schema.rb file that can be portably used against any DB supported by AR
rake db:schema:load
# Load a schema.rb file into the database
rake db:bootstrap:load
# Load initial database fixtures (in db/bootstrap/*.yml) into the current environment's database.  Load specific fixtures using FIXTURES=x,y
rake db:fixtures:load
# Load fixtures into the current environment's database.  Load specific fixtures using FIXTURES=x,y
rake db:sessions:clear
# Clear the sessions table
rake db:sessions:create
# Creates a sessions table for use with CGI::Session::ActiveRecordStore
rake db:structure:dump
# Dump the database structure to a SQL file
rake db:test:clone
# Recreate the test database from the current environment's database schema
rake db:test:clone_structure
# Recreate the test databases from the development structure
rake db:test:prepare
# Prepare the test database and load the schema
rake db:test:purge
# Empty the test database
rake deploy
# Push the latest revision into production using the release manager
rake diff_from_last_deploy
# Describe the differences between HEAD and the last production release
rake doc:app
# Build the app HTML Files
rake doc:clobber_app
# Remove rdoc products
rake doc:clobber_plugins
# Remove plugin documentation
rake doc:clobber_rails
# Remove rdoc products
rake doc:plugins
# Generate documation for all installed plugins
rake doc:rails
# Build the rails HTML Files
rake doc:reapp
# Force a rebuild of the RDOC files
rake doc:rerails
# Force a rebuild of the RDOC files
rake edge
# freeze rails edge
rake log:clear
# Truncates all *.log files in log/ to zero bytes
rake rails:freeze:edge
# Lock to latest Edge Rails or a specific revision with REVISION=X (ex: REVISION=4021) or a tag with TAG=Y (ex: TAG=rel_1-1-0)
rake rails:freeze:gems
# Lock this application to the current gems (by unpacking them into vendor/rails)
rake rails:unfreeze
# Unlock this application from freeze of gems or edge and return to a fluid use of system gems
rake rails:update
# Update both configs, scripts and public/javascripts from Rails
rake rails:update:configs
# Update config/boot.rb from your current rails install
rake rails:update:javascripts
# Update your javascripts from your current rails install
rake rails:update:scripts
# Add new scripts to the application script/ directory
rake remote_exec
# Execute a specific action using the release manager
rake rollback
# Rollback to the release before the current release in production
rake show_deploy_tasks
# Enumerate all available deployment tasks
rake stats
# Report code statistics (KLOCs, etc) from the application
rake test                           
# Test all units and functionals
rake test:functionals                 
# Run tests for functionalsdb:test:prepare
rake test:integration               
# Run tests for integrationdb:test:prepare
rake test:plugins                     
# Run tests for pluginsenvironment
rake test:recent                    
# Run tests for recentdb:test:prepare
rake test:uncommitted                 
# Run tests for uncommitteddb:test:prepare
rake test:units                     
# Run tests for unitsdb:test:prepare
rake tmp:cache:clear                
# Clears all files and directories in tmp/cache
rake tmp:clear                        
# Clear session, cache, and socket files from tmp/
rake tmp:create                       
# Creates tmp directories for sessions, cache, and sockets
rake tmp:pids:clear                   
# Clears all files in tmp/pids
rake tmp:sessions:clear               
# Clears all files in tmp/sessions
rake tmp:sockets:clear              
# Clears all files in tmp/sockets
rake update_dialog_helper           
# Copies the latest dialog.js to the application's public directory

Why FLEX?

noreply@blogger.com (Arunkumar) — Fri, 25 May 2007 03:29:00 +0000

Reasons made me to choose FLEX :

i. look and feel of a desktop application. Because there is no page reload.

ii. Reduction in Server Load and Network Bandwidth

iii. Common Deployment Environment

Some or all of the presentation tier of a flex application runs in flash player itself. It runs in the Client side which means “ no application server processing resources are spent for data formatting”.

By Off loading the presentation logic to the client side flash player, and eliminating the need for frequent page refreshes. Flex applications minimizes the network traffic and server load.

Common Deployment Environment:

Flex applications execute on flash players which are platform independent, so customer do not need to install any custom client software. Also flash player runs consistently in all browsers and platforms. So you don’t have to worry about the problems like inconsistent behaviors in different client environments.

Flex - RPC

noreply@blogger.com (Arunkumar) — Fri, 25 May 2007 03:28:00 +0000

Remote Procedure Call Services:

RPC services let your flex application to interact with the remote servers to provide data to your application or for your application to send data to the server.

Using Flex SDK, you can access the remote data through web services like SOAP or normal HTTP services like GET or POST requests.

For security, by default flash player doesn’t allow an application to access a remote data source from a domain other than the domain from which the application was served.

Therefore a remote server must either be in the same domain as the server hosting your application or the remote server must define a crossdomain.xml file.

Crossdomain.xml file is an xml file that provides access to swf files from certain domains or from all domains.

Flex - Power of RIA

noreply@blogger.com (Arunkumar) — Fri, 25 May 2007 03:26:00 +0000

What is flex?

Flex is a development and runtime environment that you use to create rich internet applications that use adobe flash player 9.

Flex is an adobe technology.

Using flex, you can design, develop and deliver entirely new class of RIAs.

Flex lets the developers familiar with the server side technologies to build rich front end for applications.

While executing in flash player, your flex application can interact with the server side functionality such as databases, web services, java objects (data models) and other server side services.

In Flex, You use a standards based programming model to develop an application. So you have to describe the user interface and configure the user interface controls and define the data bindings.

Flex Application Development Methodology:

Design
Compile
Run

Design:

Design part consists of flex class libraries, MXML, Action Script, CSS and other imported files like images, swf files.

Compile:

When compiling the application, all the source code will be converted in to Action script classes. So everything here is AS classes.

Run:

The final output is a SWF file where your application resides.

You can embed this swf file into a normal html file to run your flex application.

How to use Capistrano

noreply@blogger.com (Arunkumar) — Wed, 25 Apr 2007 15:22:00 +0000

Capistrano is a simple but a powerful deployment tool...

To use Capistrano for deployment, please read the following lines

(Note : Instructions are given for ROR development. )

1. Install Capistrano Gem

"gem install capistrano"

2. Run this command from your local system

"cap --apply-to /path/to/your/app YourApplicationName"

3. Execute the setup task

"rake remote:setup"

this command will setup the directory structure to deploy...

4. Execute the cold_deploy task

"rake remote:cold_deploy"

this command will run, deploy your application to the server...

Now Your application will run

Once you’ve finished the above, your server is ready to have new versions of your
application deployed to it anytime you would like. All you need to do is commiting your changes into Subversion and then redeploy using the following command on your local computer

"rake remote:deploy"

Capistrano OVER....

you can see "how to write capistrano task" in coming posts.

Nice Web 2.0 App

noreply@blogger.com (Arunkumar) — Fri, 23 Mar 2007 05:59:00 +0000

check this link

http://color.slightlyblue.com/

Rails Ajax rating system (Part 1)

noreply@blogger.com (Arunkumar) — Tue, 20 Mar 2007 12:38:00 +0000

Adds rating capabilities to any ActiveRecord object. It has the ability to work with objects that have or don ’t special fields to keep a tally of the ratings and number of votes for each object. In addition it will by default use the User model as the rater object and keep the ratings per-user. It can be configured to use another class...

read more | digg story

Validating XHTML and CSS

noreply@blogger.com (Arunkumar) — Wed, 28 Feb 2007 05:14:00 +0000

Validating an XHTML document's content involves checking its markup against a DTD and reporting markup errors. You can validate HTML, XHTML, and CSS files by using the W3C's validator. It will allow you to validate files on the Internet or on your computer.

The validator program will go through your coding, find any errors, and create a report. You can then "clean up" your coding and validate again. This service is free.

http://validator.w3.org/

You can also check your external CSS pages through the CSS validator ...

http://jigsaw.w3.org/css-validator/

Once validated as well formed coding, the bottom of the report page will show an icon image that you may display on your page such as the ones you see in the right side column of my site. Display it with pride!

XHTML Doc Types

noreply@blogger.com (Arunkumar) — Wed, 28 Feb 2007 05:11:00 +0000

There are 3 Doctypes usable by an XHTML document. Strict, Transitional, and Frameset. The doctype is used when validating an XHTML document's content against a DTD and reporting markup errors. (The DOCTYPE lines below are broken in parts only to prevent the examples from being too wide for non-horizontal scrolling - you can keep it all on one line).

XHTML 1.0 Strict

Use this when you want really clean markup, free of presentational clutter. Use this together with Cascading Style Sheets.

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

XHTML 1.0 Transitional

Use this when you need to take advantage of HTML's presentational features because many of your readers don't have the latest browsers that understand Cascading Style Sheets.

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

XHTML 1.0 Frameset

Use this when you want to use HTML Frames to partition the browser window into two or more frames.

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">

Reserved Words in MYSQL

noreply@blogger.com (Arunkumar) — Wed, 28 Feb 2007 04:39:00 +0000

In MYSQL, There is a number of words that you cannot use for your table and column names. MySQL uses some specific words for command processing, so using them in your own coding may confuse things a bit.

ADD ALL ALTER
ANALYZE AND AS
ASC ASENSITIVE AUTO_INCREMENT
BDB BEFORE BERKELEYDB
BETWEEN BIGINT BINARY
BLOB BOTH BY
CALL CASCADE CASE
CHANGE CHAR CHARACTER
CHECK COLLATE COLUMN
COLUMNS CONDITION CONNECTION
CONSTRAINT CONTINUE CREATE
CROSS CURRENT_DATE CURRENT_TIME
CURRENT_TIMESTAMP CURSOR DATABASE
DATABASES DAY_HOUR DAY_MICROSECOND
DAY_MINUTE DAY_SECOND DEC
DECIMAL DECLARE DEFAULT
DELAYED DELETE DESC
DESCRIBE DETERMINISTIC DISTINCT
DISTINCTROW DIV DOUBLE
DROP ELSE ELSEIF
ENCLOSED ESCAPED EXISTS
EXIT EXPLAIN FALSE
FETCH FIELDS FLOAT
FOR FORCE FOREIGN
FOUND FRAC_SECOND FROM
FULLTEXT GRANT GROUP
HAVING HIGH_PRIORITY HOUR_MICROSECOND
HOUR_MINUTE HOUR_SECOND IF
IGNORE IN INDEX
INFILE INNER INNODB
INOUT INSENSITIVE INSERT
INT INTEGER INTERVAL
INTO IO_THREAD IS
ITERATE JOIN KEY
KEYS KILL LEADING
LEAVE LEFT LIKE
LIMIT LINES LOAD
LOCALTIME LOCALTIMESTAMP LOCK
LONG LONGBLOB LONGTEXT
LOOP LOW_PRIORITY MASTER_SERVER_ID
MATCH MEDIUMBLOB MEDIUMINT
MEDIUMTEXT MIDDLEINT MINUTE_MICROSECOND
MINUTE_SECOND MOD NATURAL
NOT NO_WRITE_TO_BINLOG NULL
NUMERIC ON OPTIMIZE
OPTION OPTIONALLY OR
ORDER OUT OUTER
OUTFILE PRECISION PRIMARY
PRIVILEGES PROCEDURE PURGE
READ REAL REFERENCES
REGEXP RENAME REPEAT
REPLACE REQUIRE RESTRICT
RETURN REVOKE RIGHT
RLIKE SECOND_MICROSECOND SELECT
SENSITIVE SEPARATOR SET
SHOW SMALLINT SOME
SONAME SPATIAL SPECIFIC
SQL SQLEXCEPTION SQLSTATE
SQLWARNING SQL_BIG_RESULT SQL_CALC_FOUND_ROWS
SQL_SMALL_RESULT SQL_TSI_DAY SQL_TSI_FRAC_SECOND
SQL_TSI_HOUR SQL_TSI_MINUTE SQL_TSI_MONTH
SQL_TSI_QUARTER SQL_TSI_SECOND SQL_TSI_WEEK
SQL_TSI_YEAR SSL STARTING
STRAIGHT_JOIN STRIPED TABLE
TABLES TERMINATED THEN
TIMESTAMPADD TIMESTAMPDIFF TINYBLOB
TINYINT TINYTEXT TO
TRAILING TRUE UNDO
UNION UNIQUE UNLOCK
UNSIGNED UPDATE USAGE
USE USER_RESOURCES USING
UTC_DATE UTC_TIME UTC_TIMESTAMP
VALUES VARBINARY VARCHAR
VARCHARACTER VARYING WHEN
WHERE WHILE WITH
WRITE XOR YEAR_MONTH
ZEROFILL

What is XML, DTD and XSLT?

noreply@blogger.com (Arunkumar) — Mon, 19 Feb 2007 13:10:00 +0000

All these letters, abbreviations, meanings and so forth. What do they all mean and how do we use them? Here are some basics breakdown :

First we will start at the top. The VERY top. SGML stands for Standard Generalized Markup Language. Simply put, it is the very root coding of coding. HTML is an application of SGML.

XML is a simplified subset of SGML. It stands for eXtensible Markup Language.

DTD stands for Document Type Declaration. It is a set of instructions that states what tags are usable and what (re)action they create. Each browser has a DTD set in it's programming set by the browser companies. This is how some tags will work in only one type of browser or version. It has the tags stated in it's DTD. XML makes it possible to create unique tag sets by applying it's own DTD. This makes the DTD more compatable with more browsers.

XSLT stands for eXtensible Stylesheet Language Transformation. It is a strong verions of CSS that formats the XML page for viewing.

XHTML

noreply@blogger.com (Arunkumar) — Mon, 19 Feb 2007 13:09:00 +0000

What is XHTML?

* XHTML stands for eXtensible Hyper Text Markup Language.
* It is aimed to replace HTML.
* It is almost identical to HTML 4.01
* It is the reformulation of HTML 4.01 as an application of XML.
* It is a stricter, tidier version of HTML.

XHTML 1.0 is the next level of coding as specified by the W3C.

XHTML is a transition / combination of HTML and XML. To change from HTML to XHTML requires just a few changes in your coding styles. The main page to check out is CONVERTING but all the others provide valuable information about this coding technique as well.

XHTML provides the framework for future extensions of HTML and aims to replace HTML in the future. Some resources refer to XHTML as HTML5.

XHTML 1.0 became an official W3C recommendation on January 26, 2000. A W3C recommendation means that the specification is stable, that it has been reviewed by the W3C membership, and that the specification is now a Web standard.

XHTML 1.0 is the first step toward a modular and extensible web environment based on XML (eXtensible Markup Language). It provides the bridge for web designers to use a future based coding and still be able to maintain compatibility with today's browsers.

SGML stands for Standard Generalized Markup Language. Simply put, it is the very root coding of coding. HTML is an application of SGML. XML is a simplified subset of SGML.

DTD stands for Document Type Declaration. It is a set of instructions that states what tags are usable and what (re)action they create. Each browser has a DTD set in it's programming set by the browser companies. This is how some tags will work in only one type of browser or version. It has the tags stated in it's DTD. XML makes it possible to create unique tag sets by applying it's own DTD. This makes the DTD more compatable with more browsers.

ruby-mp3info gem patch

noreply@blogger.com (Arunkumar) — Sat, 17 Feb 2007 13:40:00 +0000

IF you are using the gem "ruby-mp3info", it will work well in windows. but in linux, it wont. Coz mp3info will throw errors on 64 bit versions of Ruby.

To clear this problem, you have to apply the following patch which allows mp3info to work on 64 bit versions of Ruby...

Remove the NumericBits module from extension_modules.rb.
Remove "head.extend(NumericBits)" from mp3info.rb
Add this to the top of mp3info.rb

-class Bignum
- def bits(b, a)
- t = 0
- b.downto(a){ |i| t += t + self[i] }
- t
- end
-end

And the most important point is

you have to include "rubygems" while including "mp3info"
like this

require "rubygems"
require "mp3info"

otherwise it will throw "no such file to load" error....