Scala 是一种运行在 JVM 上的强类型编程语言，具有函数式和面向对象的特性，支持简化的语法和动态静态组合。它在 Twitter 和 LinkedIn 等公司中得到应用，但也面临性能和复杂性问题。尽管存在缺点，Scala 提供丰富的类库和工具，适合构建并发和分布式应用。

1. Sparkle

2. 大纲
Scala是什么
语法（特色）
类库和工具
缺点

3. Scala是什么

4. "Which Programming Language would you use *now*
on top of JVM, except Java?". The answer was
surprisingly fast and very clear: - Scala.
http://www.adam-bien.com/roller/abien/entry/java_net_javaone_which_programming

5. I can honestly say if someone had shown me
theProgramming in Scala book by by Martin
Odersky, Lex Spoon & Bill Venners back in 2003 I'd
probably have never created Groovy.
http://macstrac.blogspot.com/2009/04/scala-as-long-term-replacement-for.html

6. Scala是……

7. Scala是……
又一个JVM上的语言（编译）

8. Scala是……
又一个JVM上的语言（编译）
强类型

9. Scala是……
又一个JVM上的语言（编译）
强类型
“动态的”静态语言

10. Scala是……
又一个JVM上的语言（编译）
强类型
“动态的”静态语言
函数式

11. Scala是……
又一个JVM上的语言（编译）
强类型
“动态的”静态语言
函数式
面向对象

12. 谁在用
Twitter
LinkedIn
FourSquare
Xerox、Sony、Siemens

13. 语法（特色）

14. Hello world!
object Test {
! def main(args: Array[String]) {
! ! println("Hello, world!")
! }
}

15. Hello world!
没有分号
object Test {
! def main(args: Array[String]) {
! ! println("Hello, world!")
! }
}

16. Hello world!
没有分号
object Test {
定义后置
! def main(args: Array[String]) {
! ! println("Hello, world!")
! }
}

17. Hello world!
没有分号
object Test {
定义后置
! def main(args: Array[String]) {
! ! println("Hello, world!")
object ! }
}

18. Hello world!
没有分号
object Test {
定义后置
! def main(args: Array[String]) {
! ! println("Hello, world!")
object ! }
}
def

19. Hello world!
没有分号
object Test {
定义后置
! def main(args: Array[String]) {
! ! println("Hello, world!")
object ! }
}
def
println

20. Hello world!
object Test extends Application {
! println("Hello, world！")
}

21. Hello world!
object Test extends Application {
! println("Hello, world！")
extends
}

22. Hello world!
object Test extends Application {
! println("Hello, world！")
extends
}
类内直接写代码

23. 简化

24. 简化
val i = 1.2.toInt

25. 简化
val i = 1.2.toInt
val list = List(1, 2, 3)

26. 简化
val i = 1.2.toInt
val list = List(1, 2, 3)
val map = Map("Guangzhou" -> "GZ",
"Shenzhen" -> "SZ")

27. 简化
val i = 1.2.toInt
val list = List(1, 2, 3)
val map = Map("Guangzhou" -> "GZ",
"Shenzhen" -> "SZ")
class MyClass(x: Int, y: Int) {}

28. 简化
val i = 1.2.toInt
val list = List(1, 2, 3)
val map = Map("Guangzhou" -> "GZ",
"Shenzhen" -> "SZ")
class MyClass(x: Int, y: Int) {}
list.exists(_ == 2) //true

29. 简化
val i = 1.2.toInt
val list = List(1, 2, 3)
val map = Map("Guangzhou" -> "GZ",
"Shenzhen" -> "SZ")
class MyClass(x: Int, y: Int) {}
list.exists(_ == 2) //true
val (a, b, _) = (x, y, z)

30. 函数式编程

31. 函数式编程
list.filter(e => e % 2 == 0)

32. 函数式编程
list.filter(e => e % 2 == 0)
list.filter(_ % 2 == 0)

33. 函数式编程
list.filter(e => e % 2 == 0)
list.filter(_ % 2 == 0)
val f = (e: Int) => e % 2 == 0
list.filter(f)

34. open class(ruby)
class String
def foo
"foo"
end
end
puts "".foo # prints "foo"

35. 为什么我们需要open class

36. 为什么我们需要open class
StringUtils.isBlank("some str")

37. 为什么我们需要open class
StringUtils.isBlank("some str")
"some str".isBlank

38. 为什么我们需要open class
StringUtils.isBlank("some str")
"some str".isBlank
myObj should not contains(13)

39. 隐式转换
class MyString(str: String) {
def isBlank = str.trim.length == 0
}
implicit def myStringWrapper(str: String) = new
MyString(str)
println("some str".isBlank)

40. 隐式转换
class MyString(str: String) {
def isBlank = str.trim.length == 0
}
implicit def myStringWrapper(str: String) = new
MyString(str)
println("some str".isBlank)
println(new MyString("some str").isBlank)

41. open class的效果让大家觉得Scala是动态语言，但选择
隐式转换来实现，正好证明了Scala是静态语言

42. Trait
class Animal { xxx }
trait CanFly {
def fly {
println("fly")
}
}
class Bird extends Animal
with CanFly {}

43. Trait
class Animal { xxx }
trait CanFly {
Mixin，类似多集成 def fly {
println("fly")
接口和实现一起出现 }
}
是什么和拥有什么功能
class Bird extends Animal
with CanFly {}

44. Trait
class Fish { xxx }
trait CanFly {
def fly {
println("fly")
}
}
val flyFish = new Fish with CanFly

45. Actors
val myActor = actor {
loop {
react {
case "Send" => {
println("Get")
}
}
}
}
myActor ! "Send"

46. 模式匹配
def matchTest(x: Any) = x match {
case 1 => "number one"
case y: Int if y > 0 => y + 1
case head :: tail => tail
case Send(a, _) => a
case ("Send", _, b: String) => b
case _ => x
}

47. XML支持
println(<date>{new java.util.Date()}</date>)

48. 并发

49. 是什么让我们觉得一个语言是并发的语言

50. 是什么让我们觉得Go和Erlang是并发语
言，而C++和Python不是

51. 是什么让我们觉得Go和Erlang是并发语
言，而C++和Python不是
Go内置Channel和Goroutine
Erlang的一次赋值、轻量级进程

52. 是什么让我们觉得Scala
val
case class
模式匹配
大量的immutable类
Actors

53. 与Java互相调用
Scala能调用绝大部分的Java
JavaConverters、JavaConversions
Java调用Scala独有的东西比较困难

54. 类库和工具

55. Lift
full stack
view first

56. Play!
Play Scala

57. Play!
Play Scala
Play 2.0 !!

58. Akka
STM & Transactors
Fault-tolerance
Transparent Remoting
Scala & Java API

59. sbt
构建工具

60. 更多
Xitrum
Scalatra、Scalate
ScalaTest、specs2
Squeryl

61. IDE支持

62. 缺点

63. It took about 15 hours to recreate the publishing
daemon in Clojure and get it to pass all our tests.
Today we ran a "soak test" publishing nearly
300,000 profiles in one run. The Scala code would
fail with OoM exceptions if we hit it with 50,000
profiles in one run (sometimes less).
http://groups.google.com/group/clojure/browse_thread/thread/b18f9006c068f0a0

64. The e-mail confirms that Yammer is moving its basic
infrastructure stack from Scala back to Java, owing
to issues with complexity and performance.
http://www.infoq.com/news/2011/11/yammer-scala

65. flatMap [B, That] (f: (A) Traversable[B])(implicit bf:
CanBuildFrom[List[A], B, That]) : That
http://goodstuff.im/yes-virginia-scala-is-hard

66. jetbrains出了新JVM语言Kotlin后，Scala社区终于 始
正视Scala太 杂的问题了
http://groups.google.com/group/scalacn/browse_thread/thread/cbbe5997009db919

67. 缺点
编译速度
二进制不兼容
语法越来越 杂
太少人使用，招聘 发人员的问题

68. 始使用

69. 始使用
使用最新版(2.9.1)

70. 始使用
使用最新版(2.9.1)
先 用高级特性

71. 始使用
使用最新版(2.9.1)
先 用高级特性
小工具、单元测试

72. 始使用
使用最新版(2.9.1)
先 用高级特性
小工具、单元测试
Java/Scala混合项目，逐步 移

73. 始使用
使用最新版(2.9.1)
先 用高级特性
小工具、单元测试
Java/Scala混合项目，逐步 移
sbt

74. 谢谢
weibo&twitter: @sparklezeng
email: popeast@gmail.com
website: http://weavesky.com