Inphina Thoughts

Scala is a multi-paradigm programming language that combines the features of object-oriented programming and functional programming. The word “Scala” refers to “Sca(Scalable)+la(Language)” i.e designed to grow with the demands of its users. Scala runs on the Java Virtual Machine.

Here We’ll discuss about some of the basic concepts in Scala that make it distinct from other programming languages.Let us start with some of the following:


1. Simple method in scala:-

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!!!!

Festival and Holiday season is all around us. Many of us are already on holidays, taking well deserved break and having fun with family and friends. This is also a time to sit back, take a look how things went in past 12 months and plan for the coming year.

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.

Lift web framework accommodate a no. of conspicuous features that are implemented in a unique and solitary way as compared to other frameworks. Here we’ll discuss about the basic “Http authentication” mechanism for security in Lift.

What is ‘LiftRules’ singleton ?
Nearby all configuration parameters for the http requests and response are defined in LiftRules singleton. The important thing to notice is that we can only change the configuration parameteres of LiftRules only during boot but not at other times. You can find more about LiftRules Here.

Now for our purpose of Http authentication what all you have to do , is to add some Lines of code using the LiftRules singleton present in lift, in to your Boot.scala File and you’ll find all gets done for a basic http authentication.

Let us have a look to the steps for doing it ::

*Firstly in your Boot.scala file make the class extends Loggable(part of “net.liftweb.common”) as :

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}

Wishing you all a very Happy, Joyous and Fun-Filled Diwali 2011. We sincerely Thank you for all your support and hope the same for years to come.