What is Ruby on Rails ?

Ruby, as you may know, is a very well known scripting language, with an exceptional and clean syntax. I’ve always been a fan of Python and i must say that moving to Ruby is a totally different programming style. Luckily, learning Ruby is quite easy. It indeed offers some very good techniques, like code blocks etc, but overall, it resembles interpreted language, like Python and Perl also are.

On the other side, Ruby on Rails is something completely different and harder to learn. RoR (widely used for Ruby on Rails), is actually a framework for creating web applications. As simple as that. You may already know the Django alternative for Python. Sounds … ok, but is it just that ?

Why Ruby on Rails is Really Really Good

RoR is really great because it makes the life of the programmer a WHOLE lot easier. Imagine that you wanted to write a php function that checks whether  passwords match in a simple registration routine. Using php, you would need to get the input, compare it and write an html page that presents the error to the user. Lots of work for doing a simple thing. But with ruby :

validates_confirmation_of :password

is just enough !

Installation of RoR

Installing RoR is a pretty easy procedure for the well known operating systems. There is an installer for Windows, you can use a package manager for Linux and macports for mac OS (as i currently use). For more information on the whole process, please take a look at the official ruby programming website.

The MVC (Model - View - Controller) Model.

MVC is the programming model that RoR utilizes. If you have used a templating system like smarty in the past, you have most probably already used the model. This model simply identifies that our web program has 3 different entities that we need to look after. The model, the view and the controller. But, what is the difference ? Now, i could describe that in words, but i prefer providing an example as well :

The View is the easy entity. It is what our program prints out to the browser of a user.

The Controller closely relates to data. It is the part where data is initialized, to be then provided to the View and shown to the user.

The Model is the auxiliary entity where we write our large functions that operate on data.

Now, think of this situation. You have a page that presents some products for people to buy. The Controller is the first thing that gets utilized. Once the browser requests the page, the controller takes action. Therefore, when the products page is requested, the Controller understands that this page was called and provides the gateway between your large functions and your view. Now, the Model contains functions such as getAllProducts(). This function is called by the controller, to provide an instance of all the products. This variable, most times a class variable like @products, is going to be used in the view.

Hope this starts to make sense, i've tried to describe it to the best of my knowledge. I do not want to take this post any further. In my next one about RoR, i will describe how to create a test project, use migrations and more. Have fun with Ruby, play a little bit with it, it is really worth it, you have my word !

Have you by any chance taken a look at the python online challenge ? This is a great series of 33 Python Programming levels that require great Python knowledge in order to be solved. In the past i’ve solved a bunch of them, but never really went as far as completing the whole nine yards.

Therefore, i was thinking that it would be a quite good idea to create a section at the codercaste.com forum, where we would not only talk about those challenges, but more importantly solve them together. This way, we would learn more about Python and not alone. I’ve noticed that some of the levels can also be done easier using some unix tools or so. We will discuss that as well.

What do you think about that ? Would you participate ? I think that i will create this section pretty soon, so if you want to do so, please take a moment to join the codercaste.com forum.

And let’s have fun !

A Virtual Private Network is a way to access a private network (your office lan in this occasion) through a larger network (the internet in this and actually most cases). What you would do in this occasion is install openvpn in both your computers and set your office computer to be the server and your home computer to be the client. Let’s take a look on the steps that you need to take in order to create the vpn.

Generate The Master CA certificate, the Server Certificate and The Clients Certificates

After you install openVPN on your machines (installation is trivial, there are packages available or you can even compile from sources), go to your server and locate the openVPN configuration files. It should be under /etc/openvpn/. Inside the easy-keys/2.0/ directory, execute these commands to initialize the Public Key Infrastructure :

./vars
./clean-all
./build-ca

After executing build-ca, you will be asked for some information. Changing the Common Name is a good idea if you like to. You can leave the rest as they are. After completion, the Master CA Certificate is now generated.

Let’s now generate the certificate and private keys for our server, using the command :

./build-key-server server

Sign and commit the certificate, while also provide a meaningfull Common Name, like “officeServer”. Our server is set and we just need to configure our client(s).  Again, this is almost the same as the server key and certificate generation :

build-key homeClient

You could create more clients if you like, but in this case we just need one for our home. In the end, you also need to generate the Diffie-Hellman public key scheme parameters using :

build-dh

This will create a *.pem file that we need for our server. In the end of the process, you will have a bunch of different files in easy-keys/2.0/ . The ca.crt file is needed by both the server and the client(s), it is the master certificate. The server has 3 more files. The *.pem file, the server.crt and server.key file (or however you named them). A client has 2 files, the client.crt and client.key file.

The next thing that you would need to do is create a tarball with the client files, client.crt, client.key AND the ca.crt, which is needed by every computer.

Sample Configuration Files For OpenVPN Clients and Server

Now, both your server and client(s) need to have config files in /etc/openvpn/ . This is actually pretty easy to do and you can follow the official openvpn sample files to do so. Once you’re done, just restart both openvpns using “/etc/init.d/openvpn restart” and your virtual private network is now working !

func = lambda x: x + 2
print func(4)

Upon execution, this prints the number 6 on your screen. Quite simply, we create a lambda function that gets a parameter and returns this integer parameter after adding 2 to it. Notice the syntax here. “lambda x: x + 2″. If this was a standard Python function, the code would be like :

def myfunc(x):
  return x + 2

Notice the differences ? As you see, a lambda function is a way to create a simple function quickly, without having to define it as usual. You may wonder why a lambda function can be important, but this is easily identified if you think of a function like map or filter in python.

Use a Lambda Function Along With The Filter Function

Filter is a very important Python function that gets a list as input and returns a new filtered list, according to our presets. To use filter, we provide it with a list and a function that filters that list. This is where a lambda function is most times used. Let’s take a look at this interesting example :

list = [1,2,3,4,5]

newList = filter(lambda x: x - 1, list)
print newList

After this is executed, it returns [2,3,4,5], but do you understand why ? First of all, we create a lambda function that gets an integer and returns the same integer subtracted by 1. Now, filter works like this. If the function returns true, the item is returned to the newList. Each element of the list is passed through the lambda function for evaluation. The first integer value of the list is 1. When subtracted by 1, it returns the integer 0. However, 0 means False as you know and the element is not passed to the newList. The second element 2 becomes 1, 3 becomes 2 and so forth and all these values, since they are not 0, are evaluated as true and passed to the newList.

Why is The Learning PHP Process Different Than Any Other Programming Language ?

By nature, PHP is all about knowing what to do. If you have the knowledge on how to do something in PHP, actually doing it is most of the times really really easy. I would actually pay to know some of these things beforehand. In PHP, doing things the way you think them will most probably result in doing them the wrong way. Not because you’re a bad programmer, but because there are some standard tricks of the trade that you cannot really avoid using, if you want to write good and maintanable code. Let’s talk about these 10 techniques that you really need to know about :

1. How to Properly Create a Website Index Page

Creating your website index page is the first thing to do for every website that you create. I’ve actually created a post that will help you properly create a website index page.

2. Use the Request Global Array to Grab Data

There is actually no reason to use $_GET and $_POST arrays to grab values. $_REQUEST, is another global array that fetches you either a get or form request. Therefore, it’s most times more convenient to use something like this to parse data :

$action = isset($_REQUEST['action']) ? $_REQUEST['action'] : 0;

3. Debugging PHP is About var_dump

If you’re looking for php debugging techniques, i have to say that var_dump is most times the way to go about it. This command is all you need to echo php information. There shouldn’t really be many cases where you need anything more than dumping values in PHP, in order to debug your code.

4. PHP Handles The Code Logic, Smarty Handles The Presentation

I think i’ve said this many times before, but Smarty usage (or other template system), is critical for creating organized PHP code. Learn to use smarty as a template engine for your websites, it will pay off, i promise.

5. When You Absolutely Need Global Values, Create a Config File

It is a bad practice to create global values for everything. There are limited cases where you would actually need to do so. Doing it for database tables or database connection information is a good idea, but do not use global variables throughout your PHP code. Moreover, it is always a better idea to keep your global variables at a single config.php file.

6. If NOT Defined, Access Denied !

If you’re creating your pages the correct way, there will absolutely no reason for anybody to access any other php page other than index.php or home.php. The idea is that once index.php is accessed, you utilize get variables in order to open the needed pages. Your index page should contain something like :

define('yourPage',1);

Then, your other pages should contain this :

if (!defined('yourPage')) die('Access Denied');

What this does, is preventing direct access to your other php pages. Therefore, any user who tries to access your other web pages, not through index.php, gets an “Access Denied” message.

7. Create a Database Class

If you’re doing database programming (pretty common in PHP), it would be a very good idea to create a database class to handle any database management functions. A good way to do it is by creating functions like :

    public function dbExec($query)
    {
        $result = $this->db->exec($query);
        if (PEAR::isError($result))
            errorRedirect($result->getMessage(), true);
        else
            return $result;
    }

This is an example function from an actual project i’m creating. This one just receives a query and executes it. It also handles any errors that may occur. You could also include sanitization code here, but i prefer to do it using a sanitization function like :

	// checks if arguments given are integer values not less than 0 - has multiple arguments
	function sanitizeInput()
	{
		$numargs = func_num_args();
	    $arg_list = func_get_args();

	    for ($i = 0; $i < $numargs; $i++) {
			if (!is_numeric($arg_list[$i]) || $arg_list[$i] < 0)
	            errorRedirect("Unexpected variable value", true);
	    }
	}

8. A php File Handles Input, a class.php File Handles Functionality

It is pretty important that you learn not to mess the code that retrieves user input and redirects it to any functions, with those actual functions. The idea is pretty simple. The php file gets any input that we need and then redirects execution to a function residing to the class file. For example, let’s suppose that a url is like “index.php?page=profile&action=display”. The profile.php file retrieves the url and gets that action is “display”. Then, using a simple switch, we execute the actual display function like :

require_once PROJECTROOT.'libs/messages.class.php';

$message = new Message();

switch ($action)
{
    case 'display':
        $message->display();
        break;

...

Again, this is part of a project that i create. You see that i include the messages class and then initiate the switch check. $message is just an object that is used to call functions inside the class.

9. Know Your SQL and Always Sanitize

As i mentioned before, a database is 99% of times important for any php created website. Therefore, you need to know many things about how to use sql properly. Learn to combine tables and more advanced techniques. I promise there will be mysql tutorials soon in codercaste.com. Let me present you an example of a function that uses mySQL and sanitazes using the function seen on point #7 :

    private function getSentMessages($id)
    {
	$this->util->sanitizeInput($id);

        $pm_table = $GLOBALS['config']['privateMsg'];
	$users = $GLOBALS['config']['users'];

        $sql = "SELECT PM.*, USR.username as name_sender FROM $pm_table PM, $users USR
		    WHERE id_sender = '$id' AND sender_purge = FALSE AND USR.id = PM.id_receiver AND is_read = TRUE
		    ORDER BY date_sent DESC";
	$result = $this->dbQueryAll($sql);

        return $result;
    }

At first, we sanitize the user input (the message id at this point, that is passed through a GET variable) and then we execute our sql command. Notice the usage of sql here. You need to learn how to use aliases and combine tables.

10. When You Need Just an Object, Use a Singleton Pattern

It happens pretty often in PHP that we just need a single object created one time and then used globally throughout our whole program. A good example of this is the smarty variable that has to be initialized once and then is used all over the place. A good way to do that is a Singleton pattern, where an object is just created once and for all. The way to do this is like :

    function smartyObject()
    {
        if ($GLOBALS['config']['SmartyObj'] == 0)
        {
            $smarty = new SmartyGame();
            $GLOBALS['config']['SmartyObj'] = $smarty;
        }
        else
            $smarty = $GLOBALS['config']['SmartyObj'];
        return $smarty;
    }

Notice that we have a global smarty variable (initialized in config.php in example) and if it equals 0, we go about creating a new smarty object. If not, it means that the object is already created and we just need to return it.

Hope these 10 techniques are as helpful to you as they are for me and i would really like to listen to what you think is your most important PHP technique.

The first thing that i had in mind was speed. I wanted the library to be lightweight and effective. I could live without some features, but performance is really critical. You do not really want your users waiting over client code that is executing on their browsers.

I remember that i had 3 frameworks in mind at the time. They were mootools, yui and prototype. I wouldn’t really know which one was faster. At the time, i was playing the well known Ikariam browser game and i noticed that they were using YUI. Ikariam, though a nice game, is pretty slow on its javascript handling. So, i thought that YUI may have not been a good choice. Then, i also noticed that tribal wars was using mootools. I was always fascinated on their client side scripting. Their game runs really fast. This made me think that mootools was probably the best choice, BUT i needed proof.

Luckily, there is a tool (in mootools website), that can help us make out which js library is faster. You can find the tool here :

Javascript Frameworks performance test

If you run the test (do it, it’s fun), you will notice that mootools, along with Dojo, are the fastest frameworks. So, now you now. Choose wisely

To get information about the disk space on your system, you can just execute :

df -h

-h stands for Humanly readable, so it’s pretty easy to remember. Upon execution, you get back something like :

Filesystem      Size   Used  Avail Capacity  Mounted on
/dev/disk0s2   113Gi   89Gi   23Gi    80%    /
...

This example is generated on my macintosh pc, so it may defer in your case. As you can see, i have a total of 113GBytes on free space and i’m currently using 89GBytes (hmm, i have to free up some space). This leaves me with 23GBytes on available free disk space and thus i’m using 80% of the hard disk capacity.

How do CSS work ?

CSS is today’s standard in stylizing web pages. Its usage is pretty straight forward and easy. As, you know, in HTML, we are using elements like <p> or <h1> in order to create our paragraphs, headers and more. When we create a paragraph, we sometimes need to change the text size or font inside a paragraph, for instance. CSS is all about making our lives easier in doing so, without repeating the same things over and over.

Change The Text Size and Font Using CSS

Using just plain HTML, we could stylize our paragraph like :

<p>
<font size="3" face="Times">our text here </font>
</p>

While this would work, there is a problem here. What if we wanted to do that on every paragraph of our HTML code ? This would turn out to become pretty tedious. Thankfully, this is where CSS comes to our rescue. Using a simple CSS tag, we can stylize our every paragraph like :

p  {
    font-family: Times, serif;}
    font-size:0.875em;
    }

Does that make sense here ? Now every paragraph of our text is stylized using these attributes. You may ask what happens if you just want to stylize certain paragraphs. Well, in that case, you need to utilize a more advanced CSS technique, called classes. If you’re more interested in that, take a look here :

CSS Classes

I will be creating tutorials about CSS classes and more in the future for sure.

In PHP, there is a very important difference between writing code and writing good code. Of course, this is true for every programming language, let alone PHP. Knowing how to properly design your website’s index page is the first and important step towards creating a solid website.

The Amateur Way to Write Your Index Page

The typical way to write your index page, if you are not really that knowledgeable in PHP, is just go about coding whatever there is for the index page. For instance, suppose that our index page has a login form and some introductory text. Our approach would be to just write the code for the index page and then, for every link on that page, create another page. This would mean that we now have an index.php page, a contact.php page, a mail.php page and more.

Don’t feel bad if you do it this way. I’ve done it myself and every new PHP programmer has done so as well. However, it’s time to learn of a more efficient way to code in PHP.

The “index.php?page=home” Way

Have you noticed that many websites follow this pattern ? Instead of having a home.php page, you see something like “index.php?page=home”. The same happens for every page of the website. What happens is that the index.php page includes the code of the other webpages, as asked. The variable page that you notice in the url is actually a typical $_GET type global variable that you can read in order to identify what is the page that the browser asks for. Here is the actual code of a typical index page :

$page = isset($_REQUEST['page']) ? $_REQUEST['page'] : 'home';

switch($page)
{
    case 'home':           break;
    case 'mail':           break;
    case 'contact':        break;
    default:
        $page = 'home';
}

include("$page.php");

This is a very basic example as you see. The index page just gets the $_REQUEST['page'] global variable ($_REQUEST is a union of $_GET and $_POST, retrieves whatever is available). Now the switch starts. But why have a switch and not just include the php page ? Well, this is actually a security measure against file inclusion attacks. It is always good to handle unexpected input. If an attacker somehow manages to upload a new php page, say hello.php, this index page, without the switch structure, would execute it normally when instructed with index.php?page='hello'. However, if the switch is there, hello.php never gets executed. Instead, the default home.php gets executed. This is always a very good practice and you should really stick to it. Of course, there is much more in protecting PHP code, but this is a small addition as well.

You could now go about creating your own template for writing websites. Remember that it is very important that you know of the essential PHP requirements in order to write much more efficiently than usual. Also, if you are not familiar with it, pay special attention to Smarty and learn to use it to create your templates.

What is a Python List ?

A Python list is simply a data type containing values of the same type that can be changed dynamically. It can be initialized having just two elements and then we can go on adding more elements or delete some elements as well. On the other hand, the other important Python data structure, tuples, is the same as lists only immutable. Thus, it cannot be changed on runtime.

Why Do You Need to Filter Lists ?

What happens with standard Python programming is that we tend to create lists all the time. We could be either reading a file and creating a list with its words, or maybe getting a list of the files of our current directory. Whatever the case, lists are used quite a lot and if you have been programming in Python for just a small period of time, chances are that you have already used them at least once. The problem is that lists alone are not enough. Most times we need some time of filtering in order to throw out some elements and only keep the important ones. A good example could be the case of getting a list of files. Then, we just want to keep the ones that are of *.mp3 filetype. This is where Python starts to become really versatile, as you will see below.

How to Filter Lists in Python ?

The simplest way to filter a list is the one show below. We just have a list of filenames and we want to recreate that list so that it does not contain the files that do not have “mp3″ as their filetype.

list = ["1.mp3","2.txt", "3.mp3", "4.wmv","5.mp4" ]
temp = []

for item in list:
    if item.find(".mp3") != -1:
        temp.append(item)

for item in temp:
    print item

In this example, we have a list that we traverse using a simple for. Then, we have another temporary list and whenever we locate an element having “.mp3″ as a substring, we add it to our new list. In the end we just print the new list and get the filenames we opted for.

Sometimes, we just need to quickly create a sublist of our starting list. Say that we just need the first two elements of our list. This can be done like this :

list = ["1.mp3","2.txt", "3.mp3", "4.wmv","5.mp4" ]

list = list[:2]

for item in list:
    print item

The syntax [starting:ending] determines the sublist we need to create. If no starting index is specified, it defaults to the first element. If you specify the ending index as n, you get the n-1 elements. So, li[:2] gets you elements li[0] and li[1].

The Elegant Way to Filter Lists

def isMp3(s):
    if s.find(".mp3") == -1:
        return False
    else:
        return True

list = ["1.mp3","2.txt", "3.mp3", "4.wmv","5.mp4" ]
temp = filter(isMp3,list)

for item in temp:
    print item

This is probably the best and most elegant way to filter a list in Python. We utilize the python function filter() here. What this does is take a function and our list to be filtered as its 2 parameters. For each element of the list, this function is executed and the parameter is the next element of the list. If this function returns true, the item is added to the resulting list, else it is not. Once finished, filter() returns the new list, which we print out as you see in the example above. If you want, you can also check the map() function as well.

This concludes this small post about filtering lists in Python. I reckon these techniques pretty important in writing efficient code. Python is mostly about doing things fast. Hence, using the built in functions can save you time (and money?) and also transform your code to an elegant state of the art (or at least make it bearable )