Scala: functional programming for the imperative mind

Scala Functional programming for the imperative mind

Scala Functional programming for the imperative mind ‘of the nature of or expressing a command; commanding.’ - imperative. (n.d.).  Dictionary.com

Scala ‘imperative Functional programmingisfor the imperative mind programming a programming paradigm that describes computation in terms of statements that change a program state.’ - Imperative programming Wikipedia.com

Outline • Introduction • Functional programming • Scala features • Java to Scala in three steps • Scala community • Wrap up

Roots • Created by Martin Odersky • Supported by EPFL Switzerland

What is Scala? A programming language ... • Runs on JVM (and .Net) • Statically typed • Object Oriented • Functional • From scripting to enterprise apps

Scalable language • Scalable language constructs: • Composition ‘in the small’ • Composition ‘in the large’ • Java interoperability • Performance on par with Java

Scalable language • Scalable language constructs: • Composition ‘in the small’ • Composition ‘in the large’ • Java interoperability • Performance on par with Java Fuses functional and object oriented paradigms

What is Functional Programming

Functional programming • Focus on functions, not state fx=x+1 • Functions are values vs. • Recursion, not loops x=x+1 • Immutability (‘referential transparency’) • Schools of thought: pure and impure (‘pragmatic’)

Functional programming • Focus on functions, not state • Functions are values f g x = g(x) • Recursion, not loops • Immutability (‘referential transparency’) • Schools of thought: pure and impure (‘pragmatic’)

Functional programming • Focus on functions, not state f0=0 fx= • Functions are values f (x - 1) vs. • Recursion, not loops for(i=x; i>0 ; i--) { • Immutability (‘referential transparency’)x--; } • Schools of thought: pure and impure (‘pragmatic’)

Functional programming • Focus on functions, not state • Functions are values • Recursion, not loops • Immutability (‘referential transparency’) • Schools of thought: pure and impure (‘pragmatic’)

Functional programming Why should I care about FP? • Concurrency: FP ‘killer app’ • Higher order functions: expressiveness boost • Type-system: when present, often superior • It is coming to a language near you (C#, Java 8?)

FP in Scala • First-class functions: functions are objects with pleasing syntax • Immutability • Algebraic data-types and pattern matching • Parametric polymorphism (e.g. generics)

What are Scala’s Features

Scala is like Java... (Generic) classes: class Foo[T], or: class Foo[+T] public class Foo<T> Methods: def m(s : String) : Unit = .. public void m(String s) {..} Bean properties: private Foo foo; Real properties: getFoo() {..}, setFoo(..) {..} var foo: Foo Fully interoperable with existing Java Mature, large amount of proven libraries code Class/Interface distinction, single Abstract classes, traits (restricted inheritance. multiple inheritance)

Pure object orientation No primitive types:

Pure object orientation Every operation is a method call: 1+3 1.+(3)

Pure object orientation Every operation is a method call: 1+3 1.+(3) Console.println(“hi”) Console println “hi”

Pure object orientation Every operation is a method call: 1+3 1.+(3) Console.println(“hi”) Console println “hi” Since operators are methods, operator overloading is trivial.

Pure object orientation Every operation is a method call: 1+3 1.+(3) Console.println(“hi”) Console println “hi”

Pure object orientation No static members, but singleton objects:

Type inference • Types may be omitted in declarations • Does not mean there is no type! • Inference is local only • Var/val: mutable vs. immutable

Type inference

Everything is an expression

Functional objects • Functions are ﬁrst-class values • Function literals:

Functional objects • Functions are ﬁrst-class values • Function literals: (x: Int) => x * 2

Functional objects • Functions are ﬁrst-class values • Function literals: (x: Int) => x * 2 val double = (x: Int) => x * 2

Functional objects • Functions are ﬁrst-class values • Function literals: (x: Int) => x * 2 val double = (x: Int) => x * 2 double(2) == 4 What is the type of double?

Functional types val double = (x: Int) => x * 2 has type (Int) => Int

Functional types val double = (x: Int) => x * 2 has type (Int) => Int Function1[Int,Int]

Passing functions Since functions are values, we can pass them around:

Passing functions But we can do this with anonymous classes...

Passing functions But we can do this with anonymous classes... Well, sort of... but: • You need explicit interfaces (no function types) • Verbose • Doesn’t scale (syntactically and semantically) • No true closures:

Traits • Compare trait with abstract class • No interfaces, but: completely abstract traits • Can mixin multiple traits, statically and dynamically

Traits as rich interfaces Java interfaces have two consumers with conﬂicting interests: 1) Implementors 2) Users

Traits as stackable modiﬁcations • Situation: IntQueue interface (abstract trait), IntQueueImpl implementation • We want to add logging and ﬁltering to any IntQueue implementation

Pattern matching

Pattern matching Yes, it prints 9

Pattern matching • No more instanceof/typecasts • No more visitor pattern

Pattern matching • No more instanceof/typecasts • No more visitor pattern No more NullPointerException:

Pattern matching & XML • Scala has XML literals, can be matched • Other literals can be matched as well

Language feature or Library Support

Actors • Message-based concurrency • Actors exchange immutable messages • Extract them by pattern matching

Actors • Message-based concurrency • Actors exchange immutable messages • Extract them by pattern matching Looks like language feature, but is a library

Other library features • Enums • Map ‘syntax’ • Events • Using ‘keyword’ (e.g. Java 7 ‘automatic resource management.’) • Virtually all other Project Coin proposals

Other library features • Enums • Map ‘syntax’ • Events • Using ‘keyword’ (e.g. Java 7 ‘automatic resource management.’) • Virtually all other Project Coin proposals Lesson: choose language core wisely, all else will follow...

Lift webframework In own words: ✓Seaside's highly granular sessions and security ✓Rails fast ﬂash-to-bang ✓Django's \"more than just CRUD is included\" ✓Wicket's designer-friendly templating style • Heavy use of actors for async features • Integrated O/R mapping (surprisingly little boilerplate code)

From Java to Scala In Three steps

Requirements • Person entity with age property • Method to separate minors and adults • Input: List[Person] • Output: list of minors, list of adults • One pass over input

What happens in the Scala Community

Scala progression • Current version: 2.7.4 • Version 2.8 beta coming up: • Package objects • Named and default parameters • Many library improvements

Tool support • Major IDEs (Eclipse, IntelliJ, NetBeans) supported • Maven support • Scaladoc • SBaz package manager

Wrapping up with Concluding Remarks

Scala hitting mainstream? Reports of ﬁrst switchers Twitter, SAP, LinkedIn, Sony Pictures

Scala hitting mainstream? Reports of ﬁrst switchers Twitter, SAP, LinkedIn, Sony Pictures April 2009: top-30 of TIOBE index

Scala hitting mainstream? Reports of ﬁrst switchers Twitter, SAP, LinkedIn, Sony Pictures April 2009: top-30 of TIOBE index Lots of books appearing

Scala hitting mainstream? “If I were to pick a language today other than Java, it would be Scala” James Gosling, ‘Father of Java’

Scala hitting mainstream? “If Java programmers want to use features that aren't present in the language, I think they're probably best off using another language that targets the JVM, such a Scala and Groovy.” Joshua Bloch Author of ‘Effective Java’

Pro’s and cons • Complexity • Java interoperability • Java -> Scala • Hides accidental complexity harder than Scala -> Java • Expressiveness • Type-system may • Uniform, extensible be intimidating language

Conclusion • Scala feels like ‘cleaned up Java on stereoids’ • Small core (takes some time to see it as such) provides broad options • Type inference brings ‘dynamic language’ feel • Adoptation growing because of: • Java interoperability • Growing discontent with Java

Conclusion • Scala feels like ‘cleaned up Java on stereoids’ • Small core (takes some time to see it as such) provides broad options • Type inference brings ‘dynamic language’ feel • Adoptation growing because of: • Java interoperability • Growing discontent with Java Scala provides deep features, but at the same time helps getting things done.

More information http://www.scala-lang.org http://liftweb.net Article Java Magazine 1/2009

Questions?

Scala: functional programming for the imperative mind

2 comments

Notes on slide 1

9 Favorites