object Check {
   def countcharacter(a: String, b: String) = { //Declaring a method in scala
       if (a.length > b.length) println("The large word is" + a) 
       else  println("The large word is" + b) 
 }

  def main(args: Array[String]) {                 // The main method in scala
      countcharacter("Neelkanth","Sachdeva")     //calling the method
  }

}

object forloopdemo {
  
  val name= new Array[String](4)     // Declaring an Array in scala
  name(0)="This"
    name(1)="is"
      name(2)="an"
        name(3)="array"
  
  def printarrayelem(args:Array[String]):Unit={  

   /*Creating a method named "printarrayelem" with return type "Unit",
   that will print out all the elements in array.  */                                             
                                                     
  for(arg <- args)      
  /* A sample for loop for printing all elements in array. */                                                  
  println(arg)         
}
  
  def main(args: Array[String]) {    //The main method in scala
  printarrayelem(name)
  }
}

3. Constructor in Scala:-

class construct(val name: String, val age: Int) {                
println("This is the example program of primary constructor")
}

object PrimaryConstructor {
  def main(args: Array[String]) {           //the main method.
    val cons = new construct("Neelkanth Sachdeva", 23) 
     /*passing the values for name and age at the time of object creation. */                                                
                                                       
    println(cons.name)      // accessing the value via constructor.
  }
}

In Java, you often have a class with both instance methods and static methods. In Scala, you achieve this by having a class and a “companion” object
of the same name. The class and its companion object can access each other’s private features. They must be located in the same source file.

class companion{
  private var balance=0.0
  private def deposit(amount:Double){      //Declaring a private method
  balance+=amount
  println(balance)
  }
}
object companion {
  def main(args: Array[String]) {
  val n=new companion
/*Accessing the private method of class in its companion object.  */
  n.deposit(78.00)                
   }
 }

5. Bypass the main method :-
In Scala, you need not to have main method always, you can bypass the main method by extending the “App” trait as follows.

object main_alternate extends App{       //extending the "App" trait 
                                         //to avoid main method.
 println("This is the alternate of main")
}

import scala.collection.mutable.ArrayBuffer
object arraybuffdemo {
  val abuf = new ArrayBuffer[Int]()        //Array buffer
  val array = Array(1, 2, 3, 4, 5)         //Simple array

  def main(args: Array[String]) {

    abuf += 1            //Inserting an element to buffer
    println(abuf)

    abuf ++= array      //Inserting a whole array to arraybuffer
    println(abuf)

    abuf.trimStart(1)   //removing one element from 
                         //starting point in arraybuffer
    println(abuf)

    abuf.trimEnd(1)    //removing one element from 
                         //ending point in arraybuffer
    println(abuf)

    abuf.insert(1, 80, 81, 82)  //inserting the three element 
                                //say 80,81,82 at index 1. 
    println(abuf)
       
    abuf.remove(1, 2)   //removing two elements from the index 1
    println(abuf)

 }
}

Enjoiii Scala!!!!

For Inphina, it has been an eventful year. We did projects on lot of new and diverse technologies like Google Fusion Tables, Maps, Google App Engine, Lift, Scala and lot more. Our partners list also increased substantially this year and we got opportunity to work with organizations from Singapore, Australia, Germany, UK, USA and of-course India. We started with CSD (Certified Scrum Developer) program and were the first one to execute it in India. Along with many successful public and private courses in India, we were able to take it outside India and did our first International CSD course in Kathmandu, Nepal. Most importantly, we had great fun and learning all through-out the year. We would like to thank all our partners for their confidence and support.

On behalf of everyone at Inphina, we would like to wish you and your dear ones a Merry Christmas and happy times in the year ahead.

• (In case of migration) Substantial efforts in adapting the application code base to Google Datastore specifications
• Potentially huge data-migration efforts
• Vendor Lock-In as both the application code and data residing in Datastore can’t be taken to an in-premise Infrastructure or another cloud platform seamlessly

Keeping all these requests and potential business opportunities in mind, Google has recently announced Cloud SQL.

What is Google Cloud SQL

• It’s a Relational Database on Cloud offering from Google.
• Offers MySQL Database environment with JDBC support for Java applications and DB-API support for Python applications.
• Being a service on Cloud, it offers traditional advantages of any Cloud service like no maintenance, administration, replication and backup efforts
• To ensure high-availability, data gets replicated across multiple geographic regions
• Easy to use Web-Interface for managing multiple Instances

Google Cloud SQL & Google App Engine

A very good integration has been provided for your applications running on Google App Engine to use Google Cloud SQL as back-end storage mechanism. Furthermore, one SQL instance can be shared across multiple Google App Engine applications. This feature should be quite helpful as often we have a family of Web Applications for different user-requirements but still sharing the same Database.

Getting Started

Cloud SQL is still in limited preview mode so you need to request access for the same. More information is available here.

Once you have got access, you can visit Google APIs Console and should be able to see Google Cloud SQL tab on the left side menu. You can create a new Cloud SQL instance from there. During the creation, you can

• Specify the storage capacity (current options are 1GB, 5GB and 10 GB)
• Specify one/more App Engine Application ID’s allowed to access this DB instance. It should be noted that multiple applications can access one Cloud SQL instance or one application can access multiple SQL instances.

Once an instance is created, you can access it either through API Console’s Web Browser SQL prompt or through a command line tool from your computer. Detailed instructions for downloading and configuring command line tool are available here. To quickly get going, we will use Web Browser. Once inside SQL prompt, we can execute commands as if we are working on local MySQL Database installation. Do keep in mind that all identities in Google Cloud SQL are case-sensitive i.e. Entries and entries are considered different tables.

Integrating GAE Application with Cloud SQL

For Java developers, detailed instructions are available here. Similar instructions for Python can be accessed here. Following the steps, I was able to get an application on GAE accessing Cloud SQL Database in less than 15 minutes. During development stages, you can also test the application behavior accessing your local MySQL Database. Configuration steps for the same are provided here

Export/Import Cloud SQL provides the possibility of importing your existing MySQL data to Cloud SQL Database. This feature is very important when we are thinking of migrating our existing in-premise applications to Cloud. Similarly if for some reasons, we want to move our applications from GAE platform, an export utility is also provided. In both the cases, though we need to pass via Google Cloud Storage, yet another Service offering from Google to store your data on cloud. Detailed instructions about exporting and importing data are provided here

Usage Stats You can access usage statistics on variety of parameters and across multiple time-lines through your instance dashboard. As the service is currently in preview mode, it’s usage is free but once Google launches it officially it will most likely be a paid service. This would then be an important place for determining possible improvement areas in your application for cost and performance optimizations.

Conclusion

I think it is big positive addition for increasing the reach of GAE platform inside enterprises. I am yet to try it on a serious project but the integration looked quite straightforward. Possibility of accessing the same instance from multiple GAE applications also appears to be a good feature while designing or migrating multiple applications using same Database. One of things which I feel lacking is inability to access Cloud SQL instance from applications outside Google App Engine environment. This may be a bottleneck when we think about phased migration of an application family using the same Database instance or one of the applications can’t be deployed on GAE platform because of some reasons. Workarounds are possible but ideal solution would be to provide REST Service to access the instance from anywhere. Hope this is in future pipeline. Looking forward to hearing your comments and experiences on Cloud SQL and GAE.

class Boot extends Loggable {
  def boot {
   LiftRules.addToPackages("XYZ")
.....
.....
} }

 LiftRules.httpAuthProtectedResource.prepend{
      case (Req("html_page_name":: Nil,_,_)) => Full(AuthRole("admin"))
      case (Req("securepage":: Nil,_,_)) => Full(AuthRole("admin"))
                       
      
// Just mention the above code for page on which you
// want to implement the http authentication.   

    }

LiftRules.authentication = HttpBasicAuthentication("Authenticate Yourself") {      
      case("user_name","password",req) => {
        logger.info("Authentication Succeeded...Welcome!!")
         userRoles(AuthRole("admin"))
         true
      }
    }

Note:- Don’t forgot the following basic imports:

import common.{Loggable, Full}
import http._
import auth.{userRoles, HttpBasicAuthentication, AuthRole}

hg branches //shows all the branches present in the repository

hg branch new_branch_name //creates a new named branch

hg commit //commits all the changes locally to the newly created branch
hg push --new-branch //pushes all the changes of this branch along with the branch to mercurial server

hg pull //gets all the changes on default as well as other branches
hg update -C branch_name //switches to the branch

hg merge default //merges all the changes from default branch to your current working branch
hg commit //commits all the changes in your current working branch
hg push //pushes all the change-sets into the repository for other members to use them

For more detailed information on branching, please refer to branching tutorial available on Mercurial site.

1. First of all you have to install simple-build-tool(sbt) on your machine. (Know more about it Here )

2. After installing simple-build-tool(sbt), Just create a directory for your project say “Test” , enter in to directory and just say “sbt” as:

nsachdeva@nsachdeva-Vostro-3700:~/Test$ sbt

3. “sbt” will prompt you to ask for creating new project, just press “y” & give the Name to your project as shown in Fig. :

.

4. Now for creating the lift project, you’ll use a processor to generate the structure and default files you’ll need to start working on the application.From the shell, run this command:

*lift is org.lifty lifty 1.6.1

5. Now you have to execute the following command to populate a blank SBT project with Lift web specialities.

> lift create project-blank

6. Just give the name of your main package & the version of Lift you want to use, when it prompt for ask and then you will obtain the following type structure of your project.

7. After obtaining this point, proceed by a “reload” & “update”.This will download all the dependencies required.

8.Start the jetty and check the running application at http://localhost:8080.

Importing the project in “IntellijIdea”:

you can now import the project on any platform with which you want to work e.g for importing the project in intellijIdea just run the following commands. This will generate the “Test.iml” file within the project structure and you will be able to import this project in IntellijIdea.

>  *sbtIdeaRepo at http://mpeltonen.github.com/maven/
 > *idea is com.github.mpeltonen sbt-idea-processor 0.4.0
....
....
 > update
....
....
 > idea

$ play install scala

$ play new Test --with scala

$ play idealize Test

$ play run Test

Now the created application can’t be directly imported in intellijIdea. Now do it as elaborated follow:

6. Create the new project in IntellijIdea. The location of the project must be the same as the directory where the play project is created.Don’t forget to uncheck the create module option because the created play project itself acts as a module.



7.Now select ‘Project Structure’ option from the file menu. Click the Module option and press the “+” button. Select the “Import existing module” option and then point towards the (.iml) file.



8.Let the Module selected,Then select the ‘tmp/generated’ directory in the right one tree and press the ‘Sources’ button. The HTML template pages are converted to scala source files by Play ,these source files are to be included in the project along with the source files in the Test directory.



9.Select Global Libraries > scala-compiler-2.9.1, Then press the ‘Attach Classes’ button and navigate to the ‘lib’ directory in your Scala 2.9.1 directory. Then select the following files & press Apply.
-scala-compiler.jar
-scala-library.jar



10. Now add another global library as Global Library > scala-library-2.9.1, containing the files scala-dbc.jar, scala-library.jar and scala-swing.jar. Select these files and press OK.

11.Now go to the Modules > Dependencies, press Add button to add new library called “scala-library-2.9.1″ to dependencies.



12. Go to Module,select the scala under Test branch and set the compiler library to the presented one on your machine e.g on my machine this is the “scala-compiler-2.9.1″.



13.Save the Project Structure by clicking the “Ok” button.Again verify the project at http://localhost:9000. Your Project development environment is now ready.

Here we will discuss about creating the menus in Lift. These are the approaches to create a menu:

• Define the url names and routes directly in Boot.scala.
• Create the seperate Singleton for defining menu items.

Let us see how this works:

Define the url names and routes in Boot.scala

class Boot {
  def boot {
    // where to search snippet
    LiftRules.addToPackages("demo.helloworld")

    // Build SiteMap
    val entries =
      Menu(Loc("Home", List("index"), "Home"))::
      Menu(Loc("Items", List("items"), "Items")) ::
      Menu(Loc("Search", List("search"), "Search")) :: Nil

    // Sitemap
    LiftRules.setSiteMap(SiteMap(entries:_*))

  }
}

And here is the output:

Create the seperate Singleton for defining menu items

We will define the sitemap in Boot.scala. Sitemap will obtained from the Application Singleton

class Boot {
  def boot {
    LiftRules.setSiteMap(SiteMap(Application.sitemap: _*))
  }
}

Now define your menu items in this seperate singleton say "Application" singleton.

object Application {
  // Sitemap
  val sitemap = List(
    Menu.i("Items") / "items",
    Menu.i("Search") / "search"
  ) ::: User.menus
}

When working with html pages always provide the links to pages corresponds to as defined in your singleton's sitemap e.g

  <li><a href="/items">Items</a></li>
  <li><a href="/search">Search</a></li>

Lift will search for corresponding HTML pages defined either in Boot.scala or in Application.scala in src/main/webapp folder.

Here’s a little Node.js utility that does the same. While working on Flex with gedit (or any other text editor), just keep “hotflex” running in the background. It watches all MXML and AS3 files and rebuilds the project on save.

Screenshots

Dependencies

Node.js and NPM are required, refer to – Setup Node.js and NPM on Ubuntu

For notifications on Ubuntu, install libnotify-bin:

    sudo apt-get install libnotify-bin

Install

From NPM:

    sudo npm install hotflex -g

From GitHub

    git clone git://github.com/Srirangan/hotflex.git
    cd hotflex
    sudo npm install -g

Configure

You will need to create a hotflex.json file containing the following parameters:

    { "source": "./src/main/flex/main.mxml"
    , "sourceFolder": "./src"
    , "target": "./bin/main.swf"
    , "lib": "./lib"
    }

Run

Execute hotflex from the folder containing the hotflex.json file, preferably your project root.

hotflex

Meta

GitHub repository – https://github.com/Srirangan/hotflex
NPM – http://search.npmjs.org/#/hotflex

To do

• Integration with Adobe Flex Compiler Shell fcsh for faster builds
• Integration for Growl for OSX notifications. Currently notifications work for Ubuntu.