Online and physical events scheduled on FPish.uuid:fe2fdcb4-3834-4b64-90e6-a19c607c18aa;id=68832013-09-21T23:59:51Z//course/5332013-10-16T00:00:00-07:002013-09-21T23:59:51ZYou will have one whole day to find out what makes Erlang such an effective tool for innovation. Discover how companies solved real-world challenges with Erlang and learn from language experts. What you'll learn: What makes Erlang unique among other general purpose software platforms How others have used Erlang as a competitive business advantage Practical strategies for getting started with Erlang in your organization //course/5362013-10-15T00:00:00-07:002013-09-21T23:59:51ZErlang’s basic features are a perfect match for massively concurrent, distributed cloud environments. Being rooted in an actor model with no shared memory, the complexity of multi-core programming is hidden from the developers, allowing them to focus on the program. This tutorial will introduce Erlang and its actor model, explaining how it is positioning itself to win the multi-core challenge.//course/5342013-09-14T00:00:00-07:002013-09-21T23:59:51ZExpect to find out about the latest developments and innovations in the world of Erlang from the likes of Erlang co-inventor Joe Armstrong and Mahesh Paolini-Subramanya - creator of the first Erlang Cloud PBX. If you're new to Erlang, expect first-hand accounts on why Erlang is the best fit for building scalable, fault-tolerant distributed applications faster, with smaller budgets and with smaller teams. Adam Denenberg, VP of Engineering at the Huffington Post, will present the architecture and setup built by Huffington Post to power their realtime websocket-based commenting framework.//course/5352013-09-11T00:00:00-07:002013-09-21T23:59:51ZThis course is taught Robert Virding. Robert is one of the best people to learn from, not only because he's one of the inventors of the language but also because he taught it to literally hundreds of developers. The course contains all the Erlang basics such as sequential and concurrent programming, along side error handling. The Erlang development environment is presented, with a special emphasis on the Erlang mode for Emacs alongside the major debugging tools. Good and bad programming practices are discussed, as are tools used to profile the system. OTP design principles and concepts are sneaked into the material as well as the exercises. //course/4862013-06-13T00:00:00-07:002013-09-21T23:59:51ZThe 19th Erlang User Conference will feature over 40 speakers. Each year, the Erlang User Conference in Stockholm brings together more and more developers and companies using Erlang across the world. Whether you have been coming to the conference from the first edition - 19 years ago or this is the first time you are thinking to join, we guarantee this is where you will get to hear the best Erlang experts talking about the latest projects and innovations in the world of Erlang. //course/5322013-06-12T00:00:00-07:002013-09-21T23:59:51ZAndrew Phillips & Nermin Serifovic One of the most advanced programming languages of today has surely outgrown the gotchas, puzzlers and head-scratchers of the past. Really? Scala Puzzlers returns with a totally new range of seemingly simple examples which demonstrate that there's plenty of head-scratching left in Scala 2.10! Let your mind be challenged by unexpected and unintuitive behaviour and results and learn something about your favourite language in the process. And unlike in a real magic show, we'll even be giving away the solutions :-)//course/5312013-06-12T00:00:00-07:002013-09-21T23:59:51ZEver dreamed of writing you next Rich Internet Application in Scala, enjoying all the Scala goodness, but not sacrificing JavaScript interoperability? Then come and meet Scala.js, a JavaScript backend for Scala. Scala.js compiles full-fledged Scala code down to JavaScript, which can be integrated in your Web application. It provides very good interoperability with JavaScript code, both from Scala.js to JavaScript and vice versa. E.g., use jQuery and HTML5 from your Scala.js code, either in a typed or untyped way. Or create Scala.js objects and call their methods from JavaScript. For the most part of the talk, we will show off Scala.js and its features through some examples and code samples. We will then present our future plans for Scala.js, and we'll be very interested in knowing what *you* want Scala.js to be. //course/5302013-06-12T00:00:00-07:002013-09-21T23:59:51ZIsmael Juma & Alois Cochard Designing a REST API for multiple applications and devices is typically an exercise in trade-offs. A single API offers efficiency in terms of building and maintenance costs; specialised APIs, though tedious to build, can be optimised for each particular use-case, removing unnecessary computational overheads. At Time Out (http://www.timeout.com/), we are experimenting with a Graph-based approach that takes full advantage of Scala's functionality to provide the best of both worlds: an optimised and flexible API with no boilerplate. In this talk, we discuss how your domain can be modeled as a graph and introduce Shona, a library which facilitates integration of data from heterogeneous data sources and links it together in a consistent and flexible Graph API. We compare Shona with other approaches (LinkedIn, Netflix and Facebook) highlighting its strengths along with possible areas for development. //course/5292013-06-12T00:00:00-07:002013-09-21T23:59:51ZThe decipherment of Mesoamerican hieroglyphic writing systems advanced at previously unparalleled rates in recent decades. One of the keys to this success is the application of methodologies developed and applied successfully to other writing systems. The purpose of this presentation is to show how some of these methodologies, from Natural Language Processing and Hermeneumatics, can be successfully applied to the Maya hieroglyphic writing system thanks to the power and versatility of Scala. In particular, the research framework presented here makes extensive use of the facilities that Scala provides to build external Domain Specific Languages that epigraphers can use both to provide accurate transcriptions and transliterations of hieroglyphic texts, and to query the linguistic corpora for quantitative and qualitative analyses.//course/5282013-06-12T00:00:00-07:002013-09-21T23:59:51ZScala provides a wide variety of productivity- and correctness-enhancing features, but some of those come at the cost of performance. I will discuss how to design Scala applications to take maximal advantage of Scala's best features while still yielding Java-like performance--or better since you can spend your time thinking and optimizing instead of writing boilerplate! Topics will include how and when to write microbenchmarks, the intrinsic speed of various common library routines, the pitfalls of the first-get-it-working-then-run-the-profiler mode of optimization when performance really matters (and how to let the profiler help you), and patterns to favor when you know a priori or via profiling or benchmarking that performance is critical.//course/5272013-06-12T00:00:00-07:002013-09-21T23:59:51ZChristopher Vogt & Stefan Zeiger Slick is not an object-relational mapper, but a functional-relational mapper leading to unique benefits. Using Slick efficiently may be counter-intuitive to people familiar with ORM systems. This talk explains how common ORM use cases should me implemented differently using Slick and what the benefits are. In short, ORM systems suffer from the consequences of the object-relational impedance mismatch, where in contrast Slick's mapping to functional programming constructs is rather straight forward. This allows for tight integration with Scala and highly re-useable code for composing queries. //course/5262013-06-12T00:00:00-07:002013-09-21T23:59:51ZPolymorphic function values are one of the key abstractions in shapeless: they are crucial to enabling sequence-like operations such as map, flatMap and filter to be performed on HLists (data structures which combine the heterogeneous typing of tuples with list-like characteristics). Their encoding in Scala has been refined over a number of iterations, but remains a little heavyweight relative to the syntactic ease with which ordinary monomorphic functions or polymorphic methods can be defined. In this talk I will show how we can use macros to automatically promote polymorphic methods to polymorphic function values and how that improves the usability of shapeless. //course/5252013-06-12T00:00:00-07:002013-09-21T23:59:51ZSpark Streaming is a new extension to the Spark cluster computing framework that enables high-speed, fault-tolerant stream processing through a high-level Scala API. It builds on a new execution model called "discretized streams" to provide exactly-once processing without the heavy cost of transactions required by previous systems (e.g. Storm), allowing it to process significantly higher rates of data per node while still recovering from faults in seconds. It also greatly simplifies stream programming by providing a set of high-level operators (e.g. maps, filters, and windows) in Scala. Perhaps the most exciting feature of Spark Streaming, however, is that it combines seamlessly with Spark's interactive and batch processing features, allowing ad-hoc queries on stream state and programs that combine streaming and historical data. Spark Streaming scales linearly to 100 nodes and has been used to build applications including session-level metrics reporting and online machine learning.//course/5242013-06-12T00:00:00-07:002013-09-21T23:59:51ZAsynchronous IO is one of the most important building blocks when designing high-performance systems. Over the years various patterns emerged on top of the selector based services provided by the operating system. In this talk I will give a quick overview of the most important asynchronous IO patterns from callbacks to iteratees, demonstrating various approaches to error handling, backpressure/throttling and exposing low level behavior. Finally I will show how these approaches map to the actor world, introducing the new IO model designed by the Akka and Spray team available in Akka 2.2."//course/5232013-06-12T00:00:00-07:002013-09-21T23:59:51ZThe Spring Framework is one of the most popular Java frameworks used today. While it is possible to use Spring in Scala, it does feel awkward in certain places, because of the "Javaism" peering through. For instance, using callback interfaces feels strange in Scala; functions would be a better match. In October 2012, I introduced the Spring Scala project, which solves this particular issue, and aims to make it easier to use Spring in Scala in general. In this session, we discuss the Spring Scala portfolio project and its feature set.//course/5222013-06-12T00:00:00-07:002013-09-21T23:59:51ZDespite unifying frameworks like Akka, distributed systems often look like a patchwork of special-purpose tools, libraries, and frameworks. For example, the essential task of persisting objects by pickling (or serializing) them to a binary or text representation is typically outsourced to a third-party serialization framework. Many of these frameworks, like Google's Protocol Buffers, lack support by the Scala compiler or integration with the Scala standard library, resulting in suboptimal performance, unsatisfying Scala support, or both. Furthermore, to obtain good performance using one of these frameworks, it's often necessary to roll your own type-specialized custom serializers, requiring significant boilerplate. This talk presents a new pickling framework designed for Scala with a few attractive properties: (1) using the framework requires little to no boilerplate, (2) using Scala's implicit parameters, users can add their own easily-swappable pickle format enabling users to persist to a number of formats, binary, JSON, or your own custom format, (3) using the type class pattern, users can provide their own custom picklers to override the default behavior of the pickling framework, (4) static, macro-based generation of picklers enables significant performance improvements. In microbenchmarks our framework achieves a factor 6 speedup over Java Serialization, and performs on par or up to 3 times faster than popular fast Java serialization frameworks like Kryo. We'll show how this new framework can be used as a drop-in replacement for other serialization frameworks, and what's in store for Java compatibility. Finally, we'll present an experimental abstraction, called spores, well-behaved, composable pieces of functional behavior that can be cleanly pickled, transported over the wire, unpickled, planted, and more. //course/5212013-06-12T00:00:00-07:002013-09-21T23:59:51ZPhilipp Haller & Jason Zaugg Ever wished the compiler could make asynchronous programming easier? Enter Scala Async. Do asynchronous I/O like “normal” blocking I/O, program with Futures and Promises even more naturally! Scala Async makes it possible to “suspend” at arbitrary points in a block of regular Scala code, and to “resume” from that point later— all without blocking. This not only makes it possible to make concurrent code look sequential, it makes it possible to actually use even the most unfamiliar asynchronous libraries in a familiar blocking style. What’s more, not only does it come out-of-the-box seamlessly integrated with Scala 2.10’s new Futures and Promises API, but you can also easily use it with any other event-driven Scala or Java library of your choice.scala,java//course/5192013-06-12T00:00:00-07:002013-09-21T23:59:51ZScala continues to be fun! Implementing algorithms to solve Sudoku puzzles, bioinformatic problems, and analyzing time-series data has been a great learning experience. Creating video games and mods have made my game time much more enjoyable and gave me an opportunity to impress my friends! To do all these, I used a myriad of technologies from Scala IDE, sbt, and giter8 to git, Android, and Play! In the process, I learned a lot more about Scala's features such as traits, iterators, streams, lazy vals, implicit classes, and typeclasses. In this talk, I will share a few games, Android apps, and algorithms that show how Scala made implementing complex programs simple. I will also demonstrate a few awesome Minecraft mods written in Scala and a "mind blowing" project. //course/5202013-06-12T00:00:00-07:002013-09-21T23:59:51ZWith IntelliJ IDEA frequently called the most intelligent Java IDE, JetBrains is working to replicate similar levels of code assistance and developer tools for Scala. This presentation will showcase some of the IDE’s trickiest features that help developers to be more productive, and will provide a brief overview of IntelliJ IDEA’s plugin infrastructure for Scala development, including support for SBT, Play Framework and Scalate.//course/5182013-06-12T00:00:00-07:002013-09-21T23:59:51ZIn this talk, we discuss some interesting extensions to the cake pattern as described in Real­World Scala: Dependency Injection (DI) by Jonas Bonér. We consider the use of the cake pattern to express hierarchical components, and the high­level design constraints between them. We also discuss encapsulating the details of a composite component. The cake pattern suffers from three major problems that limit its adoption: 1. Verbosity: Lots of boilerplate. 2. Opacity: Hard to follow the code because the language idioms used do not signify the user's intent. 3. Compiler error messages are confusing. We present a specification for a suite of type macros to address the problems of verbosity and opacity. We provide a status report on the implementation of these macros to date. //course/5172013-06-12T00:00:00-07:002013-09-21T23:59:51ZA case study of how Scala and Akka helped a team of software developers without a whole lot of distributed system programming experience build a fairly sophisticated, production quality distributed system with a custom multipaxos implementation at its core. The name of the system is Sirius, and we're using it to power the next generation of our API layer at Comcast's Interactive Media division. The talk will focus on how we use'd Akka and Scala to build the core of the system. Our basic approach was to read up on all the Paxos literature we could find. We then took the psuedocode in "Paxos Made Moderately Complex" and translated it wholesale into straightforward Scala using functions and tuples. Then we slowly massaged that code into something cleaner using case classes before moving it into Akka actors. Finally, we went through that naive implementation to optimize our usage of memory and network resources to finish the core Paxos implementation. We've had this running in production for about half a year now with only minor issues. Given that we had very limited experience with distributed systems, this a major miracle that we couldn't have pulled off without Akka. //course/5162013-06-12T00:00:00-07:002013-09-21T23:59:51ZIn this session we will have a round at all new functionalities introduced in the latest sand greatest Scala IDE V3.0 release, and outline the future direction of the tool. Semantic highlighting, implicit highlighting, and a new shiny Scala debugger are the spotlights of version 3.0. Scala code is now easier to read, write, test and debug. Furthermore, a growing ecosystem of plug-ins is available right at your fingertips for customizing your Scala environment just the way it fits you best. The focus of the next releases is on enhancing the Scala debugger, further improving the editor's responsiveness, and add first-class support for both Play2 and Sbt. Sounds too good to be true? Come and see for yourself the Scala IDE in action!//course/5152013-06-12T00:00:00-07:002013-09-21T23:59:51ZAnnounced right before 2.10.0-final, macro paradise became the home for experimentation in the macro land. In this talk I will cover the ideas we played with and outline what panned out and what did not. What's going to happen to quasiquotes? Are type macros useful enough? Do macro annotations make sense? Come over and find out the answers.//course/5142013-06-12T00:00:00-07:002013-09-21T23:59:51ZIt's 2018. Scala is now 15 years old and the dominant programming language for enterprise apps. But how did we get here? What hurdles did we tackle and what hurdles tackled us?//course/5132013-06-11T00:00:00-07:002013-09-21T23:59:51ZJan will show how to use RabbitMQ to connect components on different platforms. After a few introductory slides explaining the main concepts, the rest of the talk will be live code. The coding will begin by showing simple Scala / Akka code to connect to RabbitMQ to send and receive messages--think ``java.lang.String`` values back and forth to start with. We will then increase the complexity of the messages and marshal the messages into JSON. Jan will then show the real power of messaging infrastructures by replacing the RPC server component by native code in C++: we will write image processing component. To make matters even better--faster--we will then use CUDA to perform the image processing. Come to Jan's talk and demo if you want to find out how to use Scala, Akka and RabbitMQ in the core of your application, especially if your application needs to tie together code on completely different platforms and if it performs heavy number crunching or image processing. You do not need to have deep knowledge of Scala, Akka, RabbitMQ, Boost, OpenCV, ...; all that you will need is your _inner geek_. //course/5122013-06-11T00:00:00-07:002013-09-21T23:59:51ZA lens represents a readable and "settable" location in a possibly nested immutable object. Lenses aren't in the Scala standard library, but several libraries provide them, including Scalaz and Shapeless. I'll show how you to use the Shapeless version, and we'll look at how it's implemented. This may interest you if: ...you use immutable objects ...you use nested immutable objects ...you want to abstract over different fields in your immutable objects ...you're interested in functional programming This is an informal, introductory talk, suitable for newcomers to Scala and newcomers to functional programming. //course/5112013-06-11T00:00:00-07:002013-09-21T23:59:51ZRealtime Web Applications are applications making use of Websockets, Server Sent Events, Comet or other protocols to offer an open socket between the browser and the server for continuous communication. Several web frameworks target the development of this type of applications but they mostly feature a basic API that allows developers to push/receive messages from/to an open channel: channel.push(message) //and channel.onMessage { callback } These APIs fall short when it comes to manipuling a rich set of streams of data, which is central to the Realtime Web model. It presents indeed several challenges in terms of creating, adapting, manipulating, filtering and merging streams of data as well as in terms of synchronization involved. To respond to this challenges, it is crucial to have a programming model that identifies clearly what a stream of data is and defines composable components to deal with it. Play2 uses Iteratees together with Futures for dealing reactively with streams of data, providing a very rich model for programming rich Realtime Web Applications. //course/5102013-06-11T00:00:00-07:002013-09-21T23:59:51ZScala's mix of functional and object oriented programming paradigms is ideal for building data pipelines. Many smart people have noticed this, and as a result, we now have three distinct APIs for creating MapReduce pipelines in Scala (Scrunch, Scoobi, and Scalding), as well as a standalone data processing framework developed purely in Scala (Spark). Although all of these tools showcase the power and elegance of Scala, there is a larger opportunity for the community to give pipeline developers a single API to use for both in-memory and batch-style data processing. We'll discuss some of the challenges in creating an API that balances the features of both in-memory and batch processing and demonstrate the benefits that this creates in ETL development, exploratory data analysis, and machine learning.//course/5092013-06-11T00:00:00-07:002013-09-21T23:59:51ZAs the author of an open-source serialization library in Scala, I've undergone a lot of struggle to understand and harness the power of Scala's type system. My library was based on parsing pickled Scala signatures, which was a subterranean and sparely documented feature of Scala 2.8. I wanted to serialize and deserialize options, lists and maps, which required defeating type erasure when serializing while skating by on type erasure when deserializing. I struggled with multiple constructors, checking for annotation types, specialization, more. The new reflection libraries introduced in Scala 2.10 provided easier access to the same information I had been getting from the pickled signatures. This talk will address practical aspects of type mining, providing a library of hands-on examples using the Scala 2.10 reflection API.//course/5082013-06-11T00:00:00-07:002013-09-21T23:59:51ZProfile-driven JIT compilers like those in most JVMs provide good performance on average, but they are a black box with highly nondeterministic behavior. Thus, achieving top performance, predictably and consistently, is very hard. This talk will present Lancet, a research JIT compiler written in Scala that allows the running application to take full control of the JIT process. This includes the ability to compile multiple specialized versions of code paths at runtime, which is key for removing abstraction overhead of high-level, generic code. Another key feature of Lancet are JIT macros, which enable execution of user code at JIT-compile time and thus open the door for "smart libraries" that come with domain-specific optimizations and checks. Unlike Scala macros, JIT macros are not a front-end system, but tightly integrated with regular JIT compiler optimizations and VM functionality like speculative optimization and re-optimization.