• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Taxonomy of Scala
 

Taxonomy of Scala

on

  • 5,158 views

 

Statistics

Views

Total Views
5,158
Views on SlideShare
4,849
Embed Views
309

Actions

Likes
19
Downloads
110
Comments
8

8 Embeds 309

http://www.scoop.it 199
https://twitter.com 81
http://lanyrd.com 22
http://tweetedtimes.com 2
http://webcache.googleusercontent.com 2
https://si0.twimg.com 1
http://twitter.com 1
http://instacurate.com 1
More...

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

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

18 of 8 previous next Post a comment

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • Fixes are uploaded. Thanks to all!
    Are you sure you want to
    Your message goes here
    Processing…
  • @mrxtravis Thanks! Fixing for re-upload with the others.
    Are you sure you want to
    Your message goes here
    Processing…
  • Thanks, Bruce. Appreciate it. I'm also going to rewrite the presentation in Spotlight and make it more clear how I walk through the code in a presentation. I think that will really help make it less of a whirlwind tour.
    Are you sure you want to
    Your message goes here
    Processing…
  • myNums flatMap(i => 1 to i map (j => i * j))
    Are you sure you want to
    Your message goes here
    Processing…
  • Slide 22 also has a bug on the last code line; the uppercase I should be lowercase. Code should be:

    val myNums = 1 to 20

    for(i 1 to i map (j => i * j))
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • When you walk out of this room, your head should hurt. But that’s a GOOD thing – the problem is not that these concepts are difficult to grasp, but that you have to understand the vocabulary to even sit in the room with someone discussing them. I want to provide you with a reference point from which you can do your own investigation of what these concepts mean.
  • Ask why we don’t need the “new” keyword with case classes
  • Very fragile
  • Constant, Constructor, Or, Sequence, Sequence with wildcard, tuple, typed with guard, bound variable wildcard, wildcardBy definition, a lookup/table switch on the JVM can only be an int or enumerated type. Tell the story about your implementation of a jump table using hashes of class definitions – 5000 of them, had to do some delegation due to max method size on the JVM, but was able to perform the deepest match in ~300ns
  • Very powerful programming paradigmInverts imperative logic - apply your idempotent function to your dataThis is NOT monads, functors and the like, despite what you will hear in the communityAt it’s essence, functional programming is functions, referential transparency and immutability ONLY
  • How many times have you been bitten by someone altering the contents of your collection?Can happen with closing over state very easily, or sending state to another method/function without considering whether or not it can be changed after it is sent.
  • Map is key to valueSet does not allow dups and doesn’t care about orderSequence allows dups and maintains orderList provides Lisp-like cons semantics, but is a linked list and can be slow, must prependVector is a bitmapped vector trie, organizing data into 32-element arrays. Very performant, holds 2.15 billion elements only seven levels deep
  • map, filter and flatMap in ScalaYou have the choice as to how to organize your code
  • Map is key to valueSet does not allow dups and doesn’t care about orderSequence allows dups and maintains orderList provides Lisp-like cons semantics, but is a linked list and can be slow, must prependVector is a bitmapped vector trie, organizing data into 32-element arrays. Very performant, holds 2.15 billion elements only seven levels deep
  • Functions are automatically curry-able in ML and Haskell, but has to be explicitly defined with multiple parameter lists in Scala
  • This is ALL you need to know. There is a ton of goodness in Akka that make performing actor-based work much simpler and reasonable than it has been in the past, as well as a codifying of best practices. Please check out the documentation if you are interested.
  • Don't use them until you understand them! And limit their scope when you do so nobody shoots their foot off.
  • Implicits will seem like voodoo at first. Exist in other languages, like C type coercion
  • Very powerful programming paradigmInverts imperative logic - apply your idempotent function to your dataThis is NOT monads, functors and the like, despite what you will hear in the communityAt it’s essence, functional programming is functions, referential transparency and immutability ONLY
  • Global type inferencing is found in ML, for example
  • Using Java's interfaces requires you to specify the inheritance structure in your code. What if you can't because you're using a library? What if you want to make the way your code handles situations orthogonal to it's inheritance structure
  • Using Java's interfaces requires you to specify the inheritance structure in your code. What if you can't because you're using a library? What if you want to make the way your code handles situations orthogonal to it's inheritance structure
  • This is the understandable reaction of most developers when they first engage the people who like CT. Or when they read their first blog post about how monads are like burritos or some other metaphor. I'm convinced what we need to do is understand that there is a whole vocabulary that must be learned in order for you to know what CT is.
  • Morphism is chewy brownie to a hard brownie
  • Would convert a brownie to a cookie, and a chewy brownie to a chewy cookie and hard brownie into hard cookie, but also chewy cookies into hard cookies just like the brownie because the morphism is preserved
  • They are not containers! They are not collections. Having a flatMap method does not mean that your type is monadic.Like a collection with flatMap. you won't know what they are by looking at code at first. Monads are ephemeral - they have to meet the laws of monads. Left and right identity as well as binding.
  • Is the language trying to support too many paradigms at the expense of usability? Should a language be responsible for providing convention as well as capability? I think not. You can start by using Scala as a DSL for Java and make your code more concise, more readable and more correct. As your abilities with the language grows, try expanding what you're doing, but keep in mind your limitations.
  • They are not containers! They are not collections. Having a flatMap method does not mean that your type is monadic.Like a collection with flatMap. you won't know what they are by looking at code at first. Monads are ephemeral - they have to meet the laws of monads. Left and right identity as well as binding.

Taxonomy of Scala Taxonomy of Scala Presentation Transcript

  • A Taxonomy of Scala StrangeLoop 2012 Jamie Allen @jamie_allenhttp://github.com/jamie-allen/taxonomy-of-scala
  • Agenda• Goal• Object-Oriented Features• Pattern Matching• Functional Programming• Actors• Futures• Implicits• Type Theory• Macros• Category Theory
  • GoalProvide you with a reference point for many of the terms you hear in the Scala community
  • How Programming in Scala Makes Me Feel
  • How I Write Programs• Pre-Scala: – Make it work – Make it work well – Make it work fast• With Scala: – Make it work and work well – Make it work fast
  • Object-Oriented Features
  • Case Classescase class Person(firstName: String = "Jamie", lastName: String = "Allen")val jamieDoe = Person(lastName = "Doe")res0: Person = Person(Jamie,Doe)• Data Transfer Objects (DTOs) done right• By default, class arguments are immutable & public• Should never be extended• Provide equals(), copy(), hashCode() and toString() implementations• Don’t have to use new keyword to create instances• Named Parameters and Default arguments give us Builder pattern semantics
  • Lazy Definitionslazy val calculatedValue = piToOneMillionDecimalPoints() • Excellent for deferring expensive operations until they are needed • Reducing initial footprint • Resolving ordering issues • Implemented with a guard field and synchronization, ensuring it is created when necessary
  • Importsimport scala.collection.immutable.Mapclass Person(val fName: String, val lName: String) { import scala.collection.mutable.{Map => MMap} val cars: MMap[String, String] = MMap() ...} • Can be anywhere in a class • Allow for selecting multiple classes from a package or using wildcards • Aliasing • Order matters!
  • Objectsobject Bootstrapper extends App { Person.createJamieAllen }object Person { def createJamieAllen = new Person("Jamie", "Allen") def createJamieDoe = new Person("Jamie", "Doe") val aConstantValue = "A constant value”}class Person(val firstName: String, val lastName: String) • Singletons within a JVM process • No private constructor histrionics • Companion Objects, used for factories and constants
  • The apply() methodArray(1, 2, 3)res0: Array[Int] = Array(1, 2, 3)res0(1)res1: Int = 2 • In companion objects, it defines default behavior if no method is called on it • In a class, it defines the same thing on an instance of the class
  • Tuplesdef firstPerson = (1, Person(firstName = “Barbara”))val (num: Int, person: Person) = firstPerson • Binds you to an implementation • Great way to group values without a DTO • How to return multiple values, but wrapped in a single instance that you can bind to specific values
  • Pattern Matching
  • Pattern Matching Examplesname match { case "Lisa" => println("Found Lisa”) case Person("Bob") => println("Found Bob”) case "Karen" | "Michelle" => println("Found Karen or Michelle”) case Seq("Dave", "John") => println("Got Dave before John”) case Seq("Dave", "John", _*) => println("Got Dave before John”) case ("Susan", "Steve") => println("Got Susan and Steve”) case x: Int if x > 5 => println("got value greater than 5: " + x) case x => println("Got something that wasnt an Int: " + x) case _ => println("Not found”)} • A gateway drug for Scala • Extremely powerful and readable • Not compiled down to lookup/table switch unless you use the @switch annotation,
  • FunctionalProgramming
  • Immutability• Extends beyond marking instances final• You must not leak mutability
  • Referential Transparency// Transparentval example1 = "jamie".reverseval example2 = example1.reverseprintln(example1 + example2) // eimajjamie// Opaqueval example1 = new StringBuffer("Jamie").reverseval example2 = example1.reverseprintln(example1 append example2) // jamiejamie • An expression is transparent if it can be replaced by its VALUE without changing the behavior of the program • In math, all functions are referentially transparent
  • Scala Collectionsval myMap = Map(1 -> "one", 2 -> "two", 3 -> "three")val mySet = Set(1, 4, 2, 8)val myList = List(1, 2, 8, 3, 3, 4)val myVector = Vector(1, 2, 3...) • You have the choice of mutable or immutable collection instances, immutable by default • Rich implementations, extremely flexible
  • Rich Collection Functionalityval numbers = 1 to 20 // Range(1, 2, 3, ... 20)numbers.head // Int = 1numbers.tail // Range(2, 3, 4, ... 20)numbers.take(5) // Range(1, 2, 3, 4, 5)numbers.drop(5) // Range(6, 7, 8, ... 20) • There are many methods available to you in the Scala collections library • Spend 5 minutes every day going over the ScalaDoc for one collection class
  • Higher Order Functionsval names = List("Barb", "May", "Jon")names map(_.toUpperCase)res0: List[java.lang.String] = List(BARB, MAY, JON) • Really methods in Scala • Applying closures to collections
  • Higher Order Functionsval names = List("Barb", "May", "Jon")names map(_.toUpperCase)res0: List[java.lang.String] = List(BARB, MAY, JON)names flatMap(_.toUpperCase)res1: List[Char] = List(B, A, R, B, M, A, Y, J, O, N)names filter (_.contains("a"))res2: List[java.lang.String] = List(Barb, May)val numbers = 1 to 20 // Range(1, 2, 3, ... 20)numbers.groupBy(_ % 3)res3: Map[Int, IndexedSeq[Int]] = Map(1 -> Vector(1, 4, 7, 10, 13,16, 19), 2 -> Vector(2, 5, 8, 11, 14, 17, 20), 0 -> Vector(3, 6, 9,12, 15, 18))
  • For Comprehensionsval myNums = 1 to 20for (i <- myNums) yield i + 1myNums map(_ + 1)for { i <- myNums j <- 1 to i} yield i * jmyNums flatMap(i => 1 to i map (j => i * j)) • Used for composing higher-order functions • As you chain higher-order functions, you may find it easier to reason about them this way
  • Parallel Collectionsscala> 1 to 1000000res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3,...scala> res0.parres1: s.c.parallel.immutable.ParRange = ParRange(1, 2, 3,...scala> res1 map(_ + 1)res2: s.c.parallel.immutable.ParSeq[Int] = ParVector(2, 3, 4,...scala> res2.seqres3: s.c.immutable.Range = Range(2, 3, 4,... • You can easily parallelize the application of a function literal to your collection by calling the par() method on a collection instance • Uses JSR166 under the covers to fork/join for you • Use the seq() method on the parallel collection to return to a non-parallel instance
  • Partial Functionsclass MyActor extends Actor { def receive = { case s: String => println("Got a String: " + s) case i: Int => println("Got an Int: " + i) case x => println("Got something else: " + x) }} • A simple match without the match keyword • The receive block in Akka actors is an excellent example • Is characterized by what "isDefinedAt" in the case statements
  • Curryingdef product(i: Int)(j: Int) = i * jval doubler = product(2)_doubler(3) // Int = 6doubler(4) // Int = 8val tripler = product(3)_tripler(4) // Int = 12tripler(5) // Int = 15 • Take a function that takes n parameters as separate argument lists • “Curry” it to create a new function that only takes one parameter • Fix on a value and use it to apply a specific implementation of a product with semantic value • Have to be defined explicitly as such in Scala • The _ is what explicitly marks this as curried
  • Actors
  • Actorsimport akka.actor._class MyActor extends Actor { def receive = { case x => println(“Got value: “ + x) }} • Based on concepts from Erlang/OTP • Akka is replacing the core language actors • Concurrency paradigm using networks of independent objects that only communicate via messaging and mailboxes
  • Futures
  • Futuresimport scala.concurrent._val costInDollars = Future { webServiceProxy.getCostInDollars.mapTo[Int]}costInDollars map (myPurchase.setCostInDollars(_)) • Allows you to write asynchronous code, which can be more performant than blocking • Are not typed, hence the mapTo call above
  • Futures in Sequenceval customerPurchases = for ( costUSD <- Future{ proxy.getCostInDollars.mapTo[Int]} totalPurchase <- Future{ proxy.addToTotal(costUSD).mapTo[Int]}} yield ((customerId -> totalPurchase)) • Scala’s for comprehensions allow you to compose higher-order functions, including Futures • By sequencing the expressions on multiple lines, you can order dependencies
  • Futures in Parallelval costUSD = Future{proxy.getCostInUSD(cost).mapTo[Int]}val costCAD = Future{proxy.getCostInCAD(cost).mapTo[Int]}val combinedCosts = for { cUSD <- costUSD cCAD <- costCAD} yield (cUSD, cCAD)val costs = for ( (costUSD, costCAD) <- Future{proxy.getCostInUSD(cost).mapTo[Int]} zip Future{proxy.getCostInCAD(cost).mapTo[Int]}} yield (costUSD, costCAD) • Define the futures separately and then compose • Alternatively, the zip method allows you to parallelize futures execution within a for comprehension
  • Implicits
  • Implicit Conversions
  • Implicit Conversionscase class Person(firstName: String, lastName: String)implicit def PersonToInt(p: Person) = p.toString.head.toIntval me = Person("Jamie", "Allen")val weird = 1 + meres0: Int = 81 • Looks for definitions at compile time that will satisfy type incompatibilities • Modern IDEs will warn you with an underline when they are in use • Limit scope as much as possible (see Josh Suereths NE Scala 2011)
  • Implicit Parametersdef executeFutureWithTimeout(f: Future)(implicit t: Timeout)implicit val t: Timeout = Timeout(20, TimeUnit.MILLISECONDS)executeFutureWithTimeout(Future {proxy.getCustomer(id)}) • Allow you to define default parameter values that are only overridden if you do so explicitly • Handy to avoid code duplication
  • Implicit Classesimplicit class Person(name: String)class Person(name: String)implicit final def Person(name: String): Person = new Person(name) • New to Scala 2.10 • Create extension methods to existing types • Desugars at compile time into a class definition with an implicit conversion
  • Type Theory
  • Type Inference• Declaring a variable/value• Return types of methods/functions• See Daniel Spiewaks Philly ETE 2011 talk• Good idea to show types on public interfaces• Specify types when you want to type certainty
  • Type Classes Icase class Customer(id: Long, firstName: String, lastName: String)trait CustomerOrderById extends Ordering[Customer] { def compare(x: Customer, y: Customer): Int = { ... }}implicit object CustomerIdSort extends CustomerOrderByIdval customers = List(Customer(1, "Jamie", "Allen"), Customer(5,"John", "Doe"), Customer(2, "Jane", "Smith"))val sortedCustomers = customers.sorted(CustomerIdSort)sortedCustomers: List[Customer] = List(Customer(1,Jamie,Allen),Customer(2,Jane,Smith), Customer(5,John,Doe)) • Allow you to layer in varying implementations of behavior without changing an existing inheritance structure
  • Type Classes IIcase class Dog(name: String)case class Ferret(name: String)case class Cat(name: String)abstract class OkayPets[T]object OkayPets { implicit object OkayDog extends OkayPets[Dog] implicit object OkayFerret extends OkayPets[Ferret]}def getPet[T](t: T)(implicit p: OkayPets[T]) = tval myDog = getPet(Dog("Sparky")) // Worksval myCat = getPet(Cat("Sneezy")) // Fails at compile time • Allows you to generalize types that are acceptable parameters for methods
  • Higher Kinded TypesMap[A, B] // Type constructor, not a type!val myMap = Map[Int, String]() // Now it’s a type! • Use other types to construct a new type • Also called type constructors
  • Algebraic Data Typessealed abstract class DayOfTheWeekcase object Sunday extends DayOfTheWeekcase object Monday extends DayOfTheWeek ...case object Saturday extends DayOfTheWeekval nextDay(d: DayOfTheWeek): DayOfTheWeek = d match { case Sunday => Monday case Monday => Tuesday ... case Saturday => Sunday }} • Allow you to model the world in finite terms, such as enumerations, but also define behavior around them, with all of the power of case classes • A finite number of possible subtypes, enforced by the "sealed" keyword (must be defined in the same source file)
  • Macros
  • Macros• New to Scala 2.10• Macros are used for generating code at compile time, similar to LISP macros• Does not have compiler pragmas such as #ifdef• Are implemented as "hygenic" macros at the point you call reify() – identifiers cannot be closed over in a macro definition
  • ScalaLogging Macrodef debug(message: String): Unit = macro LoggerMacros.debugprivate object LoggerMacros { def debug(c: LoggerContext)(message: c.Expr[String]) = c.universe.reify( if (c.prefix.splice.underlying.isDebugEnabled) c.prefix.splice.underlying.debug(message.splice) )}import com.typesafe.scalalogging.Loggingclass MyClass extends Logging { logger.debug("This wont occur if debug is not defined")} • Existing log libraries allow us to define logging statements and then determine whether they result in output at runtime • ScalaLogging allows a user to use a logging facility but decide at compile time whether or not to include the logging statement based on log level.
  • Category Theory
  • Category Theory
  • Concepts and Arrowsval myIntToStringArrow: Int => String = _.toStringmyIntToStringArrow(1100)res0: String = 1100 • Concepts are types • Arrows are functions that convert one concept to another
  • Morphismval number = 1000val numericString = number.toString • Morphisms change one value in a category to another in the same category, from one type to another where types are the category • Simplified, it converts a type with one property to a type with another property • Must be pure, not side-effecting
  • Functorval numbers = List(1, 2, 3, 4)val numericStrings = numbers.map(_.toString) • Functors are transformations from one category to another that preserve morphisms • Simplified, converts a type from one to another while maintaining the conversion of a type with one property to a type with another property
  • Monadval customerPurchases = for ( costUSD <- proxy.getCostInDollars totalPurchase <- proxy.addToTotal(costUSD)} yield ((customerId -> totalPurchase)) • Very ephemeral concept • Must meet the laws of a monad to be one • Combine functor applications because they can be bound together, sequencing operations on the underlying types • flatMap() is the method the Scala compiler uses to bind monads
  • Thank You!
  • Credits• Sources – Fast Track to Scala courseware by Typesafe – Scala in Depth, by Josh Suereth – DSLs in Action, Debasish Ghosh – Wikipedia – Runar Bjarnasons NE Scala 2011 talk – Daniel Sobrals blog – Brendan McAdams blog• Contributors – Dave Esterkin, Chariot Solutions – Josh Suereth, Typesafe