• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Getting Started With Scala
 

Getting Started With Scala

on

  • 7,691 views

This presentation was presented by Meetu Maltiar and Vikas Hazrati @OssCamp on 6th Sep 2009 at Netaji Subash Institute of Technology.

This presentation was presented by Meetu Maltiar and Vikas Hazrati @OssCamp on 6th Sep 2009 at Netaji Subash Institute of Technology.

Statistics

Views

Total Views
7,691
Views on SlideShare
7,272
Embed Views
419

Actions

Likes
15
Downloads
210
Comments
0

9 Embeds 419

http://meetumaltiar.wordpress.com 338
http://xebee.xebia.in 40
http://www.slideshare.net 15
http://webcache.googleusercontent.com 10
http://67.23.46.26 8
url_unknown 4
http://www.yatedo.com 2
http://blog.xebia.in 1
http://algebrahub.com 1
More...

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel

Getting Started With Scala Getting Started With Scala Presentation Transcript

  • Getting Started with Scala Vikas Hazrati - vhazrati@xebia.com Meetu Maltiar - mmaltiar@xebia.com OSScamp Delhi 2009
  • Agenda I. What is FP and OOP? I. Features – Quick comparison with Java I. Introducing Scala – Function Values and Closures – Scalable Languages – Traits – Scala is a Scripting language – Pattern Matching – Scala is Java of future I. End Notes – Scala is OO - Who is using it ? – Scala is Interoperable - Tool support - Learning resources
  • I. What is FP and OOP?
  • What is FP Is a concept where you can pass functions as arguments, to store them in variables, and to return them from other functions.
  • What is OOP? Object Oriented Programming is programming which is oriented around objects Takes advantage of Encapsulation, Polymorphism, and Inheritance to increase code reuse and decrease code maintenance.
  • Scala: FP and OOP language Scala is a object oriented and functional programming language which is completely interoperable with java FP: Makes it easy to build interesting things from simple parts, using – Higher order functions – Algebraic types and pattern matching – Parametric polymorphism OOP: Makes it easy to adopt and extend complex systems using – Subtyping and inheritance – Dynamic configurations – Classes as partial abstractions
  • II. Introducing Scala
  • Scalable languages A language is scalable if it is suitable for very small as well as very large programs. A single language for extension scripts and the heavy lifting. Application-specific needs are handled through libraries and embedded DSL's instead of external languages. Scala shows that this is possible. 8
  • Scala is a scripting language It has an interactive read-eval-print-loop (REPL). Types can be inferred. Boilerplate is scrapped. scala> var capital = Map("US" → "Washington", "France" → "Paris") capital: Map[String, String] = Map(US → Washington, France → Paris) scala> capital += ("Japan" → "Tokyo") scala> capital("France") res7: String = Paris 9
  • Scala is the Java of the future It has basically everything Java has now. (sometimes in different form) It has closures. (proposed for Java 7, but rejected) It has traits and pattern matching. (do not be surprised to see them in Java 8, 9 or 10) It compiles to .class files, is completely interoperable and runs about as fast as Java object App { def main(args: Array[String]) { if (args exists (_.toLowerCase == "-help")) printUsage() else process(args) } } 10
  • Scala is object-oriented Every value is an object Every operation is a method call Exceptions to these rules in Java (such as primitive types, statics) are eliminated. scala> (1).hashCode res8: Int = 1 scala> (1).+(2) res10: Int = 3 11
  • Interoperability Scala fits seamlessly into a Java environment Can call Java methods, select Java fields, inherit Java classes, implement Java interfaces, etc. None of this requires glue code or interface descriptions Java code can also easily call into Scala code Scala code resembling Java is translated into virtually the same bytecodes. ⇒ Performance is usually on a par with Java 12
  • III. Scala Features 13
  • Scala compared to Java Scala adds Scala removes + a pure object system - static members + operator overloading - primitive types + closures - break, continue + mixin composition with - special treatment of traits interfaces + existential types - wildcards + abstract types - raw types + pattern matching - enums 14
  • Scala cheat sheet (1): Definitions Scala method definitions: Java method definition: def fun(x: Int): Int = { int fun(int x) { result return result } } def fun = result (no parameterless methods) Scala variable definitions: Java variable definitions: var x: Int = expression int x = expression val x: String = expression final String x = expression 15
  • Scala cheat sheet (2): Objects and Classes Scala Class and Object Java Class with statics class Sample { class Sample(x: Int, val p: Int) { private final int x; def instMeth(y: Int) = x + y public final int p; } Sample(int x, int p) { this.x = x; this.p = p; object Sample { } def staticMeth(x: Int, y: Int) int instMeth(int y) { = return x + y; x*y } } static int staticMeth(int x, int y) { return x * y; } } 16
  • Scala cheat sheet (3): Traits Scala Trait Java Interface trait T { interface T { def abstractMth(x: String): Int int abstractMth(String x) def concreteMth(x: String) = } x + field (no concrete methods) var field = “!” (no fields) } Java extension + implementation: Scala mixin composition: class C extends Super class C extends Super with T implements T 17
  • Scala Compared to Java class CreditCard(val number: Int, var creditLimit: Int) javap -private CreditCard public class CreditCard extends java.lang.Object implements scala.ScalaObject{ private int creditLimit; private final int number; public CreditCard(int, int); public void creditLimit_$eq(int); public int creditLimit(); public int number(); public int $tag() throws java.rmi.RemoteException; } 18
  • Constructors class Person(val firstName: String, val lastName: String) { private var position: String = _ println("Creating " + toString()) def this (firstName: String, lastName: String, positionHeld: String) { this (firstName, lastName) position = positionHeld } override def toString() : String = { firstName + " " + lastName + " holds " + position + " position " } } 19
  • Statics in Scala 20
  • Higher Order Functions 21
  • Currying & Partial Functions Currying in Scala transforms a function that takes more than one parameter into a function that takes multiple parameter lists. 22
  • Closures You can create code blocks with variables that are not bound. You will have to bind them before you can invoke the function; however, they could bind to, or close over, variables outside of their local scope and parameter list. That’s why they’re called closures. 23
  • Closures 24
  • Traits They are fundamental unit for code reuse in Scala A Trait encapsulates method and field definitions, which can be reused by mixing them in classes Unlike class inheritance , in which class must inherit from just one superclass, a class may mix in any number of Traits Unlike Interfaces they can have concrete methods 25
  • Traits trait Philosophical { def philosophize() { println("I consume memory, therefore I am!") } } class Frog extends Philosophical { override def toString() = "green" } val latestFrog = new Frog println("" + latestFrog) latestFrog.philosophize() val phil:Philosophical = latestFrog phil.philosophize() 26
  • Pattern Matching All that is required is to add a single case keyword to each class that is to be pattern matchable Similar to switch expect that Scala compares Objects as expressions 27
  • Pattern Matching object PatternApplication { def main(args : Array[String]) : Unit = { println( simplifyTop(UnOperator("-", UnOperator("-", Variable("x"))))) println( simplifyTop(BinOperator("+", Variable("x"), NumberOperator(0)))) println( simplifyTop(BinOperator("*", Variable("x"), NumberOperator(1)))) } def simplifyTop(expr: Expression): Expression = expr match { case UnOperator("-", UnOperator("-", e)) => e // Double negation case BinOperator("+", e, NumberOperator(0)) => e // Adding zero case BinOperator("*", e, NumberOperator(1)) => e // Multiplying by one case _ => expr } } 28
  • IV. End Notes 29
  • Tool support – Standalone compiler: scalac – Fast background compiler: fsc – Interactive interpreter shell and script runner: scala – Web framework: lift – Testing frameworks: Specs, ScalaCheck, ScalaTest, SUnit, … IDE plugins for: – Eclipse (supported by EDF) – IntelliJ (supported by JetBrains) – Netbeans (supported by Sun) 30
  • Who’s using it? Open source projects: lift wicket NetLogo SPDE: Scala branch for Processing Isabelle: GUI and code extractor Companies: Twitter: infrastructure Sony Pictures: middleware Nature.com: infrastructure SAP community: ESME company messaging Reaktor: many different projects Mimesis Republic: multiplayer games EDF: trading, … 31
  • Learning Scala To get started: First steps in Scala, by Bill Venners published in Scalazine at www.artima.com Scala for Java Refugees by Daniel Spiewack (great blog series) To continue: Programming in Scala, by Odersky, Spoon, Venners, published by Artima,com Other books are in the pipeline. 32
  • 33
  • Contact Us Vikas Hazrati - vhazrati@xebia.com Meetu Maltiar - mmaltiar@xebia.com www.xebiaindia.com www.xebia.com http://blog.xebia.in http://blog.xebia.com 34
  • References “Programming in Scala” book by Martin Odersky, Lex Spoon and Bill Venners Presentation by Martin Odersky at FOSDEM 2009 http://www.slideshare.net/Odersky/fosdem-2009-1013261 Online book on Scala by oreilly http://programming-scala.labs.oreilly.com/ Magazine for Scala Programming Community http://www.artima.com/scalazine 35