A pragmatic introduction to scala
Download
1 / 41

A Pragmatic Introduction to Scala - PowerPoint PPT Presentation


  • 124 Views
  • Uploaded on

A Pragmatic Introduction to Scala. Magnus Madsen. Presenting Scala:. An alternative to Java. Why I like Scala:. object-orientated and functional elegant and concise unrestrictive – gives freedom of choice Scala makes me a happier programmer!

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' A Pragmatic Introduction to Scala' - dyanne


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
A pragmatic introduction to scala

A Pragmatic Introduction to Scala

Magnus Madsen


Presenting scala
PresentingScala:

An alternative

to Java


Why i like scala
Why I like Scala:

  • object-orientated and functional

  • elegant and concise

  • unrestrictive – gives freedom of choice

    Scala makes me a happier programmer!

    Warning: Scala is the gateway drug to Haskell


  • A playground for fun stuff
    A Playground for Fun Stuff:

    • Engineering Perspective:

      • Actor-based Programming

      • Embedded DSLs, and more ...

    • Research Perspective:

      • Higher-Kinded Types

      • Delimited Continuations

      • Abstract Types, and more ...


    A used car analogy
    A Used Car Analogy

    Real

    classCar {

    var frontRight: Wheel;

    var frontLeft: Wheel;

    var backRight: Wheel;

    var backLeft: Wheel;

    }

    classWheel {

    ...

    }


    Quote
    Quote

    […] I can honestly say if someone had shown me the Programming in Scala book back in 2003 I'd probably have never created Groovy.

    James Strachan

    (creator of Groovy)


    Case study minitajs
    Case Study: MiniTAJS

    An inter-procedural dataflow analysis

    • a scaled down version of TAJS

    • has lots of cool stuff:

      • abstract syntax trees, control flow graphs, etc.

      • lattices, transfer functions, etc.

    • about 4500 lines of code

      • of which 90-95% are in functional style


    Main scala
    Main.scala

    package dk.brics.minitajs

    object Main {

    def main(args: Array[String]) {

    val options = Options.read(args.toList)

    Analysis.run(options)

    }

    }


    Options scala
    Options.scala

    case class Options(inputFile: File,

    context: Boolean,

    recency: Boolean,

    lazyprop: Boolean,

    ...);


    Case classes the bread and butter
    Case Classes: The bread and butter

    • A case class declaration:

      • case class Options(inputFile: File, ...)

    • Automatically gives us:

      • getters and setters

      • .equals() and .hashCode()

      • .toString()

      • .copy()

      • .apply()

      • .unapply()


    Options scala1
    Options.scala

    object Options {

    def read(args: List[String]): Options = {

    val context = args.exists(_ == "--context");

    val lazyprop = args.exists(_ == "--lazy");

    ...

    Options(new File(args.last), context, recency, ...);

    }

    }


    Bool scala
    Bool.scala

    abstractsealedclass Bool {

    defjoin(that: Bool): Bool = (this, that) match {

    case(TrueBool, TrueBool) => TrueBool;

    case (TrueBool, FalseBool) => AnyBool;

    ...

    }

    }

    case object AnyBool extends Bool;

    case object TrueBool extends Bool;

    case object FalseBool extends Bool;

    case objectNotBool extends Bool;


    Value scala
    Value.scala

    case class Value(..., bool: Bool, undef: Undef, ...) {

    defisMaybeTrue: Boolean = (bool eq TrueBool)

    || (bool eq AnyBool);

    defjoinUndef: Value

    = copy(undef = undef.join(MaybeUndef));

    }


    Latticeops scala
    LatticeOps.scala

    abstract classLatticeOps(...) extendsContextMixin

    withRecencyMixin

    with PropagationMixin

    trait PropagationMixin {

    def propagate(state: BlockState, info: PropagateInfo,

    lattice: Lattice): Lattice;

    }

    new LatticeOps(...) with CallSensitivity

    withRecencyAbstraction

    with LazyPropagation



    Arguments1
    Arguments

    Problem: In functional programming argument lists grow and grow

    Solution: Wrap arguments up inside a data type. In Scala this translates to a case class.


    Example
    Example

    defpropagate(state: BlockState,

    sourceContext: Context,

    sourceBlock: BasicBlock,

    targetContext: Context,

    targetBlock: BasicBlock,

    lattice: Lattice): Lattice

    def propagate(state: BlockState,

    info: PropagateInfo,

    lattice: Lattice): Lattice


    Mutability!

    defpropagate(s: BlockState, i: PropagateInfo,

    l: Lattice): Lattice = {

    lattice.getState(i.targetContext, i.targetBlock) match{

    caseReachable(targetState) => {

    if (state != targetState) {

    queue.enqueue(i.targetContext, i.targetBlock);

    }

    lattice.putState(i.targetContext, i.targetBlock,

    targetState.join(s));

    }

    caseUnreachable => {

    queue.enqueue(i.targetContext, i.targetBlock);

    lattice.putState(i.targetContext, i.targetBlock, s);

    }

    }

    }


    Limited mutability
    Limited Mutability

    Problem: Whenever new flow enters a basicblock it must be added to the solver queue

    Potential Solution: We could modify all functions to return a pair where the last component is the set of basicblocks that must be enqueued


    But the stack is deep
    But the stack is deep

    Solver.Solve ->

    BlockTransfer.transfer ->

    BlockTransfer.transferCallBlock ->

    LatticeOps.functionEntry ->

    LazyPropagation.functionEntry ->

    LazyPropagation.propagate

    • Not feasible to modify all return types

    • Instead we use a mutable queue!


    But the stack is still deep
    But the stack is still deep!

    How do we get a reference to the queue???

    • We could use a global reference

      Or we could use Scala's implicits:

      class BlockTransfer(...)(implicit q: Queue)

      class LatticeOps(...)(implicitq: Queue)



    Some of the bad stuff
    Some of the Bad Stuff

    • Death Traps

    • Debugging

    • Compiler Warnings

    • Compilation Times


    Death trap
    Death Trap

    case class BasicBlock(var successors: Set[BasicBlock]);

    val a = BasicBlock(Set.empty);

    a.succesors = Set(a);

    a == a;




    Compilation is slow
    Compilation is Slow

    • Compiling miniTAJS takes 35 seconds

      • 4500 lines of code

      • 113 classes + 40 objects = 580 .class files

    • Why?

      • Scalac is written in Scala - i.e. it runs on the JVM

      • Scalac must type-check both Java and Scala

      • Scalac must do local type inference


    Functions objects does it work
    Functions + ObjectsDoes it work?

    No, not really

    (but...)


    Functions objects
    Functions + Objects

    • Fundamental problem:

      • Functional Programming = Immutability

      • Object-orientated Programming = Mutability

    • Immutable objects are not really objects

    • Mutating functions are not really functions


    Functions objects1
    Functions + Objects

    A proposed solution:

    • Split the program into FP and OO parts

    • Decide whether some data should be immutable or mutable (i.e. targed for FP or OO programming)

    • Prefer immutable data, otherwise use mutable data

      Not a silver bullet


    Recent history
    Recent History

    • Scala 2.10 Milestone 1 (Januar 2012)

    • New Eclipse Plugin (January 2012)

    • New IntelliJ IDEA Plugin (December 2011)

    • Scala 2.9 (May 2011)

      • parallel collections

    • Scala 2.8 (July 2010)

      • new collections framework


    Critical mass
    Critical Mass?

    • Introduction to the Art of Programming Using Scala (October 2012)

    • Scala for the Impatient (March 2012)

    • Scala in Action (April 2012)

    • Scala in Depth (April 2012)

    • Actors in Scala (Januar 2012)

    • Pro Scala: Monadic Design Patterns for the Web (August 2011)

    • Programming in Scala 2nd (Januar 2011)



    Recommended websites
    Recommended Websites

    • Official Scala website

      • http://scala-lang.org/

    • Daily Scala – small code sniplets

      • http://daily-scala.blogspot.com/

    • CodeCommit – "Scala for Java Refugees"

      • http://www.codecommit.com/blog/

    • StackOverflow

      • http://stackoverflow.com/


    Summary
    Summary

    is viable alternative to Java

    • object-orientated and functional

    • has useful features not found in Java

    • runs on the JVM and interacts with Java

    • is fun!


    Thank You!

    (now go download Scala)


    Addendum
    Addendum

    Me>I need [what turns out to be virtual types]

    Erik> You could use an extra-linguistic solution

    Me> What do you mean "extra-linguistic"?

    Erik> A perl script...



    Embedded dsls
    Embedded DSLs

    Scala has syntactic flexibility:

    object Button {

    def onClick(f: => Unit) { ... }

    }

    Button.onClick(() => println("Hello"!));

    But you can also write:

    Button.onClick {

    println("Hello");

    }


    Historical anecdote
    Historical Anecdote

    BETA was supposed to be called Scala:

    For many years the name SCALA was a candidate for a new name – SCALA could mean SCAndinavian LAnguage, and in Latin it means ladder and could be interpreted as meaning something ‘going up’.

    The When, Why and Why Not

    of the BETA Programming Language


    ad