A gathering of statically refined types
self-selected by you, from the northeasterly regions of the US
Sat Mar 1, 8am to 6pm
Seating on day 1 is limited and is now sold out. (Join the day 1 waiting list to be notified when a spot opens if someone cancels.)
Sun Mar 2, 9am to 5pm
In past years we've had workshops, panels, talks that didn't make it into day 1, debates, group hugs (well, not really). The unconference is whatever you want to make of it.
We're taking over all three floors of Meetup HQ, so there will be plenty of room for everyone, even those who didn't get in for Day 1.
Unconference participants will collectively fill the schedule grid first thing Sunday morning. Bring your laptop, and your conversation ideas.
Rooms, projectors, whiteboards, and markers will be provided. (Video adapters will not be provided! Make sure you bring your own.)
There might be food; we're working on it.
Grab a drink and share some stories at Thom Bar.
"Grab a coffee and a nametag. Then grab more coffee. Then grab a seat."
"Opening remarks and class begins."
Lots of people talk about doing magic with Scala’s type system: “dependent types”, “type-level computation", "typeclasses". What are dependent types really? And what does Scala have to do with them? This talk will turn the academese into English, starting with a whirlwind tour of Scala’s type system and all the things that make people call it “powerful”. We’ll delve into what dependent types are across different PLs like Coq & Idris, comparing throughout with Scala. We’ll see how cool libraries like shapeless and spiral fit into the picture. Finally, we’ll cover how dependent types are useful!
Programming is all about manipulating data. This talk will explore the crucial importance of data representation and semantic meaning. We will pay particular attention to the question of how correctness can be *forced* simply through careful data design. By the time we're done, you will have acquired a burning hatred for raw integers, a loathing of strings and a renewed understanding of how static typing can help us construct correct code, not just code which avoids trivial type errors.
Many, if not most, of the analytics workloads at Twitter have common properties: they are streaming, aggregations are associative, and they are cleanly expressed in map/reduce style. We implemented Summingbird, a type-safe API to allow us to program Hadoop, Storm and soon Spark and Akka, with a single code-base. Summingbird is used at Twitter to power realtime analytics and consumer facing products. In this talk, we will witness the power of monoids, combinators, and abstract types to build portable streaming aggregations.
"Disperse for food."
Using type-level computations via implicits one can state amazingly precise facts about Scala programs in a neat, declarative style. With macros it is also possible to do computation during compilation, typically working in a straightforward, imperative way, being effective, but too bruteforce for some. Are macros principled enough, or they are just a hack? In this talk, we, Eugene Burmako and Lars Hupel, will compare type-level and macro-based approaches and figure out how they can work together for mutual benefit.
Scalaz-stream is a streaming I/O library written atop scalaz. This talk will give an overview of the library and its programming model and walk through examples of its use. We'll also see how to bind scalaz-stream to APIs that rely on callbacks, actor-based systems, and imperative code.
As a conceptual framework, functional programming empowers us to write software that is modular, highly reusable, and easy to reason about. But practicing this discipline in Scala comes with a number of difficulties and idiosyncrasies that need to be addressed. In this talk we will look at what those are, what solutions exist, and whether we can in the end write purely functional programs in Scala that have reasonable memory and performance characteristics.
The oft-criticized tool sbt gets a bad rap. Here at Banno, we'd like to dispel those doubts. We've embraced sbt to help manage an overwhelming amount of dependencies and projects. The count of projects (both libraries and deployables) is in the high double digits, but overhead maintenance is near minimal. Banno developer happiness with sbt is high. We'll cover how we've attained that and some common idioms that any large organization wishing to adopt sbt should take to heart.
GeoTrellis is an open source framework for working with geographic data that's in a raster format -- data in a pixel grid. There's more to geographic data than putting pins on Google maps, and processing raster data in real time or in batch presents significant performance and scaling challenges. I'll talk about why Scala & Akka were an excellent fit, performance and API design challenges, and the future of the GeoTrellis project (on its way to becoming an Eclipse project) and the new Spark integration. Most importantly, I promise pretty pictures! Maps! Lots of pretty maps!
For the newest CMS at The New York Times, we are having fun on building a reactive messaging system on Play! 2, Akka and Websocket. To allow user having outstanding UI experience, we decide to leverage the power of Websocket. (implicit Iteratee, Enumerator and Emuneratees) This talk is focus on how we used Akka and Play! to pattern the core engine of the system. Our approach addresses multiple topics, including subscribe/unsubscribe from either multiple users or multiple tabs, broadcasting with filter and handling keep-alive protocol to keep track of user resources (i.e. locks!).
How often do you think about how the JVM views the Scala source code you write? Have you ever wondered why your Scala method's signature is so hard to invoke from Java source code. Let's lift up the curtain and peek through the cracks and compare what you see while looking at Scala source code with what the JVM sees while interpreting it's compilation unit. We might just learn something.
WartRemover provides a simple method of writing linting rules which can be executed as compiler plugins, command line tools or even as macros. A linting rule is just a pattern match over the Scala AST which can then trigger errors or warnings. This talk will demonstrate custom linting rules and show the various ways in which they can be executed.
Quick introduction to the features coming in sbt 1.0, along with demonstration of the client-server prototype.
Happy times at Foursquare HQ
Nobody likes a jerk, so show respect for those around you.
NE Scala is dedicated to providing a harassment-free experience for everyone, regardless of gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, or religion (or lack thereof). We do not tolerate harassment of participants in any form.
All communication should be appropriate for a technical audience including people of many different backgrounds. Sexual language, innuendo, and imagery is not appropriate for any symposium venue, including talks.
Participants violating these rules may be asked to leave without a refund at the sole discretion of the organizers.