Scala in practice

Scala In Practice: A Case StudyTomer Gabel, newBrandAnalytics April 2012

Some context circa 2011:• Startup with limited budget• Cloud hosted, Linux based• Complex prototype codebase – Lots of Java code – Serving paying customers

Strategy 101 Supplant Evolve Refactor Complete with newcodebase and extend rewrite architecture

Data points• Complete system rewrite impractical – Too much code – Business continuity a priority – Cannot afford product stagnation• Team comfortable with Java platform• … but want a better language

Why Scala?• JVM-targeted, statically typed• Success stories (Twitter, Foursquare, LinkedIn)• Active community• Good (not perfect) tool ecosystem• Reasonable learning curve

Alternatives • Dynamic • LISP dialect • Dynamic • Java-like syntax • Script-oriented • Static • Java-like syntax • In its infancy

Scala in a nutshell• Pervasive type inference

Scala in a nutshell• Type aliases, closures, first class functions and comprehensions Output:

Scala in a nutshell• Imperative with functional-style constructs

Scala in a nutshell• Traits: static mixins

Scala in a nutshell• Pattern matching FTW!

Scala in a nutshell• Other goodies – Option wrappers (no more NPEs!) – Powerful collection framework – Implicit conversions – Concurrent, immutable maps (HAMT) – Built in actors

Caveat emptor• Scala is bleeding edge• You will get cut – Learning curve – Rough edges – Partial/outdated documentation• It’s well worth it, if you’re prepared!

Focal points• Learning curve• Tooling• In production

Learning curve• Risks: – Functional constructs need getting used to – Few best practices: • Coding conventions • Patterns • “Dangerous” features

Learning curve• Mitigations: – Relatively familiar syntax – Seamless Java integration • Evolve your codebase to include Scala • Reuse existing components and libraries – Lots of wow moments!

Lessons learned“New techniques are easy to explain.Old techniques are hard to maintain.” - an old Vulcan proverb• Encourage experimentation• Encourage rapid iteration• Document and share new techniques

Lessons learned• Get a good grasp of the basics: – Functions and closures – Option wrappers – Pattern matching – Traits, traits and traits• Each of these is immensely powerful• Together, they make ponies!

Lessons learned• Avoid wacky syntax! – Some common Scala libraries have atrocious syntax (scalaz) – Does this make sense to you? val p2c = ((_: Int) * (_: Int)).curried some(5) <*> (some(3) <*> p2c.pure[Option]) should equal(Some(15))

Lessons learned• Promote functional constructs: – Intent over implementation – Massive code savings – Immutability, correct code by design• Mentor junior developers!

Lessons learned• Don’t go overboard – Use implicits sparingly – Avoid tuple overload • x._1._2 * x._2 orElse x._3 == yuck • Use case classes and partial functions instead – Path-dependent types are scary!

IDE Support• Eclipse support via TypeSafe’s own ScalaIDE• IntelliJ IDEA support via plugin

IDE support• Lower your expectations• Don’t skimp on dev hardware!• Use latest IDE/plugin builds• Take your time – Grok the tool-chain – Assign a “go-to guy” (or gal)

IDE support• Wonky debugging – Java debuggers work… – … with some caveats • Step into synthetic stack frames • Do not step over closures – TypeSafe are focusing on debugging – JetBrains will likely follow

IDE support• Except the unexpected – Spurious error highlighting • Especially with implicit conversions • Double-check with your build tool- chain – Rebuild the project occasionally – The situation is improving daily

Build tools• Native Scala build tool is sbt – Ivy2 (-> Maven repositories) – Scala syntax – Very powerful, sharp learning curve• Stay away from ant• Maven and buildr should work fine

Library ecosystem• Surprisingly mature landscape!• We use: – ScalaTest + ScalaMock – Squeryl – Scalatra• Use your favorite Java libraries natively!

GC considerations• Lots of generated classes – Higher PermGen utilization – Increase -XX:MaxPermSize• Lots of intermediate objects – High eden space churn (normally OK) – Tune with –XX:NewRatio

Other considerations• Scalac emits lots of synthetic code – Deep call graph – Intermediate stack frames• Default stack often too small – -Xss=2m should do

Nasty surprises• Different compiler, different edge- cases – Stack overflow may segfault – Crash log may fail to generate (JDK 1.6.0_x) – Logs and thread dumps are your friends

Codebase evolution Import Java codebase Refactoring Tipping point Slow growth Initial Scala experimentation

Conclusion• I would recommend Scala for: – Startups willing to take the plunge – Small teams of senior developers – Large enterprises with tech advisory/leadership teams• But not (yet) for: – Contractors – Traditional enterprises

Questions?… answers may be forthcoming

Afterword• newBrandAnalytics for allowing the use of the company name and R&D evidence• TypeSafe and the amazing Scala community for making Scala what it is• … and SmileTemplate.com for the PowerPoint template• Get in touch! – tomer@tomergabel.com – http://www.tomergabel.com

http://www.tomergabel.com	1219
http://www.scoop.it	740
http://tomergabel.com	111
http://www.linkedin.com	71
http://abtasty.com	18
http://webcache.googleusercontent.com	4
http://translate.googleusercontent.com	4
http://ranksit.com	1
http://hsmaker.com	1

Scala in practice

by Tomer Gabel

Accessibility

Categories

Upload Details

Usage Rights

9 Embeds 2,169

Statistics

Scala in practice Presentation Transcript