Quoting from wikipedia

Within the type system of a programming language, covariance and contravariance refers to the ordering of types from narrower to wider and their interchangeability or equivalence in certain situations (such as parameters, generics, and return types).

• covariant: converting from wider (double) to narrower (float).
• contravariant: converting from narrower (float) to wider (double).
• invariant: Not able to convert.

The ability to send a collection of subclass instances to a collection of base class is called covariance

The ability to send a collection of superclass instances to a collection of subclass is called contravariance

By default scala does not allow covariance and contravariance, but there are some good use cases where you might want to use a derived type as a super type.

Lets prepare some base code:

class Person(val name: String) {
 override def toString = name
}

class Employee(override val name: String) extends Person(name)

val empList = List(new Employee("Joao"), new Employee("Andre"))
val peopleList = List(new Person("Martin"), new Person("Jonas"))

def sayHi(people:List[Employee]) = people.map { println _ }

sayHi(empList)
sayHi(peopleList) // compilation ERROR

The error is pretty obvious we can’t send a List[Person] as the sayHi function expects a List[Employee] as it’s formal parameter, and here is where covariancecomes into place.

Covariance

To solve the above compilation error we have to let scala compiler know that it’s ok to treat a Person as an Employee, we do that as follows:

def sayHi[T <: Person](people: List[T]) = people.map { println _ }

sayHi has now a special syntax [T <: Person]. This syntax indicates that T sould be of Type Person or any class that derives from Person, which means that know we can have something like:

sayHi(empList) sayHi(peopleList)

You can also indicate covariance at the class level by making the parameterized type+T instead off T.

class SomeCollection[+T]

var lst1 = new SomeCollection[Employee]
var lst2: SomeCollection[Person] = lst1

The above snippet is possible since Employee is a subclass of Person

Contravariance

Contravariance is the literally the opposite of Covariance, Lets imagine we want to add Employee to Person, as you can see the relationship is from subclass to superclass.

def appendToPerson[T, D <: T](employees: List[T], people: List[D]) = people ++ employees

With the syntax [T, D <: T], we have constrained the parameterized type D to be of the type T or a super type of T, so basically T sets the lower level in the Type hierarchy for type D. In our example the type D (Person) can be of type T (Employee) or its superclass.

Scala also has class level support for setting contravariance and as you might guess the parameterized type is -T

Summary

• A class C[T], when a method accepts only C[T] is invariant
• A class C[+T], when a method accepts C[T] i can also get any of it’s dervatives
• A class C[+-T], when a method accepts C[T] i can also get any of it’s super classes

Function Type bounds:

def fun[T <: A](arg:T) // covariant, arg must be of type T or any of it's subclasses
def fun[T >: A](arg:T) // Contravariant, arg must be of type T or any of it's super class

Install Node.js via mac ports

sudo port selfupdate
sudo port install nodejs

Install Node.js via Homebrew

brew install node

Build in 30 seconds by Isaac Z. Schlueter(@izs)

echo 'export PATH=$HOME/local/bin:$PATH' >> ~/.bashrc
. ~/.bashrc
mkdir ~/local
mkdir ~/node-latest-install
cd ~/node-latest-install
curl http://nodejs.org/dist/node-latest.tar.gz | tar xz --strip-components=1
./configure --prefix=~/local
make install
# ok, fine, this step probably takes more than 30 seconds...

Install npm with

curl http://npmjs.org/install.sh | sh

or

git clone http://github.com/isaacs/npm.git
cd npm
sudo make install

Node version management with N

Node version management is important so that you can switch node versions on the fly giving you a very flexible development environment, i like to use N as is a great tool to manage any version of Node.

nmp nstall n

Grab the latest node version(stable or unstable) but sometimes the build does not complete if it downloads the unstable branch and this in terms has some glitches :

n latest

Install and activate a specified node version

n 0.5.5

Remove a specified node version

n - 0.5.5

Activated nodes are then installed to the prefix /usr/local, which may be altered via the PREFIX environment variable.

To alter where n operates simply export N_PREFIX to whatever you prefer.

Scala MacPorts

If and once you have installed macports there is only one step:

sudo port install scala29

I you ever need to work with different versions you can find more scala macports.

To Manage Scala versions you should also install scala_select which lets you switch the default compiler by symlinking the standard compiler executables in the MacPorts prefix to the selected version.

$ sudo port install scala_select 

# List available scala versions
$ scala_select -l 

# Select one of the available versions.
$ scala_select scala29

That’s it.

You may also would like to have look into Homebrew an alternative package manager for OS X.

As i wanted to try Play Scala i created a simple URL shortener application which was useful to learn some Scala, Play! Scala concepts and paradigms.

On this example we will be using java.security for generation of the md5 of the full url this way we can detect if the url is already present in the database and if it is we just use that url, otherwise we save it and return the new shortUrl We will also usescala.Random and Integer.to_s(36) to generate a Base 36 short url.

The last lib worth mention is the Anorm, SQL data access. Anorm is a data access layer that let us “talk” with databases and as far as i understood, the philosophy of it is that the developer should “Take Control of SQL code”.

Nowadays developers work at very high levels of abstractions and this is good for an accelerated development process but it can come at a cost of efficiency. Therefor i quite sympathize with the way Anorm works. At it will make me remember some SQL practices which have been abstracted from me for a while.

I will walk you through what i did and if you have any remarks or tips to the code please let me know as i am open minded and willing to improve.

The code is available at github

Prerequisites

To get this going you should have scala and the Play! framework installed

You can download Scala on the Scala Language website and if you are on a Mac you can read my how to Install Scala on Mac.

For Play! you can head over to the official Play Framework installation guide as is as complete as it gets.

Generate the application with:

cd {your working directory}

play install scala

play new scalaPlayShortener --with scala

cd scalaPlayShortener && play dependencies

Database Migrations

Play has database migrations support know as (evolutions -> http://www.playframework.org/documentation/1.2.2/evolutions), so lets create our evolution.

cd {your working directory}/scalaPlayShorner && mkdir -p db/evolutions

Create a file called 1.sql and add the following SQL:

# Shortener schema
# --- !Ups

CREATE TABLE Shortener (
 id bigint(20) NOT NULL AUTO_INCREMENT,
 shortUrl varchar(12) NOT NULL,
 fullUrl varchar(4096) NOT NULL,
 fullUrlHash varchar(32) NOT NULL,
 PRIMARY KEY (id)
);

# --- !Downs

DROP TABLE Shortener;

The SQL after # — !Ups runs when you are applying the evolution and consequent SQL, on the other site # — !Downs is run when the migration is being reverted.

Routes

We will use 3 routes, first for the landing page with the form, second for the POST request when user submits the long URL and third the route that dispatches/redirect from the short to the long URL

Open the file in conf/routes and add this routes at the top, the file syntax is the same as in the Java version of the framework.

GET  / Application.index
POST / Application.shorten
GET  /{dispatchUrl} Application.dispatch

Scala Tests

Play Scala comes with scala test which is a great tool/DSL. Those who have used RSpec from Ruby land will see that they are very similar.

The scalatest syntax is very clear and does not let any doubt on what the code is doing, for example:

val url = "http://google.com"

Shortener.create(Shortener(url))

// Fetch Some DB Record
val shortenURL = Shortener.find( "fullUrl={fullUrl}")
 .on("fullUrl" -> url )
 .first()

// The DB Record should not be of type None
shortenURL should not be (None)

shortenURL.get.fullUrl should be (url)

Shortener.count().single() should be (1)

The Above code sample contains a should verb which is made available throughShouldMatchers trait. A must verb is also available through the MustMatchers

The full test case for this example application located at test ShortenerTests.scala:

import play._
import play.test._

import org.scalatest._
import org.scalatest.junit._
import org.scalatest.matchers._

import models._
import play.db.anorm._

class ShortenerTests extends UnitFlatSpec with ShouldMatchers with BeforeAndAfterEach {

 override def beforeEach() {
 Fixtures.deleteDatabase()
 } 

 it should "create and retrieve a Shorten Url" in {
 val url = "http://google.com"
 val url2 = "http://playgramework.org"
 Shortener.create(Shortener(url))

 val shortenURL = Shortener.find( "fullUrl={fullUrl}")
 .on("fullUrl" -> url )
 .first()

 shortenURL should not be (None)
 shortenURL.get.fullUrl should be (url)
 shortenURL.get.fullUrlHash should be ("c7b920f57e553df2bb68272f61570210")
 shortenURL.get.shortUrl should fullyMatch regex ("""[a-zA-z0-9]+""")
 Shortener.count().single() should be (1)

 // add url and increase count
 Shortener.create(Shortener(url2))
 Shortener.count().single() should be (2)

 // try to create an already existent url
 Shortener.create(Shortener(url2))

 //the count should be 2 since we are not saving the url just returning the existent one
 Shortener.count().single() should be (2)

 val shortUrl2 = Shortener.find( "fullUrl={fullUrl}")
 .on("fullUrl" -> url2 )
 .first()

 // the url2 properties
 shortUrl2 should not be (None)
 shortUrl2.get.fullUrl should be (url2)
 shortUrl2.get.fullUrlHash should be ("7faf91bbbde823d7c27ad7aaa17e196e")
 shortUrl2.get.shortUrl should fullyMatch regex ("""[a-zA-z0-9]+""")
 }
}

Model iteration

As mentioned above i access the database width Anorm. Anorm offers a Magic helper which allow us to match a case class to the database schema, however we are not required to match every table field if we don’t need to.

case class Shortener(
 id: Pk[Long],
 fullUrl: String,
 fullUrlHash:String,
 shortUrl:String = { Shortener.convertToBase36 }
)

The main Model interaction is done through an Object which extends the Magic helper. The magic helper provides some convenience methods about which you learn more here. As an example the find helper used on the findFirstByFullUrl method:

def findFirstByFullUrl(url:String) = {
 Shortener.find("fullUrl={fullUrl}")
 .on("fullUrl" -> url)
 .first()
}

Below you will find all of the shortener Model used in modes/shortener.scala .

package models

import java.security._
import java.lang.Integer
import scala.util.Random

import play.db.anorm._
import play.db.anorm.defaults._

case class Shortener(
 id: Pk[Long],
 fullUrl: String,
 fullUrlHash:String,
 shortUrl:String = { Shortener.convertToBase36 }
)

object Shortener extends Magic[Shortener] {

 def apply(fullUrl:String) = {
 val urlHash = Shortener.urlHash(fullUrl);
 Shortener.find("fullUrlHash = {urlHash}")
          .on("urlHash" -> urlHash)
          .first()
          .getOrElse {
            new Shortener(NotAssigned, fullUrl, Shortener.urlHash(fullUrl))
          }
 }

 def convertToBase36():String = {
   Integer.toString(new Random().nextInt(100000),36)
 }

 def findFirstByFullUrl(url:String) = {
   Shortener.find( "fullUrl={fullUrl}")
            .on("fullUrl" -> url )
            .first()
 }

 def findFirstByShortlUrl(url:String) = {
   Shortener.find( "shortUrl={shortUrl}")
            .on("shortUrl" -> url )
            .first()
 }

 def urlHash(url:String) = {
   val md = MessageDigest.getInstance("MD5");
   md.update( url.getBytes() );
   md.digest.map(0xFF & _).map { "%02x".format(_) }.foldLeft(""){_ + _}
 }
}

Controllers

In Play Scala the controllers are singletons object which extend play.mvc.Controller. In our case is the Application controller which has 3 methods in which 2 of them take arguments sent to them via the Routes configuration and via a form.

package controllers

import play._
import play.mvc._

import models.Shortener
import views.Application._

object Application extends Controller {

 def index = {
 // Call the views/Application/index.scala.html
 html.index()
 }

 // Get the POST.ed longUrl field from the submited form
 def shorten(longUrl:String) = {
 Shortener.create(Shortener(longUrl))
 val shortenURL = Shortener.findFirstByFullUrl(longUrl)

 // Call the view
 html.index(shortenURL)
 }

 // Get the dispatchUrl from the Routes Configuration
 def dispatch(dispatchUrl:String) = {
 val shortenURL = Shortener.findFirstByShortlUrl(dispatchUrl)
 shortenURL match {
 case None => NotFound
 case shortenURL:Option[Shortener] => Redirect(shortenURL.get.fullUrl)
 }
 }
}

In the controller above we retrieve the data form our Shortener Model and deal with that data, either by executing a Redirect, calling the NotFound and by display the template view.

For displaying the views we call html.index() and html.index(shortenURL), this call will retrieve the template in views/Applicaion/index.scala.html, so if we split the structure it will be views/{ControllerName}/{ActionCalled}.scala.html. Being ActionCalled .index()and .index(shortenURL). The reason for this is that the templates/views files are special Scala source files.

Now how does the template get the data we have passed as theshortenURLparameter? that bring us to the views.

Views

On the file located in views/Applicaion/index.scala.html i have created very basic template, but important thing is how we declare the values which will be made available for the rest of the template, so on the top of the file you can find:

@(
 short:Option[models.Shortener] = None,
 title:String = "Scala Url Shortener"
)

If look at it closer you will find a nameless function @(etc…) with default parameters. The short parameter will be bound to the formal parameter shortenURL. The @ is used to call Scala code. I am still getting to know the way of doing this style of templates.

There are a few more concepts to grasp with regards to the templating system as how to use @action to invoke controller methods and generate URLs.

Conclusion

I am still getting into Scala and the Play! Framework but for me this is obviously good stuff. I know that the above code can be improved and i will do so upon suggestions and future learnings.

There is one thing that kind bugged me which is the templates as they are different and maybe not so web designer friendly, but i will digg more into them and i know that scalate can be used as an alternative.

Overall this is nice stuff and i would like to know your feedback and tips.

This will be a quick post and Ruby code snippet i have used to automatically scale and resize those images.

The process is simple just get the images in the folder containing the original images, read in each image, call the “scale” method on the images and save the resized images into a new location.

You can also use the Kernel#sleep method to avoid your CPU to get overloaded.

$ gem install RMagick

require 'rubygems'
require 'RMagick'

# get the folder containing the original images
folder = ARGV[0]

# reduce by 35% = 35/100
scale_by = 0.35

# Get the images in the folder
# (you may replace JPG for whatever extension you will be processing )

files = Dir.glob("#{folder}/*.JPG") do |f|
 # read the image
 image = Magick::Image.read(f).first

 # scale the images
 puts "resizing #{image.filename}"
 new_image = image.scale(scale_by)
 new_image.write("resized/#{image.filename}")

 # sleep(5)
end

If anyone has a diferent solution please let me know i would love to know about it.

Static Websites

On static websites you will have to update, create, delete pages individually and manually. For instance if you have a web site with 10 pages and you want to change the footer information this had to be done ten times in every page which is not very effective, creating extra work and this costs money.

So the solution is to go dynamic.

Dynamic Websites

Dynamic websites are powered by Content Management Systems(CMS for friends), this CMS’s provide a powerful way to manage not only content but the web site itself.

If we take the footer example from above if you have a content management system in place you would only need to change the footer information in one place and this change would apply to every page on your site, the advantages are very obvious.

With a good Content management system you will be in control of your web site from one central control panel and will save you to keep paying to web designers or other companies to to make superficial changes or add pages, etc..

Content management systems will cost you more when first developed or incorporated into your current static web site, but if you are serious about your online side of business in my opinion and Content management system is a must, not to mention the future economical savings.

Currently i work with three different Content Managements Systems and each of them are suitable for all tasks and i will help you choose the correct one depending on your needs.

Conclusion

If you wish to have an online presence you really should have a content management system to support you online web site, this will save money and in a long run you will be very happy with the fact that you manage your website by adding, changing content or new features.

Feel free to contact me if you require support in selecting and implementing a Content Management System on your newly created or current website.

The goal of the VCard Website is to direct visitors to any of my projects, portfolio and to prove an easy way for people to contact me on the social networks to which i am linked too.

The original idea for this style of web site was made popular by within the webdesign community by the designer  Tim Van Damme .

This website has quite some time and has been featured in a few popular webdesign blogs side by side with some of the most popular web designers out here.

Below you will a few of the websites that fearured this design.

• Six Revisions Web Design Blog
• Tim Van Damme
• Inspiration Feed

visit joaosilva.co.uk

This project was developed using WordPress Multisite and Buddypress, this two opensource projects combined can provide a very robust solution.

Firstly the initial goal was to provide the fashion community with an easy way to publish content and have their own website. Well the most appealing a solution was to use WordPress 3.0 which was freshly backed and released.

Secondly having a fashion community on board where bloggers could easily share their stories and news made sense, here is where Buddypress came into play.

Fashionblogr.com the site it self was designed by Sofiane Delloue from digitalpublishing.cz which is also the owner and project manager.

On this project my responsibilities were to build and deploy using HTML, CSS, Javascript, WordPress, Buddypress as well as server administration.

visit fashionblogr.com

Fashion-themes.com the site it self was designed by Sofiane Delloue fromdigitalpublishing.cz. I have built the HTML, CSS and Javascript.

As part of this project i have designed and built WordPress themes, the brief for this themes was to have a clean and minimal design which would appeal to the target audience.

These themes were created with the propose of being used on fashionblogr.com a design community.

If you are looking for minimal and full featured wordpress themes you can try out the wordpress themesavailable at fashion-themes.com

To get started and prepared for a search engine optimized website there are three main foundations:

• Good Content Management System
• Standard Compliant and Valid Code
• Readable Content

Good Content Management System

When setting up a website you should have a clear path on how you want your content to be delivered and how will you publish that content, this involves to choose the correct platform or Content Management System(CMS) for your needs.

Currently there are many options available in the market from open source(free) to expensive enterprises solutions.

For 90% of the case an open source solution is more then adequate and in my opinion will be an asset for your business due to its monetary and scalable vantages.

Just keep in mind that it is very important for your website success to define how will you publish and in what platform will you publish your content.

Standard Compliant and Valid Code

If you bout who is checking your web site besides the users one that comes into play is search engine robots, these are complex algorithms that navigate the collecting information about all websites.

These robots will collect data from your website and serve them to peoples search query thought their websites, being the most popular player Google.

Now your code its an important factor on this robots searches, because they crawl your website and if the code does not present errors they will crawl the website at a faster speed and will index the relevant content that you have to offer. In the other hand if all they find is errors these robots will have problems to do a good job and you will be losing upfront to other competitors with valid web sites.

The other aspect of good code is semantic code, this means that your content should be displayed in order of relevance(pretty obvious), but you will be surprised on how many web sites out there do not adware to this good practice.

The last aspect i would like to mention is speed, with good and valid code your website load times will increase and your visitors plus these robots will be very happy for that.

Readable content

Readable content plays a major part on your web site success and with this words i mean that some websites have a very small font, or the colors and tone are not correct, so even if you have fantastic content but people can’t read it obviously they will go somewhere else.

Adding to the above i believe that you should write content for users and not for robots, this is very important because people sometimes focus to much on the search engine results and forget their audience, and this is a terrible mistake to make online.

One last detail i would like to mention is be careful where you display advertisements in your site, if this advertisements create an obstacle to users to reach their goal which is your content, they will give up and all the effort put in place will be useless.

Conclusion

With good content management system, valid code and readable content you will have a very strong advantage over your competitors and you Search Engine campaigns will most likely be a success.

One last word is please be aware of those who guarantee top rankings in no time, those people will rip you off and destroy your online reputation.