🎊 2.12.1 🎉

Contributors

Community: ⅓

Typelevel

EPFL

Massive Thank You!

https://github.com/scala/scala/graphs/contributors?from=2014-11-01&to=2016-10-29&type=c

Lightbend Scala Team: ⅔

Stefan Zeiger

Seth Tisue

Lukas Rytz

Jason Zaugg

me

Scala Center

• Empower Community
  • Community rep: Bill Venners, Lars Hupel
• OSS development
  • Scala Platform, Scaladex, Scalafix
• Education
  • Coursera

Release Cadence

1 every 6 weeks

2015

• 2.11.5, 2.11.6, 2.10.5
• 2.12.0-M1, 2.11.7
• 2.12.0-M2, 2.10.6
• 2.12.0-M3

2016

• 2.11.8, 2.12.0-M4
• 2.12.0-M5
• 2.12.0-RC1
• 2.12.0-RC2, 2.12.0, 2.12.1

2017

• 2.11.9 (last 2.11)
• quarterly 2.13 milestones
• 2.12.x

Looking back

2.10: BIG release

2.11: Modules, inc comp

Slow down for tooling!

2.12: Java 8

Overhauled back-end. New optimizer!

Regular

Syntactically

val    x  : T              = ???
def    m  (a: T): U        = ???
type   T  >: L <: U
class  C  (a: T) extends A { ... }

No limits / exceptions

Arbitrary nesting

Higher-order

(Methods and Types)

Operator names

(Primitive types are types too)

Conceptually

Pure OO

value = object

operation = method call

Everything is an expression

• think in values, not side-effects
• statement is expression : Unit
• all types subject to polymorphism
• ⟹ function types uniform

Small core reaches far

Start small, grow methodically.

Regularity begets flexibility

Our flexibility is your flexibility.

Flexibility requires discipline

The language is not opinionated, but we should be.

Growing

• f(x) = f.apply(x)
• for comprehension, string interpolation
• pattern matching / extractors
• (1, 2) = Tuple2(1, 2),
  • and val (x, y) = (1, 2)
• static member is object member

Unifier

• FP & OOP
• Safety in types & Convenience of inference
• From oneliner to millions

Types come second

because optional

• public types are documentation
• ↔ codegen: maintenance liability
• best types are unseen
  • e.g., definition-site variance

How I stopped worrying about variance

"Just add +/- until it compiles."

-- me

Function subtyping

Scala: definition encapsulates <: rules

def map[R](mapper: T => R): Stream[R]

Wildcards: users encode <: rules

<R> Stream<R> map(Function<? super T, ? extends R> mapper)

Over, and over

(But there's a JEP for that.)

Practical

simplest solution

solves the problem today

can understand tomorrow

evolve later

Language is a tool

improve our understanding

through static typing, FP, abstraction

Aid

static types: refactor with confidence

type inference to refactor with ease

FP: small abstractions in isolation

composed into different solutions

abstraction: capture essence

not obscure it

Shield

implementation details: encapsulate!

OO's forte

from time: immutable

mutability exposes order of execution

from distribution: asynchrony

synchrony exposes distance/failure

Compiling to JVM 8!

Trait = interface + default method

Function = SAM instance via INDY

New Backend & Optimizer!

• GenBCode ASM-based backend
• Inline methods from classes/objects/traits #4711
• Eliminate: closures, box/unbox,...
• For details, see Lukas's talks
  • Tales from Compiling to the JVM (Scala World 2016 video)
  • The new Optimizer in Scala 2.12 at Zurich-Scala

Scaladoc

• Modern look
• Documents Java sources

REPL

• Better tab completion (same as IDE/ENSIME)
• -Dscala.color

Library

• Either is now right-biased
• scala/scala-java8-compat
• must have withFilter for for

Contributor's experience

sbt build!

Open & timely communication

Growing number of contributors!

Inspiration from dotty

• trait & λ encoding
• Signature inference for val
• Infer H-O fun arg types of overloaded method #5307
• Method lazy val more compact #5294
• fields phase (+ simplified post-typer phases) #5141

sbt improvements (0.13.13)

• Class-based name hashing sbt/sbt#1104
• More efficient IO for analysis sbt/sbt#2525
• Faster compilation sbt/sbt#2754

Trait encoding #5003

• trait compiles to Java 8 interface
  • binary compat ftw
  • so long, implementation classes!
• FunctionN compiles to SAM type (Java 8 λ)

Mixing in trait: glue

• fields & other init effects
• trait extends class
• super call ⟹ accessor
• forwarders (for linearization & jvm perf)

INDY-λ #4463

1. scalac λ bytecode mimics javac's
2. ride JIT perf tuning wave
3. profit

Gotcha

• Lambda body in method of enclosing class
• Before, in its own anonymous class
• Can result in deadlock, accidental outer capture

Single Abstract Method

• Unify FunctionN and SAM types
• Scala 2.12 ↔ Java 8 λ-interop
• But wildcards...
• #3018 #4971

Overloads

class C[V] {
  def sort(cmp: (V, V) => Int): C[V] = ???
  def sort(cmp: java.util.Comparator[V]): C[V] = ???
}
val c: C[Int] = ???

c sort (_ - _)
c sort ((a: Int, b: Int) => a - b)
c sort ((_ - _): java.util.Comparator[Int])

Example

• Original: http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples
• Full translation: https://gist.github.com/adriaanm/892d6063dd485d7dd221

scala> import java.util.{Arrays, List, ArrayList}
scala> import java.util.stream.{Stream, IntStream}
scala> val myList = Arrays.asList("a1", "a2", "b1", "c2", "c1")

scala> myList.stream.filter(s => s.startsWith("c")).
  map(_.toUpperCase).
  sorted.
  forEach(println)

scala> Arrays.asList("a1", "a2", "a3").stream.
  findFirst.
  ifPresent(println)

scala> Stream.of("a1", "a2", "a3").
  findFirst.
  ifPresent(println)

scala> IntStream.range(1, 4).forEach(println)

scala> Arrays.stream(Array(1, 2, 3)).
  map(n => 2 * n + 1).average.
  ifPresent(println)

scala> Stream.of("a1", "a2", "a3").
  map(_.substring(1)).
  mapToInt(Integer.parseInt).max.ifPresent(println)
<console>:14: error: type mismatch;
 found   : (x$1: String)Int <and> (x$1: String, x$2: Int)Int
 required: java.util.function.ToIntFunction[? >: ?0]
       Stream.of("a1", "a2", "a3").map(_.substring(1)).mapToInt(Integer.parseInt).max.ifPresent(println)
                                                                        ^
scala> Stream.of("a1", "a2", "a3").
  map[String](_.substring(1)).
  mapToInt(Integer.parseInt).max.ifPresent(println)
3

Library release

scala-lang.org/news/roadmap-next

RC1: Q1 2018?

Simpler Collections

Fix common gotchas

Refactor

Minimize impact on most users

Inheritance hierarchy will change

Modularization part 2

aka Scala Platform

IO

JSON

Parallel collections

Allow opting out of old stuff

Compiler Performance

Simplify Language

• Trait parameters
• Deprecate
  • early initializers
  • procedure syntax
  • implicit without signature
• Scalafix

Wishlist

Improve errors

• nicer messages
• configurable reporting (e.g. deprecation)

REPL polish

• syntax highlighting
• class-based wrapping
• improve embeddability
• take advantage of Java 9

sbt launcher consolidation

• improved getting started experience
• provide custom default dependencies
• auto upgrades
• version usage statistics

Scalafix

• use for upgrade to 2.13
• procedure syntax
• add sigs for implicits (& non-private members?)

scala-abide

• move linting out of compiler
• more extensible

Thank you

Questions!

@adriaanm