The next phase or step would be to create a database for the application to use. Make sure the MySql engine is running and in the command window type “mysql -u root -p” and press enter and another enter for the password when prompted for there has not been any defined password yet. You are now logged into the engine as the root user and proceed to create the database by entering the following command “create database filename_development”. Also type in “grant all on filename_development.* to ‘ODBC’@'localhost’ this tells windows to grant access to a user named ODBC so you avoid an error when you try to access the said database from the command prompt. We next tackle the creation of tables that would allow the database to store the information we send it.

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
}

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

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.

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