第 1 页
An Introduction to Scala for Spark programming Nastaran Fatemi Slides of this course are prepared based on the book “Programming in Scala” and its presentations by Martin Odersky
第 2 页
What’s Scala • Scala is a statically typed, object-oriented programming language that blends imperative and functional programming styles. • It is designed to integrate easily with applications that run on modern virtual machines, primarily the Java virtual machine (JVM). • Scala was developed starting in 2003 by Martin Odersky's group at EPFL. • It is used for big-iron projects in industry. 2
第 4 页
Some adoption vectors: • Web platforms • Trading platforms • Financial modeling • Simulation • Big Data Analytics Fast to first product, scalable afterwards 4
第 5 页
Scala is a Unifier Agile, with lightweight syntax Parallel Object-Oriented Scala Functional Sequential Safe and performant, with strong static typing 5
第 6 页
“If I were to pick a language to use today other than Java, it would be Scala.” - James Gosling, creator of Java “Scala, it must be stated, is the current heir apparent to the Java throne. No other language on the JVM seems as capable of being a "replacement for Java" as Scala, and the momentum behind Scala is now unquestionable. While Scala is not a dynamic language, it has many of the characteristics of popular dynamic languages, through its rich and flexible type system, its sparse and clean syntax, and its marriage of functional and object paradigms.” - Charles Nutter, creator of JRuby “I can honestly say if someone had shown me the Programming in Scala book by Martin Odersky, Lex Spoon & Bill Venners back in 2003 I'd probably have never created Groovy.” - James Strachan, creator of Groovy. 6
第 7 页
What makes Scala scalable? • Many factors: strong typing, inference, little boilerplate,… • But mainly, its tight integration of functional and object-oriented programming Functional programming: Object-oriented programming: Makes it easy to build interesting Makes it easy to adapt and extend things from simple parts, using complex systems, using immutable datatypes subtyping and inheritance, closures and higher-order dynamic configurations, functions, classes as partial abstractions. generic typing 7
第 8 页
The Philosophy behind Scala Put productivity and creativity back in the hands of developers. “Joy is underrated as a metric for a language’s potential success in a development organization.” a3lx@twitter - address professional developers - trust them & value their expertise - (don’t tell them how they should do their job) 8
第 10 页
Overview In this course you will learn about Scala REPL Variable and method definitions Scala syntax Scala’s type hierarchy How to construct functional objects Collections: sequences Function values and higher-order functions For loops and for expressions Collections: sets and maps 10
第 11 页
Download and install Scala • Installation : - Go to http://www.scala-lang.org/downloads and follow the directions for your platform - Once you download an archive file, create a directory wherever you prefer and unzip (or untar, etc.) the archive file in that empty directory. - Among the subdirectories created will be the bin directory that contains the Scala executables, including the compiler and interpeter. - To make Scala convenient to use, add the full pathname of the bin directory to your PATH environment variable. You can also use Scala via plug-ins for Eclipse and IntelliJ downloadable from the same link given above. 11
第 12 页
Using the Scala interpreter The easiest way to get started with Scala is by using the Scala interpreter, which is an interactive “shell” for writing Scala expressions and programs. The interactive shell for Scala is simply called scala. scala> 1 + 2 res0: Int = 3 scala> res0 * 2 res1: Int = 6 scala> println("Hello, world!") Hello, world! 12
第 13 页
Variables Two forms: val immutable variable var reassignable variable scala> val msg = "hello world!" msg: String = hello world! scala> var greeting = "hi!" greeting: String = hi! scala> greeting = "hi there!" greeting: String = hi there! 13
第 14 页
Expressions Languages like C and Java distinguish between expressions which return a result and statements which don’t. Scala does not: every statement is an expression that returns a value. scala> if (msg contains 'a') msg else "no a" res3: String = no a scala> try { msg} finally { println("done") } done res4: String = hello world! scala> { val x = 2; x * x } res5: Int = 4 14
第 15 页
Functions • Basic form: def max(x: Int, y: Int): Int = { if (x < y) y else x } • Result type is required only for recursive functions. • Right hand side may be simple expression without { ... } • Short form: def max(x: Int, y: Int) = if (x < y) y else x def square(x: Double) = x * x 15
第 16 页
Recursion • Recursive functions need an explicit return type def power(x: Double, n: Int): Double = if (n == 0) 1.0 else if (n % 2 == 0) square(power(x, n / 2)) else x * power(x, n -‐ 1) def findIndex(str: String, chr: Char, from: Int): Int = if (str.charAt(from) == chr) from else findIndex(str, chr, from + 1) 16
第 17 页
The Unit Type • Question: What’s the type of the expression println(“hi”)? • Try it out! scala> val x = println("hi") hi x: Unit = () • Scala uses Unit as the type of expressions that are executed only for their side-effects. • Unit has a value, written (). • Unit corresponds roughly to void in Java. 17
第 18 页
Procedures • Procedures are functions that return Unit. scala> def sayHi(): Unit = println("hi!") sayHi: ()Unit • They have an alternative syntax, where the parameter list is immediately followed by a block, without return type or =. scala> def sayHo { println("ho!") } sayHo: Unit 18
第 19 页
Scala cheat sheet (1): Definitions Scala method definitions: Java method definition: def fun(x: Int): Int = { int fun(int x) { result return result; } } or def fun(x: Int) = result (no parameterless methods) def fun = result Scala variable definitions: Java variable definitions: var x: Int = expression int x = expression val x: String = expression final String x = expression or var x = expression val x = expression 19
第 20 页
Scala cheat sheet (2): Expressions Scala method calls: Java method call: obj.meth(arg) obj.meth(arg) or obj meth arg (no operator overloading) Scala choice expressions: Java choice expressions, stats: if (cond) expr1 else expr2 cond ? expr1 : expr2 if (cond) return expr1; expr match { else return expr2; case pat1 => expr1 .... switch (expr) { case pat => expr case pat1 : return expr1; n n ... } case patn : return exprn ; } // statement only 20
评论 (0)
暂无评论。快来抢沙发吧！