First step is to check the latest version from their website. The latest version as of this writing is 7.4.1.

Ubuntu

For Ubuntu, we will be downloading the Linux tarball from the website. GHC can also be installed using the Debian packages provided by the Ubuntu repository. However, the one that is in the repository is not the latest version. Some of the functionality offered by the latest version might not be supported.

wget http://www.haskell.org/ghc/dist/7.4.1/ghc-7.4.1-i386-unknown-linux.tar.bz2

After downloading, untar the file:

tar -xvf ghc-7.4.1-i386-unknown-linux.tar.bz2

A new directory will be created, go inside the directory

cd ghc-7.4.1

Run the configuration executable to begin the installation.

sudo ./configure

By default, this will be installed under /usr/local. However, you may override this by using this command instead:

sudo ./configure --prefix=<my-dir>

where <my-dir> is the path of the new target directory.

When I tried installing running the configuration, I kept on encountering an error which states:

libgmp.so.3: cannot open shared object file: No such file or directory

Although I was able to solve the error by creating a symbolic link to an older version, still, according to forums, this is not a correct way to solve the problem. If you have any other approach, please do comment here.

sudo ln -s /usr/lib/libgmp.so /usr/lib/libgmp.so.3

Going back to the installation, the configuration must not be terminated by an error. If it does, try installing all the necessary dependencies first.

The next step would be the actual installation.

sudo make install

The installation would take some time. To check that you have successfully installed GHC into your system is by issuing this command:

ghci

This will automatically load the interpreter and you will see this.

GHCi, version 7.4.1: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude>

Windows

For Windows, the installation of GHC is very easy. Just download the latest executable from their website. Click here.

Just run the installer and follow the instructions. Below is the step by step installation.

This is how you install GHC on Windows. You may start using it either by going to the Start Menu or in the command prompt. Just issue the ghci command for the interpreter and ghc for the compiler.

package sec.treasurer

class Person {

	String studentID
	String firstName
	String middleName
	String lastName
	String gender
	Integer year
	String section

}

As you can see, the order on how it was declared did not match the order of the list in the view.

To explicitly state the order we want to achieve, we state it in the constraints section.

package sec.treasurer

class Person {

	String studentID
	String firstName
	String middleName
	String lastName
	String gender
	Integer year
	String section

    static constraints = {
		studentID ()
		firstName ()
		middleName ()
		lastName ()
		gender ()
		year ()
		section ()
    }
}

We update the domain class file.

Now, the order has been achieved.

By default, Grails applications are configured to use an in-memory HSQLDB database for development and testing. If you wanted to use MySQL, you would have to configure your application. To do so, just follow these simple steps.

1. Create a database in MySQL.

In MySQL, create 2 new databases that will be used by our application. We will create sec_treasurer for development andsec_treasurer_prod for the production.

mysql> CREATE DATABASE sec_treasurer;
mysql> CREATE DATABASE sec_treasurer_prod;

2. Create a new Grails Application.

After creating the database, the next thing to do is to create a new application.

grails create-app sec-treasurer

3. Update BuildConfig.groovy file under grails-app/conf.

After creating the application, the next step is to setup the its dependencies. Actually, there are two ways of setting up the application to use MySQL database, However, I prefer this way since it is much easier.

Inside the file, find and uncomment the line which says:

//runtime 'mysql:mysql-connector-java:5.1.16'

As of this writing, the latest versioin of the JDBC is 5.1.18, which is why I needed to change the version number. This will automatically download from the Maven Central the necessary connector that will allow the communication between our application and the MySQL database.

The updated file should look something like this.

BuildConfig.groovy

grails.servlet.version = "2.5" // Change depending on target container compliance (2.5 or 3.0)
grails.project.class.dir = "target/classes"
grails.project.test.class.dir = "target/test-classes"
grails.project.test.reports.dir = "target/test-reports"
grails.project.target.level = 1.6
grails.project.source.level = 1.6
//grails.project.war.file = "target/${appName}-${appVersion}.war"

grails.project.dependency.resolution = {
    // inherit Grails' default dependencies
    inherits("global") {
        // uncomment to disable ehcache
        // excludes 'ehcache'
    }
    log "error" // log level of Ivy resolver, either 'error', 'warn', 'info', 'debug' or 'verbose'
    checksums true // Whether to verify checksums on resolve

    repositories {
        inherits true // Whether to inherit repository definitions from plugins
        grailsPlugins()
        grailsHome()
        grailsCentral()
        mavenCentral()

        // uncomment these to enable remote dependency resolution from public Maven repositories
        //mavenCentral()
        //mavenLocal()
        //mavenRepo "http://snapshots.repository.codehaus.org"
        //mavenRepo "http://repository.codehaus.org"
        //mavenRepo "http://download.java.net/maven/2/"
        //mavenRepo "http://repository.jboss.com/maven2/"
    }
    dependencies {
        // specify dependencies here under either 'build', 'compile', 'runtime', 'test' or 'provided' scopes eg.

        runtime 'mysql:mysql-connector-java:5.1.18'
    }

    plugins {
        runtime ":hibernate:$grailsVersion"
        runtime ":jquery:1.7.1"
        runtime ":resources:1.1.5"

        build ":tomcat:$grailsVersion"
    }
}

4. Update DataSource.groovy file under grails-app/conf.

After setting up the dependency, the next step is to configure our data source. The first part shows the parameter for the dataSource variable. We need to change the driverClassName to point to the proper class. Also, since we are using the InnoDB engine, we will be setting the dialect.

dataSource {
    pooled = true
    driverClassName = "com.mysql.jdbc.Driver"
    dialect = "org.hibernate.dialect.MySQL5InnoDBDialect"
}

The next step just shows how to configure the environment variable. Let us use the two databases we created a while ago. For the development and test environment, let us use the sec_tresurer database. On the other hand, for the production environment, let us use the sec_treasurer_prod database.

// environment specific settings
environments {
    development {
        dataSource {
            dbCreate = "create-drop" // one of 'create', 'create-drop', 'update', 'validate', ''
            url = "jdbc:mysql://localhost/sec_treasurer?useUnicode=yes&characterEncoding=UTF-8"
            username = "root"
            password = "root"
        }
    }
    test {
        dataSource {
			dbCreate = "update"
			url = "jdbc:mysql://localhost/sec_treasurer_prod?useUnicode=yes&characterEncoding=UTF-8"
			username = "root"
			password = "root"
        }
    }
    production {
        dataSource {
			dbCreate = "update"
			url = "jdbc:mysql://localhost/sec_treasurer_prod?useUnicode=yes&characterEncoding=UTF-8"
			username = "root"
			password = "root"
        }
    }
}

The code is very straightforward. The url variable simply uses the JDBC and connects to the MySQL server running on the computer. The name of the databases here are sec_treasurer and sec_treasurer_prod. There are also some optional parameters used. The assumption here is that the username that will be used to connect to the database is root and the password is root.

dbCreate deserves a special mention. It determines what happens to your database between server restarts. For example, a value of create-drop means that the database tables will be dropped and then recreated when you start the server, so you lose any data that was in there. This is fine for testing, but is definitely not what you want in production. The user guide has more information on these settings.

The complete code should look like this.

DataSource.groovy

dataSource {
    pooled = true
    driverClassName = "com.mysql.jdbc.Driver"
    dialect = "org.hibernate.dialect.MySQL5InnoDBDialect"
}
hibernate {
    cache.use_second_level_cache = true
    cache.use_query_cache = true
    cache.region.factory_class = 'net.sf.ehcache.hibernate.EhCacheRegionFactory'
}
// environment specific settings
environments {
    development {
        dataSource {
            dbCreate = "create-drop" // one of 'create', 'create-drop', 'update', 'validate', ''
            url = "jdbc:mysql://localhost/sec_treasurer?useUnicode=yes&characterEncoding=UTF-8"
            username = "root"
            password = "root"
        }
    }
    test {
        dataSource {
			dbCreate = "update"
			url = "jdbc:mysql://localhost/sec_treasurer_prod?useUnicode=yes&characterEncoding=UTF-8"
			username = "root"
			password = "root"
        }
    }
    production {
        dataSource {
			dbCreate = "update"
			url = "jdbc:mysql://localhost/sec_treasurer_prod?useUnicode=yes&characterEncoding=UTF-8"
			username = "root"
			password = "root"
        }
    }
}

5. Create a new domain class.

The next step is to create a domain class that will be persisted later in our database. Let’s create a sample domain class.

grails create-domain-model sec.treasurer.Person

Update the file Person.groovy under grails-app/domain/sec/treasurer.

Person.groovy

package sec.treasurer

class Person {

	String studentID
	String firstName
	String middleName
	String lastName
	Integer year
	String section

    static constraints = {
    }
}

6. Create a controller for Person.groovy

The last step is to create the controller.

grails create-controller sec.treasurer.Person

Update the file PersonController.groovy under grails-app/controller/sec/treasurer.

Inside the controller, we will define a scaffold which will automatically create the CRUD (Create, Read, Update, Delete) functionality for our domain class.

PersonController.groovy

package sec.treasurer

class PersonController {

    def scaffold = Person

}

Finally, let us run the application.

grails run-app

While the application is running, you might want to see the contents of your sec_treasurer database. You will notice that a new table, namely person, was created.

Let us describe the table in MySQL command line.

The controller created will be available in the list. Click on it to start the CRUD operations.

Since our database does not have any data in it, there is nothing to list. Let us create a new person.

Simultaneously, let us check our person table. You will see that it is also empty.

Let us fill up the form with all the necessary information.

Let’s check again the contents of person table. You will see that a new record is created.

We can also see this in our application.

This is how you integrate MySQL to a Grails application. Grails is not limited to MySQL. You can also use any other databases as well like PostgreSQL.

import java.applet.*;
import java.awt.*;

public class Main extends Applet {

   public void init() {
      resize(150, 25);
   }

   public void paint(Graphics g) {
      g.setFont(new Font("Helvetica", Font.PLAIN, 25));
      g.drawString("Hello world!", 50, 25);
   }

}

For more information about the Applet class, click here.

The next step is to compile this class. The output file would be Main.class.

For us to integrate our class file to our HTML page, we must use the <applet> tag. This tag has 3 attributes, namely, the code, width and height. The code is the name of the class file.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html lang="en-US">
  <head>
    <title>Sample Java Applet</title>
    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
  </head>
  <body>
    <h1>Sample Java Applet</h1>
    <applet code='Main.class' width="300" height="300" />
  </body>
</html>

Given the source code of the HTML page, you must save both files under the same directory. However you can save them in different locations, just make sure you make the proper changes in the code.

The output should look like this

Of course, you must have JRE running on your system.

For a more detailed discussion about applets, click here.

class Person:
	"""
	This class represents a Person with fields name and age.
	"""

	# This is the constructor of the class.
	# age here is an optional parameter.
	def __init__ (self, name, age=0):
		self.name = name
		self.age = age

	# Get the name of the person.
	def get_name(self):
		return self.name

	# Get the age of the person.
	def get_age(self):
		return self.age

def main():
	personA = Person('Yancy Vance')
	personB = Person('John Doe', 22)

	print '%s is %d year/s old.' % (personA.get_name(), personA.get_age())
	print '%s is %d year/s old.' % (personB.get_name(), personB.get_age())

main()

The output for this would be:

Yancy Vance is 0 year/s old.
John Doe is 22 year/s old.

One special thing that you have to take note is that, unlike Java and C++, Python does not support method overloading.

We are testing
your programming
skills today

And the output file is the length of all words:

2 3 7
4 11
6 5

You want to write a C++ program that would process each word. Aside from that, the program should follow the way the input file is written, that is, line by line.

The first step here includes reading the whole line itself. Assuming that the size of the line is variable, let us declare a pointer to allocate a dynamic memory size.

string line;
getline(iFile, line); // Assuming iFile is an input file.

char *sArr = new char[line.length()+1];
strcpy(sArr, line.c_str()); // parameters: strcpy(char*, const char*);

What happens here is that we read the whole line. Next is that we copy the string to a char* data type. We do this because we cannot initialize a char* with a string variable. The size must also be the length of the string + 1. We add 1 for the null character or the terminator of the string. The c_str() is a function that converts a string to a const char* data type.

char *sPtr;
sPtr = strtok(sArr, " ");
while(sPtr != NULL) {
	cout << strlen(sPtr) << " ";

	sPtr = strtok(NULL, " ");
}

The next step here includes going through all the tokens of the line. The strlen() function returns the length of the current word. Within the loop, we can see that we are updating the value for the sPtr pointer. This ensures that we will not have an infinite loop.

The complete code would look something like this:

#include <iostream>
#include <string>
#include <fstream>
#include <cstring>

using namespace std;

int main() {
	ifstream iFile("inputFile.in");

	while(iFile.good()) {
		// Declare variable for the line.
		string line;

		// Read the whole line.
		getline(iFile, line);

		// Initialize char pointer sArr for
		// conversion of string to char*.
		char *sArr = new char[line.length()+1];
		strcpy(sArr, line.c_str());

		// Declare char pointer sPtr for the tokens.
		char *sPtr;

		// Get all the tokens with " " as delimiter.
		sPtr = strtok(sArr, " ");

		// For all tokens.
		while(sPtr != NULL) {
			cout << strlen(sPtr) << " ";

			// Go to the next word.
			sPtr = strtok(NULL, " ");
		}

		// This is the end of the line.
		cout << endl;
	}

	iFile.close();

	return 0;
}

For more information about the strtok() function, see the documentation.

To reboot, use this command:

sudo reboot

To shut down, use this command:

sudo poweroff

To know more about these commands, use the manual in the terminal.

man reboot

or

man poweroff

This contains comprehensive information about the commands.

Assuming that you have administrative privileges on the system, issue the following command:

sudo passwd [username]

Example:

sudo passwd yancy

This will ask you to enter your current password first. After that, you will be prompted to enter a new password.

We edit our main.gsp file under the grails-app/views/layouts directory.

Just insert this block of code

<sec:ifLoggedIn>
	<strong>Welcome <sec:username/></strong><br/><br/>
</sec:ifLoggedIn>
<sec:ifNotLoggedIn>
	<strong>Welcome Guest</strong><br/><br/>
</sec:ifNotLoggedIn>

below this line:

<div id="grailsLogo" role="banner"><a href="http://grails.org"><img src="${resource(dir: 'images', file: 'grails_logo.png')}" alt="Grails"/></a></div>

The complete code should look like this:

main.gsp

<!doctype html>
<!--[if lt IE 7 ]> <html lang="en" class="no-js ie6"> <![endif]-->
<!--[if IE 7 ]>    <html lang="en" class="no-js ie7"> <![endif]-->
<!--[if IE 8 ]>    <html lang="en" class="no-js ie8"> <![endif]-->
<!--[if IE 9 ]>    <html lang="en" class="no-js ie9"> <![endif]-->
<!--[if (gt IE 9)|!(IE)]><!--> <html lang="en" class="no-js"><!--<![endif]-->
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
		<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
		<title><g:layoutTitle default="Grails"/></title>
		<meta name="viewport" content="width=device-width, initial-scale=1.0">
		<link rel="shortcut icon" href="${resource(dir: 'images', file: 'favicon.ico')}" type="image/x-icon">
		<link rel="apple-touch-icon" href="${resource(dir: 'images', file: 'apple-touch-icon.png')}">
		<link rel="apple-touch-icon" sizes="114x114" href="${resource(dir: 'images', file: 'apple-touch-icon-retina.png')}">
		<link rel="stylesheet" href="${resource(dir: 'css', file: 'main.css')}" type="text/css">
		<link rel="stylesheet" href="${resource(dir: 'css', file: 'mobile.css')}" type="text/css">
		<g:layoutHead/>
        <r:layoutResources />
	</head>
	<body>
		<div id="grailsLogo" role="banner"><a href="http://grails.org"><img src="${resource(dir: 'images', file: 'grails_logo.png')}" alt="Grails"/></a></div>
		<sec:ifLoggedIn>
			<strong>Welcome <sec:username/></strong><br/><br/>
		</sec:ifLoggedIn>
		<sec:ifNotLoggedIn>
			<strong>Welcome Guest</strong><br/><br/>
		</sec:ifNotLoggedIn>
				<g:layoutBody/>
		<div class="footer" role="contentinfo"></div>
		<div id="spinner" class="spinner" style="display:none;"><g:message code="spinner.alt" default="Loading&hellip;"/></div>
		<g:javascript library="application"/>
        <r:layoutResources />
	</body>
</html>

No need to restart the server. Just refresh the page if the server is still running. You will then see the updated page immediately. This uses the username of the currently logged in Person and displays it above.

This will add a text in all pages that will show you the current logged in Person.

This ends the 5 part tutorial on how to create a Twitter-like application in Grails.

If you would like to have a copy of the project, you can download it here.

The first thing that we have to do is to install the searchable plugin.

grails install-plugin searchable

Open the Person.groovy file found under grails-app/domain/org/grails/twitter. Insert these lines just before the constraints.

static hasMany = [followed:Person, status:Status]
static searchable = [only: 'realName']

The complete code should look like this:

Person.groovy

package org.grails.twitter

class Person {

	transient springSecurityService

	String realName
	String username
	String password
	boolean enabled
	boolean accountExpired
	boolean accountLocked
	boolean passwordExpired
	static hasMany = [followed:Person, status:Status]
	static searchable = [only: 'realName']

	static constraints = {
		username blank: false, unique: true
		password blank: false
	}

	static mapping = {
		password column: '`password`'
	}

	Set<Authority> getAuthorities() {
		PersonAuthority.findAllByPerson(this).collect { it.authority } as Set
	}

	def beforeInsert() {
		encodePassword()
	}

	def beforeUpdate() {
		if (isDirty('password')) {
			encodePassword()
		}
	}

	protected void encodePassword() {
		password = springSecurityService.encodePassword(password)
	}
}

This will create a one-to-many relationship of Person-Person and Person-Status. The searchable will then define the field or attribute that will be used for searching. In our example, we are searching only for the realName.Next step is to add a search form in our view. Open the index.gsp file under grails-app/views/status

We add these lines of codes after the opening body tag.

<h1>Search For People To Follow</h1>
<div class="searchForm">
	<g:form controller="searchable">
		<g:textField name="q" value=""/>
	</g:form>
</div>

This is going to be our search form in our view. Refresh the page and you will see this change immediately.

The complete code should look like this:

index.gsp

<html>
<head>
    <meta name="layout" content="main" />
    <title>What Are You Doing?</title>
    <g:javascript library="jquery" plugin="jquery" />
</head>
<body>
	<h1>Search For People To Follow</h1>
	<div class="searchForm">
		<g:form controller="searchable">
			<g:textField name="q" value=""/>
		</g:form>
	</div>

    <h1>What Are You Doing?</h1>
    <div class="updateStatusForm">
        <g:formRemote onSuccess="document.getElementById('messageArea').value='';" url="[action: 'updateStatus']" update="messageLists" name="updateStatusForm">
            <g:textArea name="message" value="" id="messageArea" /><br/>
            <g:submitButton name="Update Status" />
        </g:formRemote>
    </div>
    <div id="messageLists">
		<g:render template="messages" collection="${messages}" var="message"/>
	</div>
</body>
</html>

We now check our application on our browser. We now see a new controller named SearchableController. This controller will handle all our search requests. This has been created by the searchable plugin.

We can see that there is a new field in our status view. This is the one that we added earlier. When we search for a Person, say for example “john” (There is a John Doe Person in the record), and press enter on our keyboard, we will be redirected to a search results page.

However, we wanted to change how the results would look like. For this to happen, we override the view of the searchable controller.

Under grails-app/views, we create a new folder and name it “searchable”. Inside this folder, we create a new file and name it “index.gsp”.

This is the content of the index file.

index.gsp

<html>
<head>
    <meta name="layout" content="main" />
</head>
<body>
        <g:each var="person" in="${searchResult?.results}">
        <div id="name">
            ${person.realName} <g:link id="${person.id}" action="follow" controller="status">follow</g:link>
            </div>
        </g:each>
</body>
</html>

This will override the search result page that we saw a previously. This will provide a follow link that will allow you to follow the Person.

We now try our application once again in our browser.

As we can see, the search results page has been updated.

However, when we click on follow, we will be given an Error 404. The reason behind this is that we did not define a follow method inside the StatusController.groovy. We want the said controller to handle the follow event.

def follow = {
	def per = Person.get(params.id)
	if(per) {
		def currentUser = lookupPerson()
		currentUser.addToFollowed(per)
		currentUser.save()
	}
	redirect action: 'index'
}

We add this block of codes just after the index definition. The concept of this method is just to add the Person with the ID that is provided in the parameter to the collection of followed Persons of the current Person logged in. The controller then redirects the user to the index page afterwards.

When we check and refresh once again our application, we can now see that when we click on follow, we don’t encounter the error anymore. We are then redirected to the status index page afterwards. Even though we don’t see it, we are now following John.

Let’s open a different browser and log in as John Doe.

We post a new Status message and see what happens to Yancy’s timeline later on.

This is the timeline of John Doe.

This is the timeline of Yancy. When we refreshed the page of Yancy after John posted a new Status, it seems that we still don’t see the Status update of John even though we are following him.

To fix this issue, we update our StatusController.groovy. Inside the currentUserTimeline() method, we add a new criterion for our search. Just after the author criterion, we add this line:

if(per.followed) author in per.followed

This will now include in the search all the Statuses of followed Persons.

The updated file should look like this:

StatusController.groovy

package org.grails.twitter

import grails.plugins.springsecurity.Secured

@Secured('IS_AUTHENTICATED_FULLY')

class StatusController {

	def springSecurityService

    def index() {
    	def msgs = currentUserTimeline()
		return [messages: msgs] // this is a map. key=>value
    }

    def follow = {
		def per = Person.get(params.id)
		if(per) {
			def currentUser = lookupPerson()
			currentUser.addToFollowed(per)
			currentUser.save()
		}
		redirect action: 'index'
    }

    def updateStatus = {
		def status = new Status(message: params.message)
		status.author = lookupPerson()
		status.save()
		def messages = currentUserTimeline()
		render template: 'messages', collection: messages, var: 'message'
    }

    private lookupPerson() {
		Person.get(springSecurityService.principal.id)
	}

    private currentUserTimeline() {
		def per = lookupPerson()
		def query = Status.whereAny {
			author { username == per.username }
			if(per.followed) author in per.followed
		}.order 'dateCreated', 'desc'
		def messages = query.list(max: 10)

		messages
	}

}

This time, let us restart the server.

We now can see that the Statuses of John Doe can now be seen by Yancy.

In the last part of the tutorial, we will polish our web application and add some extra functionality.