Friday, June 29, 2012

Entity Framework 4.3 - Code First - ManyToOne

ManyToOne relationship is a typical scenario on ORM namespace. Implementing ManyToOne relationship in Entity Framework is similar to other ORM framework like hibernate or JPA. You will just have to annotate the field and add some parameters on it.

There are three ways (what II know so far)  to create a ManyToOne relationship in EF:

  1. Using the default behavior
  2. Having a Column with the same name as the Primary Key Field on the entity on relation.
  3. Using annotation ForeignKey

In default behavior, you just have to create a field which has the type on the entity on relation and use the default mapping for it.

Example: A Book has ManyToOne relationship to Author.

public class Author {
public int AuthorID { get; set; }
public String FirstName { get; set; }
public String LastName { get; set; }
public String MiddleName { get; set; }

public class Book {
public int BookID { get; set; }
public String Title { get; set; }
public Author Author { get; set; }

This will create a table Author with field AuthorID, FirstName, LastName and MiddleName and Book table with field BookID as PK, title and FK Author_AuthorID.

To create a column with the same name as the primary key field on the entity on relation, you should modify Book class like this:

public class Book {
public int BookID { get; set;}
public String Title { get; set; }
public int AuthorID { get; set; }
public Author Author { get; set; }

This class will generate a table having BookID as PK and AuthorID as FK linked to Author. The requirements to have the relation is that FK and PK field must have the same name. If the PK name changes the FK name must be change too.

Lastly, you can use the ForeignKey annotation, which is my recommended  approach because here you can explicitly give the FK name and where it will be linked to.

public class Book {
public int BookID { get; set; }
public String Title { get; set; }
public int WrittenBy{ get; set; }
public Author Author { get; set; }

This modification will create Book table with WrittenBy as FK which represents the Author.

Hope this helps. :)


Tuesday, June 26, 2012

Deprecated in C#

I have been doing a lot of MVC3, Razor thing for a month. Last night, I needed to label a method to be deprecated (just like in java). I tried doing: [Deprecated] but it wasn't working.

After few minutes of googling, I figured out that the equivalent of Deprecated for C# is Obsolete, I discovered it was:
[Obsolete("Reason Why")] 
which is same to java, where in you have to annotate it either class, method or field.

Monday, March 12, 2012

Deploying Existing Play! Application to Jelastic

If you had an existing play application and you want to put it on Jelastic, the easiest way is to use Jelastic Plugin on Play!.

The Requirement:
  • You need to have an existing Jelastic Envorinment (if you’re Play! application used a database, your environment must have database enable and also configured (means you have your database create with appropriate user assigned to it)
  • Your application must use Play! version must be 1.2.x.

  1. On your application.conf add this jelastic configuration

jelastic.api.login and password are your credentials to log onto jelastic app controller. Jelastic.api.context specifies where the application will be deployed, in the example ROOT means it is deployed and accessible by the domain name which is If I put app on jelastic.api.context, my application will be deploy on app context and can be access on jelastic.api.environment which is the name of your environment defined on your apihoster.

Moreover, jelastic.api.apihoster can only have two value which are: (host on Europe), and (host in North America).

  1. Configure your jdbc on application.conf.



You can define this on the phpMyAdmin of jelastic.
  1. Increase your db.pool.timeout to 10000ms of application.conf


  1. Deploy your application to jelastic cloud by (must be on the application directory):

play jelastic:deploy

This will take a while depending on your internet upload speed, this will compile your application and create a war file and then will upload it to jelastic. If it is finish, you can now access your application. In my example, I can access my application on

It seems that jelastic plugin can only work the default environment specified on application.conf, so I created a new environment that I named localhost for my localhost testing environment.

If I am testing my application locally, I will execute: play run --%localhost

Hope this can help you. :)


Tuesday, March 6, 2012

Maven with Scala and Lift

  1. Use this lift-archetype-basic archetype which is hosted on

mvn archetype:generate -DarchetypeGroupId=net.liftweb -DarchetypeArtifactId=lift-archetype-basic_2.9.1 -DarchetypeRepository= -DremoteRepositories= -DgroupId=com.dynamicobjx -DartifactId=lift-chat -Dversion=1.0
  1. This will prompt if you want the default version and configuration. Then you should change scala version to latest version. As of now the version is 2.9.1, that also change lift version which is 2.4.

  1. If you had error on dependency life-mapper, change the dependency definition by changing artifactId to life-mapper_2.9.1.

  1. If you had an error on test classes, this is due to its incompatibility to scala 2.9.1. Therefore, you have to change its artifact id of org.scala-tools.testing from specs to specs_2.9.1 and make the version to 1.6.9.


Now, resolve all the dependencies and make the project an eclipse project (eclipse is my prefered IDE) by executing:
mvn dependency:resolve eclipse:eclipse -DdownloadSources=true -DdownloadJavadocs=true

This will download all the dependencies you defined on pom. You explicitly also say to download sources and javadocs using -DdownloadSources=true -DdownloadJavadocs=true (parameter for eclipse:eclipse). eclipse:eclipse is the command that let the maven project to be open on eclipse, this goal create files like .project, .classpath, .wtpmodels and .components that is needed by eclipse.

After that you can now import it to your eclipse. The structure of the project must be like this:

The project name will be the artifactid- the source file is categorized into two: one source file for testing and another for your actual source code. It will also generates a src/main/webapp directory, that contains all the *.html and public files like image, css and javascript.

To run the project you use:
mvn jetty:run

To run, with auto-compile if source code is change use this:
mvn scala:cc

If you want an on-the-fly reloading of changes made on Java class file, try to use JRebel. Right now, I don’t add it to my dependencies.

After running jetty:run goal, the output project can be seen on

At the end of today’s experience of mine on scala and lift, I found out that the Boot.scala file is the main Class of the project and its main page is index.html based on the sitemap() method of Boot class.

<lift:surround with="default" at="content">
<h2>Welcome to your project!</h2>
      <span>Welcome to lift-chat at <b:time/></span>

This means that this html will be surrounded by the default.html content, where the enclosing content of list:surround will be placed on default.html on the place where lift:bind name=”content” is defined.
<html xmlns="" xmlns:lift="">
  <div class="container">
    <div class="column span-12 last" style="text-align: right">
      <h1 class="alt">lift-chat<img alt="" id="ajax-loader" style="display:none; margin-bottom: 0px; margin-left: 5px" src="/images/ajax-loader.gif"/></h1>


    <div class="column span-6 colborder sidebar">
      <hr class="space" />
      <lift:Menu.builder />
        <lift:Msgs showAll="true"/>
        <hr class="space" />

    <div class="column span-17 last">
      <lift:bind name="content" /> <!-- this is where the content of index.html be injected -->

    <hr />
    <div class="column span-23 last" style="text-align: center">
      <h4 class="alt">
        <a href=""><i>Lift</i></a>
       is Copyright 2007-2010 WorldWide Conferencing, LLC.  Distributed under an Apache 2.0 License.</h4>

(On index.html) Also <b: time> is also a binding tags, in here the value of b:time is defined on Helloworld.howdy. The binding tags is <lift:hellowWOrld.howdy>. in howdy method, they bind the b:time tags to the current time and date.


Saturday, February 25, 2012

List of maven archetype available for Lift-Scala

All the stated archetype are host in, all of this archetypes group id is net.liftweb:
* means 2.7.7/2.8.0/2.8.1/2.9.1 pattern
  • archetypes_*
  • lift-archetype-basic_*
  • lift-archetype-blank_*
  • lift-archetype-jpa-basic_*
  • lift-archetype-jpa-blank-single_*
  • lift-archetype-jpa-blank_*
  • lift-archetype-sbt_*

Just execute this command on your console with this pattern:
mvn archetype:generate -DarchetypeGroupId=net.liftweb -DarchetypeArtifactId=-DarchetypeRepository= -DremoteRepositories= -DgroupId=. -DartifactId= -Dversion=1.0

If I want to use the lift-archetype-basic_2.91 to create a ebook-repo project, i will execute:

mvn archetype:generate -DarchetypeGroupId=net.liftweb -DarchetypeArtifactId=lift-archetype-basic_2.9.1 -DarchetypeRepository= -DremoteRepositories= -DgroupId=com.lmn -DartifactId=ebook-repo -Dversion=1.0

If doesn’t work as archetype and remote repository try to use this:


Sunday, February 19, 2012

Scala - My Three Hours Exploration

Before we start, you can run the Scala Interpreter on Eclipse with Scala Plugin by going to Window -> Show -> Scala Interpreter then you can execute snippets of code on it.

Everything in Scala is expression. Moreover, Scala interpretation will automatically assign the proper data type for the result of an expression like the provided example below:
1 + 1
result: Int = 2

In the given, Scala determined the result of adding one to itself will be an integer.

Difference between Values and Variables:

Values (val) are expression that is once linked to an expression that will never be reassigned to another expression. It's like a variable defined with final in java
Variables (var) that are expressions that can be rebind.

val two = 1 + 1
two: Int = 2

two = 2 + 2
error: reassignment to val

var three = 2 + 1
three: Int = 3

three = 3 + 3
three: Int = 6

Function in Scala
In scala, you can create function with def:
def functionName(identify: dataType, ...) : returnType = (expression)

def addOne(m: Int): Int = m + 1
addOne: (m: Int)Int

You can use know addOne by:
val four = addOne(3)
four: Int = 3

You can also leave off parameters of function doesn’t have params. On the other hand, if the return type can also not be specified, you can try the following:
def ten() = 5 + 5
three: ()Int

Int = 10

Int = 10

You can also create anonymous functions.
(identify: datatype, ..) => (expression)

(x: Int, y: Int) => x + y
(Int) => Int =

You can pass anonymous functions around or save them into vals or vars.

val add = (x: Int, y: Int) => x + y

var result= add(5,23)
result: Int = 28

If your expression is more than one line enclose it with {}. This is also true for anonymous function shown below:

def displayResult(x: Int, y: Int): Unit = {println("sum = " + (x + y))}

Scala has this new Partial Application (which is something new for me). Here you can partially apply a function with an underscore, which gives you another function:
val add2 = adder(2, _:Int)
add2:(Int) => Int =

Int = 5

Curried function (something new to me also)

This is a technique of transforming a function that takes multiple arguments (or an n-tuple of arguments) in such a way that it can be called as a chain of function, each with a single argument which technique is present in scala by:

def multiply(m: Int)(n:Int): Int = m * n

val timesTwo = multiply(2)(_)


In the example, multiply take in one parameters which is m and returns a function as a result, then calls this function, passing the second parameters. This function computes the value and return the final result. Let's think of it as a method with an anonymous inner class.

Making Function a Curried (in here I Curried add function)

Syntax for methods that can take parameters of a repeated type:
def capitalizeAll(args: String*) = { { arg =>

this is like the ellipse (..) in java


class Calculator {
 var brand: String = "HP"
 def add(n: Int, m: Int): Int = {
   n + m

val calc = new Calculator

Class with constructor

class Calculator(var brand: String) {
 var color: String = if (brand == "HELLO") {
 } else {
 } //everything is scala really is an expression

 def add(n: Int, m: Int): Int = {
   n + m

var calc = new Calculator("Cann")

In first line, you defined a calculator with brand as a variable member and also you defined a constructor for Calculator class accepting a String that will be the value of brand.

Inheritance on Scala

class ScientificCalculator(brand: String) extends Calculator(brand) {
 def log(m: Double, base: Double) = math.log(m) / math.log(base)

same in java, scala uses extends for inheritance.

Overloading methods

class EvenMoreScientificCalculator(brand: String) extends ScientificCalculator(brand) {
 def log(m: Int) = log(m, math.exp(1))

Similar to interfaces in Java, traits are used to define object types by specifying the signature of the supported methods or variables. Unlike Java, Scala allows traits to be partially implemented, i.e. it is possible to define default implementation for some method.

trait Car {
 val brand: String

class BMW extends Car {
 val brand = "BMW"

trait Similarity {
 def isSimilar(x: Any): Boolean
 def isNotSimilar(x: Any): Boolean = !isSimilar(x)

class Point(xc: Int, yc: Int) extends Similarity {
 var x: Int = xc
 var y: Int = yc
 def isSimilar(obj: Any) =
   obj.isInstanceOf[Point] &&
   obj.asInstanceOf[Point].x == x

Function can also be generic and work on any type. This is like generic typing in java. Types uses square bracket like:

trait Cache[K, V] {
 def get(key: K): V
 def put(key: K, value: V)
 def delete(key: K)

method with types

def remove[K](key: K)

Class with type

class Stack[T] {
 var elems: List[T] = Nil
 def push(x: T) { elems = x :: elems }
 def top: T = elems.head
 def pop() { elems = elems.tail }

Calling a class with type

val stack = new Stack[Int]

Apply method

In Scala, any object that has an apply method can be called with the .apply omitted.

class Array{
def apply(index:Int) = {println(index)}

2 ways to call apply:
val a = new Array()


Object in scale used to hold single instances of a class. (Singleton)

object Timer {
 var count = 0

 def currentCount(): Long = {
   count += 1

to call currentCount:

Difference between Class and Object

A class is a definition, a description. It defines a type in terms of methods and composition of other types while object is a singleton, object has no constructor (one instance on one application)

This is my first time to write about programming language and I get pleasure from it . Scala is a great and well- designed language. It’s better than java in almost all aspects (too early for my conclusion, I just employ it in 3 hours) and more fun than ruby (being playing with ruby with rails framework for almost 3 months now). I believe that the community is not that large compare to ruby or java but it’s a great language to explore. Hope to use it in real action someday.