We now check if the book titles are deleted from the first and end of the list which should give us ‘nil’ when and if the list becomes void of contents.

list.deleteFirst >> Books: ABDC–Author1 (1)
list.deleteFirst >> Books: EFGH–Author2 (2)
list.deleteLast >> Books: MNOP–Author1 (1)
list.deleteLast >> Books: IJKL–Author3 (3)
list.deleteLast >> nil

We now include the use of the square brackets which allows us to acces the specific elements by the index instead of having to define each item specifically.

class BookList
def[](key)
if key.kind_of?(Integer)
@Books[key]
else
# …
end
end
end

Testing the code is also very straightforward:

list[0] >> Books: ABCD — Author1 (1)
list[2] >> Books: IJKL — Author (3)
list[9] >> nil

The next posts will add more functions and operators to further simplify our code making it shorter and making you more familiar with the syntax of Ruby.

Using the append command/method, we can add an element to the end of the table which in turn returns a reference to the current BookList object.The deleteFirst and deleteLast command allows us to delete the first and last records respectively in the following form/s:

For Append:
class BookList
def append(aBook)
@books.push(aBook)
self
end
end

For deleteFirst and deleteLast

class BookList
def deleteFirts
@books.shift
end
def deleteLast
@books.pop
end
end

Now we test the code we have just created to show if the right operations are being performed and if we are getting the results we desire:

list = BookList.new
list.
append(Books.new(‘ABCD’, ‘Author1′,1)).
append(Books.new(‘EFGH’, ‘Author2′,2)).
append(Books.new(‘IJKL’, ‘Author3′,3)).
append(Books.new(‘MNOP’, ‘Author4′,4))

In the next posts, we get to check and simplify the code we have just executed.

In the last post, we created arrays and showed how the various elements could be accessed or the contents changed. Now, we will create empty arrays which would be useful for easy tracing of code when you start building whole projects. To create an empty array with no elements or by using the array object’s constructor ( a detailed discussion on constructors is available in the link). Sample empty array creation, ” empty1=[] empty 2 = Array.new “. To shorten the process of creating arrays there is the %w it’s use is shown below.

z = %w {Honda Toyota Mazda Ford Chevrolet Mercedes}
z=[3] >> “Mazda”
z=[6} >> “Mercedes”

In the next post, we will turn to hashes which is also a form of table.

An array is a table or indexed collection that needs an integer key to point to a specific set of information contained within the said table. A hash on the other hand, supports any object as a key meaning it can be numeric, character or alphanumeric to name some. To initiate a new array you need to use a new array literal which is a set of elements contained between two square brackets (“[ ]“) an example of which is shown below.

b = [5, 'mouse', 'deer', 2.54] # array with four elements
# to access the first element (array content)
b[0] >gives you the value or content of position 0 > 1
# to change the contents of the fourth element
b[4] = nil
# to show all the contents of the array
b >> [5, 'mouse', 'deer', nil]

Arrays and hashes grow exponentially to house elements that are to be contained within them. In the next posts we would create empty arrays and show a shortcut to the array creation syntax.

Now, for those who do not have any idea what we are doing as of now, better begin again from the start. The term “Easy to Learn” doesn’t mean that you get all the stuff into your head in a couple of minutes. While it is true that there are several claims of getting you to program in as little as 15 minutes with their guides, there is truly more to the said programming stuff such as lingo and naming conventions that are used in programming. Now assuming you do not know anything, anything at all about programming try reading through several resources such as “The Pragmatic Programming Guide for Ruby on Rails” from Ruby Org and many other resources that offer the basics from the beginning.

True programming goes with the learning curve of making and discovering why mistakes were made and correcting them. Being object oriented, all declarations and almost all of the stuff you make with Ruby on Rails is going to become an object which makes it easy to understand and troubleshoot. Learning to program is a step by step process and our aim is to get you slowly and pointed in the right direction.

Ruby on rails can be downloaded from many sources over the internet like from http://api.rubyonrails.org/ where there are also instructions on how to quickly install and start programming. The first lessons would be the forever basic “Hello World” program which is very easy if you get set-up right. For a more automated installation you could also check-out Instant Rails or Locomotive for users on the Mac platform.
An example of the shortest way to get from installation to your first application would be;
alias rails_hello_world=’rails hello && cd hello && ./script/generate controller welcome hello && echo “Hello World” > app/views/welcome/hello.rhtml && ./script/server -d && firefox 0.0.0.0:3000/welcome/hello’. The code was compliments of ReinH. In the following posts we would start with the declarations and other basic stuff that will get us on the right track to making more complicated procedures.

Once you have successfully installed and tried that the install was a success through the Hello World program. You now begin building projects with the following syntax : “rails ProjectName”. You then start the WeBrick webserver with “cd ProjectName enter ./script/server”. The above procedures invoke the interpreter which may be required on some platforms as a must. As we can see clearly, even on the beginning parts of learning the said language, most have to be defined as objects. Don’t worry for there are tons of free apps you can get from the web through many resource pages and users like you in the forums from all over.

Before we jump into the programming itself, let us learn some of the so-called weak points that you might be able to consider and improve on ( or even share) with others out there to make the platform a better one.
First is speed, the information that I might have come upon may be a bit outdated but it still shows a significant disadvantage when it comes to speed of processing as compared to other more stable platforms. The use of green threads is also subject to criticism by many making it very difficult or unstable in certain user-case scenarios. Unicode or multi-byte string support is not yet native and the use of global variables is the biggest pitfall so far known. This trait unfortunately allows global variables to be modified from anywhere and we mean anywhere. Ruby also lacks a well-defined specification with it being referred to as an implementation of C. Most of these issues have been thought of and are to be addressed in the coming release of the newest versions of the programming language.

Blocks or simply chunks of code as in the last example may be existing variables which changes after that same variable passes thought the block, giving it a new value. Blocks may also be used to return a needed value to the method as in the last example, the resulting value of the last expression the data was exposed to was returned back to the method as the pre-set value of the yield statement till the condition which was the set maximum value of the Fibonacci Series that was set to 1000. This is why the find method which is used for array class objects work. The method find is actually defined in the enumerable module thrown into the array class mix. The Next Post, shows a sample code using the find method.

Sample Code using find :

class Array
def find
for a in 0…size
value = himself[a]
return value in yield(value)
end
return nil
end
end
[1, 3, 5, 7, 9].find {|v| v*v >30}

The code has elements passed successively to the attached block which returns true if the method sends in a corresponding element. If none match, then nil is returned which is a very good example of how to best utilize iterators. The Array class is simply doing what it was designed to which is to access the contents of an array leaving the application to do what it is supposed to do which in this case is to find entries that satisfies a set criteria.

After it goes through the block, the file is closed taking with it the results of the block’s transactional process. This is something that should be done with all programming languages, to have the code have their own built-in file handling system which ensures that a file once opened is closed upon exit to avoid destroying the contents of that file. This shows the two forms the File.open method’s behavior can be called upon, that if it is called with a block it does what it has to and then automatically closes the file. Called on without the block and it returns the file object.