This year's symposium features 16 talks of 30 minutes, one keynote talk, and one 45 - 60 minute panel discussion.
Thanks to all attendees who voted for their favorite talks and panels.
Ever since its first release, Akka has been receiving a lot of interest and praise from the Scala community. With a tagline promising to deliver "Event-driven, scalable and fault-tolerant architectures", who wouldn't want to use it? The framework does indeed deliver, but it's not a general purpose technology that can or should be applied anywhere. This talk takes a pragmatic look at how Akka and Akka actors can be used in practice, looking at architecture and code examples from a real-time ad trading system.
Most people have heard of ENSIME by now as the go-to mode for Scala editing in Emacs. This alone is quite awesome, but what you may *not* know is that ENSIME itself is entirely editor agnostic! This talk will briefly cover ENSIME, what it offers, how it works, how we talk to it, and what it means for you. (I really wanted Aemon to give this talk, but as he has not submitted it, he has forced my hand!)
spray (www.spray.cc) is a suite of lightweight Scala libraries for building and consuming RESTful web services on top of Akka. In this talk I'll show you how spray makes it easy to supply your Scala applications with a high-performance, fully asynchronous REST/HTTP API, no matter whether Akka is already a key component in your application stack or not. The talk will briefly highlight the design goals and key concepts behind spray before showing off one or more real-world examples as well as emerging best-practices with regard to architecture and development process.
We investigate the facilities in various languages for higher-order programming-in-the-large. Scala developers often borrow from Haskell, but what more can we learn from the ML family? What about (heaven forbid) C++ and its template libraries? Do dynamically-typed languages enable more sophisticated code recombination and reuse? We'll ask these questions, answer some of them, and generally compare, contrast, and encode all sorts of modularity with Scala. *The “modular module” moniker was lifted from a paper by Xavier Leroy.
Extending the compiler should be easier, both in terms of the mechanics of doing so and in terms of how much you have to understand to get very far. My dream is for scalac to be a platform upon which people can build and components can compose, and for the overhead to be so low that you could (and would) write and apply useful compiler modifications from the command line. In this talk I'd share details.
Generic (aka polytypic) programming involves parametrizing programs in terms of the "shape" of the data types they operate on, going beyond what's possible with simple type parametrization. In the Haskell world it's exemplified by Scrap your Boilerplate and related projects. shapeless is an exploration of this space in Scala, and my talk shows some of its capabilities and applications and also explains some of the type class and dependent type based implementation techniques involved.
Martin Odersky didn't initially expect Scala to find a following in the field of machine learning because of machine learning's large appetite for memory and numeric computation. But the field is expanding in new ways, with interest in parallel and distributed computation, dynamically changing model structures, and the desire to put easy-to-use DSLs into the hands of non-experts. This talk will describe these trends and discuss several machine learning projects that use Scala, including FACTORIE, a 30k-line DSL for graphical models whose development is being sponsored by Google and the NSF.
Functional programming is all well and good for mapping over lists, generating the fibonacci numbers, and writing an inefficient version of quicksort, but what about the "programmers in the trenches"? You know, the ones creating CRUD applications, writing to databases, reading from files, and building GUIs with event listeners. Don't these situations require tossing out all that theoretical FP mumbo-jumbo and writing some good ol' fashioned imperative code? In this talk I'll show that FP has a lot to say about how to write and structure useful programs that perform arbitrary effects.
IO is the trickiest of operations to tackle in a functional way. Try to make IO efficient, non-leaky, composable, and pure, and the problem becomes virtually unsolvable. In this talk, John A. De Goes, CTO of ReportGrid, discusses three different approaches to functional IO in Scala, beginning with iteratees, and continuing on to stream processors and transducers.
(Play 2.0 is due to be released shortly before this meetup.) The Play framework revolutionized the Java Web application development by bringing back simplicity and agility contrasting the so-called standard way of writing enterprise applications. The whole Web architecture is fast moving towards real-time and emerging new requirements have put into question the classic assumptions like SQL as the exclusive datastore technology or the MVC application design. In this talk I will introduce Play 2.0, a Scala (and Java) Web application framework and its core concepts
If web interaction is this century's version of running water, Unfiltered is a set of Scala pipes and wrenches that work with everything from Tomcat to Netty. This talk will walk through the options for integrating Unfiltered with application servers big and small, old and new, before performing some live-plumbing for an NE Scala web service using the toolkit. (We'll do our best not to flood the conference hall.)
Apache Hadoop is the current darling of the "Big Data" world. Most Hadoop Applications are written in the low-level Java API or high-level languages like Hive (a SQL dialect). I examine how OOP and Java thinking is impacting the effectiveness of Hadoop, both the internals and the way you write applications. Using Scala examples from tools like Scrunch, Spark, and others, I demonstrate why functional programming is the way to improve internal efficiency and developer productivity. Finally, I look at the potential future role for Scala in Big Data.
We believe that one should never have to choose between productivity and scalability, which has been the case with traditional approaches to concurrency and distribution. The cause of that has been the wrong tools and the wrong layer of abstraction and Akka is here to change that. Akka is a unified runtime and programming model for scaling both UP (utilizing multi-core processors) and OUT (utilizing the grid/cloud). With Akka 2.0 this will be taken to a whole new level, "Distributed by Design".
Even simpler than the Cake Pattern, more flexible than Guice, and more powerful than Spring, the ultimate tool in dependency injection is already built into Scala.
Beginner-friendly talk introducing the concept of “typeclasses”. What are these “typeclass” things Scala people are always talking about? Where did they come from? How are they expressed in Scala? Are they in the Scala standard library? When might I want to use them instead of other kinds of polymorphism such as inheritance and overloading? (reprise of talk previously delivered at Boston Scala)
Asynchronous and non-Blocking network frameworks have become a big deal: tools like node.js and BlueEyes have set the pattern for new projects. Many Scala developers don't understand these approaches though. In this talk I'll introduce Async/Non-Blocking IO and demonstrate both Netty & Raw NIO – and discuss strengths and weaknesses of each. We'll also discuss patterns and concepts around this: The use of callbacks, Either[E, T] to pass errors, implicit tricks to simplify them and even the Iteratee pattern. * this talk is unsynchronized
With a name like Scala it's gotta scale, right? And I don't mean extensibility of the language or dealing with larger code base. I mean doing the heavy lifting at the runtime. Does Scala really help? In this panel, I'd like to see a candid discussion on various strategies for scaling the performance and tradeoffs that comes with each solution.
We've got room for 30 Scala Workshops, in five different rooms and 6 timeslots. The unconference orientation and planning is 9-10 in the morning. We can't serve food in this space so please arrive caffeinated and ready to workshop.
There will be two morning sessions, DIY lunch 12-1:30, and four afternoon sessions. Anyone can organize a workshop. The best workshops will be highly interactive and educational.