Panel: Scaling with Scala
Your Talk Title
Proposed talk description goes here, just a few sentences please! All talks (except the anchor talks) will be limited to 30 minutes including questions, so you should plan to speak for 25 at most. Copy this template and place your talk's entry below by Monday January 10th at midnight.
There are many people running Scala code in production environments with thousands or millions of users, and many people writing Scala code in teams of dozens or more. This panel will bring together people with experience writing software for many users or with large teams, and discuss the joys and pitfall of scaling Scala in every sense.
Foursquare's Query Language
Foursquare has written a type-safe query language for MongoDB that extends Lift's Record. It is extremely expressive (almost any MongoDB query can be expressed) and yet extremely type-safe (parameters to queries, operations on fields, and results are all statically typed). This talk will explore the API and the implementation of Foursquare's Query Language.
Harry Heymann, foursquare
Advanced Lift Techniques
Currently the largest lift site in production (I think?), foursquare serves over 1000 requests per second to users of our website and Rest API. Over the past year and a half we've developed some interesting techniques for building large scale Lift based applications. We've also worked with dpp and the Lift team to continue to push the framework as a whole. I will show off some of these techniques in foursquare code and answer questions about running Lift in production.
Brendan W. McAdams
MongoDB + Scala
I'd love to do an updated version of my talk on MongoDB + Scala. Casbah 2.0 will be out and well along by the time this runs. It'll also give me a chance to wax on Pimp My Library, implicit conversions, type aliasing and all the other fun things aspiring coders should know.
Implicits without import tax: How to make clean APIs with implicits
This talk covers how to utilize Scala implicits for powerful, expressive APIs without requiring explicit import statements for the user. These techiniques will help you improve your own libraries ....
Actors: can we do better?
Actors have gotten a lot of attention as an approach to writing concurrent programs. Unfortunately, actors rely on side effects and as a result have limited composability. In this talk I'll explore an alternative to actors that can be used to express stateful concurrent computations without resorting to side effects and without destroying composability.
Experience report: Scala and purely functional programming at Capital IQ
has been a commercial user of Scala since 2008 and we've primarily used Scala as a purely functional language. During that time we've gone from one person using Scala for a single project to about ten people using or having used Scala on several projects. I'll talk about the good, the bad, and the ugly of our experiences with using Scala during the past three years.
Continuations and Other Functional Patterns
This will be a quick recap and continuation (ha!) of my last talk to the NY Scala Enthusiasts, called
. We'll explore a few elegant, useful, and fun design patterns from functional programming, with plenty of sample code in Scala.
Building an HTTP streaming API with Scala
How to push live activity from a Java web application, through RabbitMQ, to a Netty-Unfiltered server to broadcast messages to many open connections using few threads.
Scala Performance Considerations
It's a well known fact that Scala performance is generally on par with Java. However, using certain language constructs can make Scala programs run slow.
The goal of this talk is to consider trade-offs between code elegance and performance.
Scala and the Semantic Web
is a sandbox for the
RDB2RDF Working Group
, aiming at exposing Relational DataBases to the
In this talk, I propose to demo how one can use Scala to interact with the Semantic Web using FeDeRate. We will also discuss about the implementation.
A Quick Tour of Scalaz
Scalaz is an open-source library for Scala which provides abstractions to facilitate pure functional programming. A brief introduction to Scalaz's pure functional data types and type classes, including Monoids, Monads, and all the rest.
The Guerrilla Guide to Pure Functional Programming
Everything is a function. Every data structure is really a program. Every program is a single referentially transparent expression. These and other claims are substantiated. Leave your side-effects at the door (or at least put them in a continuation).
XML databinding with scalaxb
This talk will be a quick tour of
, an XML databinding tool for Scala that turns XML Schema definition into case classes, its use of typeclasses, and restful API using Unfiltered.
Building loosely coupled and scalable systems using EDA
Event-driven Architecture (EDA) is a software architecture pattern promoting the production, detection, consumption of, and reaction to, events. This architectural pattern may be applied by the design and implementation of applications and systems which transmit events among loosely coupled software components and services..
Persistence of Scala case classes into MongoDB
MongoDB and Scala are a pair of technologies capable of delivering impressive results when used properly together. Alas, currently available tools don't provide a convenient, simple, fast, and maintainable way of persisting Scala objects into MongoDB in a type-safe way. I've spent the last 18 months exploring various approaches to this problem, and in this talk will explain what dead ends I've encountered along the way. To top it off, I'll present my newest work in this field,
sbt 0.9: Why, what, how?
An overview of the changes coming in sbt 0.9, as well as the motivations and thinking behind them.
How Scala Influenced Haskell
(or is it the other way around?... ;^) Scala borrows many good ideas from Haskell, from syntactic elements to major features. I'll discuss some of these influences and also describe ways in which Scala and Haskell are different.
The Design of the Scala 2.8 Collections
The collections library was significantly revised in Scala 2.8. Some of the changes solved design problems, such the desire to return new instances of the same input type, rather than a common parent type. Other changes make it easier for user's to create their own collections that exploit reusable features. I'll describe several of these changes, using examples.
Presentation of Squeryl
Squeryl aims to be an ORM/DSL for talking with Databases with minimum verbosity and maximum type safety. The presentation will be a quick tour of the features, I will then go over the design decisions and compromises that were made in attempting to blend the Relationnal, FP, and OO paradigms together,
followed by a discussion on how implicit conversions and the type system were used to enforce the typing rules prescribed by SQL, via a type arythmetic.