Image Source: www.web2.socialcomputingmagazine.com

Ruby on Rails is great for acquiring ideas prototyped super quick. These tips will slow down growth and make apps less portable, but definitely progress the speed your system
Ruby on rails coding style:
• Try to evade the over indulgence use of helpers since it adds overhead.
• You may think about using memcached to cache your model and library computation results.
• Use a custom configuration file for passwords and API keys instead of keeping them in your Subversion repository. Use YAML and mirror the style of database.yml.
• Use constants when desired. Instead of repeating strings like the address of your customer service reply email, set it once in a constant (in environment.rb or the appropriate environment file) and use that throughout your application.
• Keep time in UTC. A no brainer, and easy to do.
• Don’t loop through ActiveRecord models inside other models. Use keen loading if you need to exertion with multiple associated models. Better yet, write a custom SQL query and let the database do the work for you.

The caret “^” and the “&” operators are used for matching the beginning of a string, and also for the end of a string shown below:

matching =/[a-e]$/

The script would look for similar letters between “a” and “e” respectively including the end of the string. To search for a letter inside a string:

[A-Z] all uppercase letters
[a-z] all lowercase letters
[0-9] all digits(numbers)

To restrict the range, say to look for only the letters between “a” and “e”, you write it as [a-e] combined with the caret operator shown below:

[^A-Z] all other characters except uppercase letters
[^a-z] all other characters except lowercase letters
[^A-Za-z] no letters, whether upper or lower case

Unless is another control structure similar to “if..else’ that is for conditional processing and it is used as follows:

unless condition
instruction1
else
instruction2
end

Again, it uses the “end” statement to terminate the control structure. The “case”, control is more of a screening process that allows say the element of an array or hash to be evaluated to meet a specific set of conditions. It is used as follows:

case variable
when condition1
instruction1
when condition2
instruction2
……
……
when conditionX
instructionX
else instructionA
end

if condition1 (is true)
instruction a
instruction b
.
.
instructionX
elseif condition2 (if the condtition 1 returns false evaluate with condition2)
instruction c
instruction d
.
.
instructionX
else (if the result is false for both levels then the following code is executed)
instruction e
instruction f
.
.
instructionX
end

The control structure evaluates the necessary ‘contition1′, if it returns true if executes instructions that follow the if statement. If it is false, it proceeds to the elseif using ‘condition2′ to evaluate it, if it satisfies condition2, then it executes code that immediately follows the elseif control. If both evaluations return false, it then proceeds to execute the instructions after the else control.

Control structures are blocks of code that result in either a true or false and are more commonly called loops. Loops are dependent on the satisfaction of certain conditions like in the sample program below that uses the “if..else control(loop):

if condition1 (if condition 1 is true)
instruction 1
instruction 2
.
.
instructionX
else (if condition 1 is false)
instruction 3
instruction 4
.
.
instructionX
end

As you can see, the simplicity of Ruby has it working without the need for the curly braces as with C++. Ruby simply uses the “end” keyword to signify the end of the “if..else” control structure. Another way of doing the same thing but with more conditional procesing is with the the “if..elseif..else” control structure. Syntax is shown in the following post.

A function is a way of shortening repetitive parts or blocks of code that are called again and again. Their use benefits the user by first of course, shortening the amount of code lines for having the same block of code appearing again and again wastes time and effort. It also allows the same block of code to be accessed by more than one program. It allows the programmer to break up complex tasks into smaller applications that are easily understood, and last, it allows the programmer to create and hide critical functions such as password and username encryption and decryption routines. Functions are mostly user defined but there are a couple of dozen or so that have been pre-defined and are included in the standard Ruby distribution package. Being open sourced, there are a whole range of functions that have been created and shared by the many ruby programmers out there that is shared across the whole globe.

Ranges can be better defined as a numeric array. Ranges can be defined as such:

numrange = 1..20 (numrange holds all the numbers between 1 and 20, effectively turning it into an array)
numrange2 = 1…20 (is another way of defining ranges, holding all numbers between 1 and 20 except the last number 20)

As with previous arrays and hashes, several operations can be done on them like:

puts numrange.min (gives you the lowest number in the specified range)
puts numrange.maxn (gives you the highest number in the specified range)

To check if a specified number is part of the range

numrange.include? (14)

To show the contents of the specified range:

puts numrange.to_a

Top find out what each key in the hash is associated with :

salad['green salad'] => “lettuce and sweet basil”

As with arrays, there are a lot of useful methods in creating them.

salad.empty? (to check if the hash is empty)
salad.size (to check for the number of elements in the hash)
salad.keys (to get all the keys in the hash to create an array)
salad.values (to get the keys in the form of an array but not necessarily in the order they’ve been entered in the hash)

All the above operations are built-in methods that are used for such purposes.

Hashes are simply arrays that link one object to another object (think of it as an association of sorts), say like Spagthetti_sauce which is part of the complete menu, referring to the hash Spaghetti_sauce gives you the ingredients. Same as with arrays, they are created with the “.new” method resulting in an empty hash.

salad = Hash.new

Using curly braces, you get to assign the hash its elements like the example shown below:

salad = {
green salad => ‘lettuce and sweet basil’
coleslaw => ’shredded lettuce, garlic and onions, carrots’
garden fresh => ‘cherry tomatoes, lettuce, iceberg, iceberg lettuce, mayonnaise, olive oil, lemons
}

You now have an array named “Spaghetti_sauce”, that contains those elements. You can also assign multiple values into several elements with the following instruction:

Spaghetti_sauce = %w[ground pork, ground beef, tomato sauce, garlic, pepper, onions, salt, olive oil]

You end up with the same array we started with that has all the elements stored within it. There are a couple of easy ways to use and manipulate arrays such as for checking if it is empty, you simply use the following command:

Spaghetti Sauce.empty?

Checking for the total number of elements you do:

Spaghetti_sauce.size

or

puts Spaghetti_sauce.size

You can also delet elements from arrays with the delete nethod :

Spaghetti_sauce.delete “ground beef”

Looking for the first or last element you use the “.first” and “.last” method shown below :

Spaghetti_sauce.first
Spaghetti_sauce.last

If you have an unknown data structure and you want to check if it is indeed an array, you simply use the “.type” method. The “class” method is better than the “.type” method for it gives you a verbose warning.

puts Spaghetti_sauce.type (to check if the array is indeed an array)
puts Spaghetti_sauce.class (more verbose way of checking that returns an error message)

arrays also have the nift anility to store elements of different data types like characters, strings and numbers shown below:

sauce = [ 'h', 'and', 'r', '@', 20]