Scala for Java Programmers
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Scala for Java Programmers

on

  • 940 views

Introduction to Scala for Java developers

Introduction to Scala for Java developers

Statistics

Views

Total Views
940
Views on SlideShare
940
Embed Views
0

Actions

Likes
0
Downloads
14
Comments
0

0 Embeds 0

No embeds

Accessibility

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
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Scala for Java Programmers Presentation Transcript

  • 1. Intro to Scala for Java Devs Sungard– 4/17/2012
  • 2. Intro•  Eric Pederson –  eric@cpextechnology.com –  Twitter @ericacm –  Sourcedelica.com/blog –  Background in Java, Groovy, Javascript, PHP, etc.•  Using Scala for last two years•  Two Scala apps developed for NYSE in Production
  • 3. Platform at NYSE•  Scala 2.9.1•  JDK 1.6•  Tomcat / JBoss•  Maven•  Using lots of Java libraries –  Spring, Hibernate, CXF, Mule, ApacheMQ –  Bouncycastle, OpenSAML, Velocity, etc, etc.
  • 4. What is Scala?•  Hybrid Object-Functional language•  Statically typed•  Developed by Martin Odersky –  Java Generics –  Java Compiler (1.3+)•  First release in 2003
  • 5. What is Scala?•  Designed for general purpose programming•  Performance on par with Java*•  Scalable –  Designed to write programs ranging from scripts up to huge systems –  You don’t have to use all of the features to be productive*  There  are  some  gotchas  you  have  to  watch  out  for  
  • 6. Why Should I Use Scala?•  Allows you to write very concise code –  Productivity on the level of Groovy / Ruby•  Concurrency-ready•  Excellent interoperability with Java code•  Lots of other reasons…
  • 7. Conciseness•  Code size reduced by 2-3x compared to Java•  Less code == easier to read•  Less code == fewer bugs
  • 8. Conciseness•  Type Inference•  Expressions, not statements•  Higher-ordered functions•  Case classes•  Pattern matching
  • 9. Type Inference•  Variables val  subscrip7onEvents  =  foo()    •  Method return types def  listOfPeople  =  List(“Paul”,  “Eric”,  “John”,  “Mar7n”)    •  Generic type parameters case  class  MyPair[A,  B](x:  A,  y:  B)   val  p  =  MyPair(1,  “foo”)          //  p  is  MyPair[Int,  String]  
  • 10. Type inference•  Java HashMap<String,  Customer>  customers  =                  new  HashMap<String,  Customer>();   customers.add("id1",        new  Customer("Eric",  "917-­‐444-­‐1234");   customers.add("id2",        new  Customer("Paul",  "718-­‐666-­‐9876");  •  Scala val  customers  =  HashMap(                      "id1"-­‐>Customer("Eric",  "917-­‐434-­‐1852"),                        "id2"-­‐>Customer("Paul",  "718-­‐666-­‐9876"))    
  • 11. Expressions, not statementsval  server  =  if  (environment  ==  "development”)  {              val  factory  =  new  MBeanServerFactoryBean              factory.aberProper7esSet()              factory.getObject.asInstanceOf[MbeanServer]  }  else  {              val  clazz  =                            Class.forName("org.jboss.mx.u7l.MBeanServerLocator")              clazz.getMethod("locateJBoss”).invoke(null)  }    //  server is assigned one of the bold values  
  • 12. Expressions, not statementsval  n  =  try  {          userInput.toInt  }  catch  {          case  _  =>  0  }    //  n  is  an  Int,  0  if  unable  to  parse  userInput  
  • 13. Collections API•  Very comprehensive –  For example, over 200 methods on List  •  Higher ordered functions –  foreach,  map,  flatMap,  exists,  forall,  find,  findAll,   filter,  groupBy,  par77on, etc.•  Concise literals•  Immutable and mutable variations
  • 14. Collection Literals•  val  l1  =  List(1,  2,  3)  •  val  m1  =  Map(“name”  -­‐>  “Eric”,  “city”  -­‐>  “NYC”)  •  val  s1  =  Set(Car(“Ford”),  Car(“Isuzu”),  Car(“VW”))  
  • 15. Collections API•  Scala val  groups  =      subscrip7onEvents.groupBy(e  =>  e.subscrip7on.id)    •  Java Map<String,  List<SubscripLonEvent>>  groups  =            new  HashMap<String,  ArrayList<Subscrip7onEvent>();   for  (Subscrip7onEvent  se  :  subscrip7onEvents)  {          ArrayList<Subscrip7onEvent>  seList  =  groups.get(se.subscrip7on.id)          if  (seList  ==  null)  {                  seList  =  new  ArrayList<Subscrip7onEvent>();                  groups.put(se.subscrip7on.id,  seList)          }          seList.add(se);   }    
  • 16. Count characters in documentsTry #1 – Java-esque Scala        var  total  =  0          for  (doc  <-­‐  docs)  {              total  +=  doc.length          }  Try #2 – Use higher order functions        var  total  =  0          docs.foreach(doc  =>  total  +=  doc.length)  
  • 17. Count characters in documentsTry #3 – Use fold docs.foldLeb(0)((accum,  current)  =>  accum  +  current.length)          Try #4 – Use type-classes (eg. Numeric)        docs.map(_.length).sum  Try #5 – Use the view method to turn multiple passes into one        docs.view.map(_.length).sum  
  • 18. Variablesscala>  var  i  =  0  i:  Int  =  0    scala>  i  =  2  i:  Int  =  2    scala>  val  j  =  0  j:  Int  =  0    scala>  j  =  3  <console>:8:  error:  reassignment  to  val    scala>  lazy  val  l  =  expensiveComputa7on()  l:  Double  =  <lazy>    
  • 19. Uniform Access Principlescala>  object  Ints  {            |                  var  i  =  1            |                  val  j  =  2            |                  def  k  =  i  +  j            |  }    scala>  Ints.i  res8:  Int  =  1    scala>  Ints.j  res9:  Int  =  2    scala>  Ints.k  res10:  Int  =  3  
  • 20. Uniform Access Principlescala>  object  M  {            |                    private  var  pm  =  0            |                    def  m  =  pm            |                    def  m_=(in:  Int)  {  pm  =  in  }            |  }  scala>  import  M._    scala>  m  res5:  Int  =  0    scala>  m  =  5  m:  Int  =  5    
  • 21. Case Classes•  Scala scala>  case  class  Car(make:  String,  model:  String,  mpg:  Int)   defined  class  Car       scala>    val  c  =  Car("Honda",  "Civic",  40)     c:  Car  =  Car(Honda,Civic,40)  
  • 22. Case Classes•  Java public  class  Car  implements  scala.Product,  scala.Serializable    {          final  private  String  make,  model;          final  private  int  mpg;          Car(String  make,  String  model,  int  mpg)  {                  this.make  =  make;    this.model  =  model;  this.mpg  =  mpg;          }          public  String  getMake()  {  return  make;  }          public  String  getModel()  {  return  model;  }          public  int  getMpg()  {  return  mpg;  }          public  String  toString()  {  return  “Car(  “  +  make  +  ….  }          public  boolean  equals(Object  that)  {  if  (that  instanceOf  Car)  &&  ……  }          public  int  hashCode()  {  return  19  +  ……  }          public  Car  copy(String  make,  String  model,  int  mpg)  {  …..  }          //  plus  9  other  Scala-­‐specific  methods   }      
  • 23. Case Classes •  Case classes can also have mutable fields and methodscase  class  Car(make:  String,  model:  String,  mpg:  Int,  var  odometer)  {          def  driveMiles(miles:  Int)  {  odometer  +=  miles  }  }       •  In Scala you can define multiple classes per source file
  • 24. Pattern Matching•  Case Classes // Class hierarchy: trait Expr case class Num(value : int) extends Expr case class Var(name : String) extends Expr case class Mul(left : Expr, right : Expr) extends Expr // Simplification rule: e match { case Mul(x, Num(1)) ⇒ x case _ ⇒ e }
  • 25. Pattern Matching•  Match on constants  def  describe(x:  Any)  =  x  match  {          case  5  =>  "five"          case  true  =>  "truth"          case  "hello"  =>  "hi!”        case  Nil  =>  "the  empty  list"          case  _  =>  "something  else”    }  
  • 26. Pattern Matching•  Typed patterns def  generalSize(x:  Any)  =  x  match  {        case  s:  String  =>  s.length          case  m:  Map[_,  _]  =>  m.size          case  _  =>  -­‐1    }  
  • 27. No Checked Exceptions//  Look  ma,  no  throws  clause!  def  foo()  {          throw  new  java.lang.Excep7on  }  
  • 28. Concurrency-readiness•  The future present is many cores•  Writing thread-safe code in Java is very difficult –  Mostly due to shared, mutable state
  • 29. Concurrency-readiness•  Scala –  Excellent support for immutability –  Actors / Futures –  Parallel collections
  • 30. Immutability•  Case classes•  Immutable collections are default –  Copies of collections share data•  val vs. var, val is encouraged•  Method parameters are vals
  • 31. Actors•  Included in standard Scala library•  Simplified multithreading and coordination•  Based on message passing –  Each actor has a mailbox queue of messages•  Implementation based on Erlang
  • 32. Actors        object  Coun7ngActor  extends  Actor  {            def  act()  {                    for  (i  <-­‐  1  to  10)  {                            println("Number:  "+i)                          Thread.sleep(1000)                    }            }    }      Coun7ngActor.start()  
  • 33. Actorsimport  scala.actors.Actor._      val  echoActor  =  actor  {          while  (true)  {                  receive  {                          case  msg  =>  println("received:  ”  +  msg)                  }          }  }  echoActor  !  "hello"    echoActor  !  "world!"    
  • 34. Futures  Return a Future immediately, run func in new thread  scala>  future  {  Thread.sleep(10000);  println("hi");  10  }  res2:  scala.actors.Future[Int]  =  <  func7on0>        Use the Future apply()  method to get the result  scala>  res2()          //  blocks  wai7ng  for  sleep()  to  finish  hi  res3:  Int  =  10  
  • 35. Actors / Futures / STM•  Akka provides more robust Actors and Futures•  Also provides –  Distributed (Remote) Actors –  Software Transactional Memory –  Java API
  • 36. Parallel Collections •  Add .par to collection to get parallel version •  Uses JDK7 fork-join framework •  Example:myData.par.filter(_.expensiveTest()).map(_.expensiveComputa7on())   –  Filter is run in parallel, results are collected, then map is run in parallel
  • 37. Interoperability with Java•  Scala classes are Java classes•  You can pass Scala objects to Java methods and vice-versa•  For the most part, seamless interop –  Cannot use Scala-only features from Java
  • 38. Java Interop Example@En7ty  class  Subscrip7onEvent  {          @Id  @GeneratedValue          var  id:  Long  =  _            @ManyToOne(op7onal=false)          var  subscrip7on:  Subscrip7on  =  _            var  address:  String  =  _            @Index(name="Subscrip7onEventStatus")          private  var  status:  String  =  _          def  deliveryStatus  =  DeliveryStatus.withName(status)          def  deliveryStatus_=(s:  DeliveryStatus)  {  status  =  s.toString  }  }  
  • 39. Java Interop Example@Controller  @RequestMapping(Array("/report"))  class  ReportController  {        class  MessageDto(message:  Message)  {          @BeanProperty  val  id  =  message.id          @BeanProperty  val  address  =  message.address          //  …      }                  @RequestMapping(Array("/messages"))      def  messages(@RequestParam(value="fromDate”)  from:  String,                                                              map:  ExtendedModelMap):  String  =  {                    //…                map.put(“messages”,  asJavaCollec7on(messageDtos))                  “report/messages”              }    
  • 40. JavaConversions•  Add Scala collection API methods to Java collections  import  collec7on.JavaConversions._            import  collec7on.Iterable            import  java.u7l.{List=>JList}      def  goodStudents(students:  JList[Student]):  Iterable[String]  =              students.filter(_.score  >  5).map(_.name)      
  • 41. Named and Default Params•  Named parameters def  resize(width:  Int,  height:  Int)  =  {  ...  }   resize(width  =  120,  height  =  42)  •  Default parameters def  f(elems:  List[Int],  x:  Int  =  0,  cond:  Boolean  =  true)   f(List(1))   f(Nil,  cond  =  false)  
  • 42. By-name Parameters•  Method parameters can be lazily evaluated class  Logger  {          def  debug(msg:  =>  String)  {            if  (isDebug)  doLog(DEBUG,  msg)          }   }     log.debug(“this  “  +  “  is  “  +  “expensive”)    
  • 43. Type Conveniences•  Type Aliases type  MyMap  =            mutable.HashMap[String,  mutable.HashMap[String,  Int]]    •  Import Aliases            import  com.nyx.domain.no7fica7on.{Topic=>DomainTopic}    
  • 44. Mixins•  Multiple implementation inheritance  trait  UserIden7fierCmd  extends  ApiKeyCmd  {            var  userId:  String  =  _          def  getUser  =  {…}  }    trait  RoleIdCmd  extends  ApiKeyCmd  {  var…    def…  }    object  cmd  extends  UserIden7fierCmd  with  RoleIdCmd  {..}  
  • 45. Duck Typingtype  Closeable  =  {  def  close():  Unit  }    def  using[T  <:  Closeable,  S]  (obj:  T)(func:  T  =>  S):  S  =  {            val  result  =  func  (obj)            obj.close()            result  }    val  fis  =  new  FileInputStream(“data.txt”)    using(fis)  {  f  =>          while  (f.read()  !=  -­‐1)  {}  }    
  • 46. More Information•  My Scala Links gist –  https://gist.github.com/1249298