9 medium length proposals
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.
Most of us have an experience of functional programming that is isolated to small libraries or specific immutable data structures. But can we design our entire application architecture in a purely functional way? Can we do "aspect-oriented" programming with cross-cutting concerns that are compositional and checked by the type system? Yes we can, and in this talk we will look at a conceptually simple recipe for making that happen. We will see that the best things in Scala are Free.
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!
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.
Let's say we wanted to design our own functional programming language that targets the JVM. Let's say we wanted to implement it in Scala. In this talk, we will discuss how we might go about doing that, what problems we might run into, and what tools we might use in order to get up and running quickly.
Scala is a strongly typed language. This means we want to preserve as much information in our APIs as is reasonable to ease the burden of consumption for our users. In this talk we'll examine a few common requirements we'd like to enforce on our users, and how to accomplish this in the typesystem. Examples include: * The ability to serialize a type. * Ensuring a component is initialized when a method is called. * Adding a method to a generic class [T] that is only applicable for a specific type. e.g. [String]. * Typesafe key-value maps. * Enforcing ownership of values.
At Netflix we're big fans of JVM languages. In particular we're building live device catalogs and partner tools in Scala using Scalatra and Swagger for efficiency and high maintainability. In this talk I'll give an introduction to the Scalatra REST API mini-framework and accompanying Swagger documentation framework, and discuss best practices for design, documenting, integrating and building your API's.
There are many methods of documenting source code. Most codebases heavily rely on the naming of classes and methods, along with things like doc comments to convey intention. Relying on words to understand source code is fraught with problems. Words are inexact, dependent on understanding and are easily allowed to become incorrect with respect to the source. This talk will demonstrate types and tests, not only as important for correctness, but also great tools for documentation.
If hearing 'regular expression' makes you think of Perl or that Jamie Zawinsky quote, think again! Kleene algebras are a generalization of regular expressions that can be used to compute transitive closure, shortest path, solve linear equations, and more! This talk will explore Kleene algebras, model them in Spire, and go through several concrete examples, with particular attention to regular expressions and languages. We'll see how algebraic properties plus laziness allow an amazingly expressive and powerful implementation.
12 short length proposals
What would it mean to "add" or "multiply" types like Boolean and List[Int]? Would you think me mad if I applied the quadratic formula to a type, expanded its power series, then tried to justify using this to count binary trees? And what interpretation could I possibly attribute to performing calculus on types (I'm talking differentiation here!), and what's this got to do with zippers? I'll leave my mathematical rigor behind in England, and go wild with types and algebra. And hopefully show that doing crazy algebraic stuff with types can actually throw up some surprising and useful results!
Stop deploying your war files and switch to an immutable build and deployment system. Your data is immutable, why shouldn't your servers be as well? In this talk I'll cover how to build a full deployable Amazon Machine Image (AMI) using three open source tools: * SBT for project management, dependencies, testing & generating WAR files * Gradle for simple RPM generation * Aminator to apply the RPM to an existing AMI to create your server AMI I'll also demonstrate how we use Asgard at Netflix to easily deploy AMIs to Amazon EC2 servers.
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.
A walk in the garden of the previous, current and potentially future state of publishing Scala libraries. This talk hopes to educate and motivate people who have brilliant ideas but have never published their ideas because the ceremony of publishing in the past was a turn off.
Everybody knows monads by now, so a talk about monads would hardly be worthwhile. Let's take it to the next level: monad transformers. We'll learn what they are, how they naturally emerge in your code base and how to make good use of them in Scala – and maybe even how to create your own.
If computers are supposed to be good at math, then why is it so hard to do math correctly with computers? We have trained programmers to reach for floating point types, and to deal with the fallout using some combination of profanity, resignation, and numerical analysis. This talk uses Spire's Rational and Real types to show a possible way forward. Despite some caveats, computable real numbers allow us to accurately calculate with real values as we would in math class, preserving invariants that are so useful with property-based testing.
ReactJS is a new component based JavaScript framework from Facebook that provides a one-way reactive data flow. Play! is a full stack web framework that was built with similar philosophy in mind. In this talk I will explore the benefits of merging these two technologies. Expect lots of buzzwords, immutability and live coding.
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.
I love Akka and have built some pretty cool things with it. But when it came to scaling it from one node to two nodes, it seemed mysterious. Going from one to two nodes is the hardest step, and I'm going to step through the process. Together, we will build a Akka Cluster from scratch. Once we get off the ground, I will show some cool things like Cluster Singleton Pattern and Scheduled Tasks. Join me on the adventure from Zero to Cluster.
Are you interested in Scala Macros, type-level programming and shapeless applied to PEG parser generators? In this talk I will introduce to you parboiled2, a powerful library for encoding of PEG rules in DSL. We will work through a running example to have a hands on experience and clear understanding of library's functionality. We will consider how well-typed shapeless-based DSL saves developers from shooting themselves in a leg while doing value stack manipulations. Finally, we will look under the hood of parboiled2 to see how Macro Paradise makes it so fast and effective.
In this talk we will discuss how one can go about learning Scalaz. First, we will demonstrate the purpose of Scalaz. Next, we will pick up a few typeclasses and data structures that can improve any style of Scala program.
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.
19 lightning length proposals
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!
This talk will demonstrate how to easily call into Mathematica from Scala code (incl. the REPL), and likewise, how to use Scala libraries from Mathematica. Just a few lines of code are needed to link the two (Mathematica and the JVM), allowing the programmer to harness the features of one system from the other. You can effectively use the Mathematica front-end as a front-end for Scala code (similar to the Scala notebook, presented last year in Philly), and you can use Scala or Java code (or any other JVM language) as a front-end for computations done in the Mathematica kernel.
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.
A quick tour of the sbt plugin ecosystem, covering popular ones, not-so-popular ones, and my favorites.
At Banno, we take on upwards of thirty interns every summer with a good bunch interning throughout the year too. http://instagram.com/p/atWnTSPcXm/ and http://banno.com/internships/. A majority of these interns gain proficiency in Scala through a rigorous bootcamp and several projects throughout their term. Interns help foster a learning culture through mentoring one another and "Internspectives". We'll present some of the challenges we've ran into and some of the common learning hurdles we've ran into.
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.
An ‘unsafeCoerce’ is the ultimate type system cheat, and a crucible for the “importance” of a type system bug, as it's equivalent to proving P ∧ ¬P. I will show you a few nice, simple unsafeCoerces using Scala type system bugs ancient and fresh, and demonstrate how to turn a simple ClassCastException bug into a full-powered unsafeCoerce.
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.
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!).
This talk will be a whirlwind tour of some exotic corners of Spire: 3-6 cool hacks and demos that show off the powerful combination of parameterized types, algebra, and a little bit of math.
Scalaz's Validation[E,A] type holds either an error of type E or a result of type A. They provide a monadic error handling alternative to exceptions. They also play well with JSON. Validations can easily be serialized and deserialized. Instead of signalling API errors with a 5xx error code, why not return well-formatted JSON containing a description of the error?
A quick review of some of the ways you may be failing to take full advantage of Options. Sure, you know "if(x.isDefined())", but are you also using "toList()"? "foreach()"? "orElse()"? Do you know the difference between "exists()" and "forall()"? Following the quick review will be a short quiz with prizes for the winners.
Monad transformers solve an enormous number of very practical problems which arise when using monads in a real application to do real things with real data and real effects. Really. On top of that, they're a surprisingly simple construct with a number of very compelling examples. This talk will (very) quickly and thoroughly explain the essence of monad transformers, taking you from beginner to expert level with more than enough time left over for coffee and cookies.
Rapture JSON has loads of really cool features, like dynamic path navigation, extraction straight into primitives, collections or case classes, pattern matching on JSON literals, automatic serialization, and alternative mutable implementations of parsed data structures. But I already talked about this last time I came to New York, so instead, I'll just apply all that same awesomeness to XML, and give a whirlwind introductory tour of Rapture XML!
With macro annotations it has finally become possible to break the chains of locally-scoped expansions and generate code to be visible by everyone in the program. In this talk we'll discuss possibilities enabled by this feature and philosophical challenges that arise from our newly acquired powers. Finally, we'll see how the compiler mechanism underlying macro annotations can be used to implement a new, yet unseen flavor of macros.
Quick introduction to the features coming in sbt 1.0, along with demonstration of the client-server prototype. Primary features: * Client-server model for sbt core engine * Project Natures, and simplified plugins * incremental tasks with `.previous` * Highlight of other potential features.
A look at using unapply to define API endpoints as partial functions. See how to implement a simple version of Unfiltered's pattern matching syntax. case GET(Path(Seg("record" :: id :: Nil))) => {/*...*/}
I present a complete implementation of a declarative tableau-based theorem prover written as a pure relation. I explain embedding of logic programming in Scala and compare results with scheme-based and prolog-based theorem provers of leanTAP variety.