Sessions at Strange Loop 2011 on Tuesday 20th September

The best Android apps are those that tightly integrate with the platform and other applications. Unlike many other platforms, in Android this capability is available to any application developer; Android is designed for users to hop from app to app seamlessly and for data to be ubiquitous and shareable, not kept in silos accessible only from the home screen.

In this talk we’ll take a tour of integration points available to the Android application developer. We’ll touch on opportunities to integrate tightly with the platform itself and with the built-in applications; on consuming data and services from other apps; on exposing your own app’s data and services for consumption; and on providing convenient entry points into your app itself.

Before the web, software developers implemented what we now refer to as desktop applications, using powerful graphics APIs that gave them the ability to program pretty much anything they could imagine. Then along came browsers with virtually no standard graphics support at all. Enter boring web applications, and dull work for developers.

But now, with HTML5 Canvas, developers have a powerful graphics API that lets them develop mind-blowing applications. Now you can implement desktop-like applications that run in a browser. In this session, you’ll see how.

This talk is a demo-fueled, fast-paced introduction to HTML5 Canvas. You’ll get an overview of the Canvas API, and see how you can use it to draw, manipulate images, and implement sprite-based animation. You will get a feel for what you can do with this powerful API, and you’ll get a basic understanding of how to harness that power.

We at Greplin have had an exciting time learning how to scale our service. A year ago, we were storing a few million documents on just two servers – while we’re now storing billions of documents on hundreds of servers (and adding up to 5000 documents a second).

When we started designing our architecture, we gave a lot of thought to distributed data stores (Riak and HBase) and message buses (RabbitMQ and Redis). But we drastically underestimated the importance of the tools and support systems that actually make managing a large and growing cluster manageable, such as:

• Monitoring
• Analytics
• Scripts (deployment/debugging/etc)
• Logging
• Security

Some of these topics aren’t as sexy as the CAP theorem – but they are just as important to running distributed systems in the real world. I’d like to talk about some of the best practices and tools we’ve discovered or created (and open-sourced!) at Greplin to make this possible. I’ll also be sharing some examples of problems that our tools have allowed us to discover and fix quickly.

If you are a JVM language lover, this presentation is for you because you know you can mix multiple JVM languages in a single code. If you have JRuby in your toolbox, Ruby and RubyGems are friends of your favorite JVM languages. Even famous RubyGems, Rails, is, for example. Isn’t it nice? You can get a lot of help from RubyGems without writing Ruby code. Magic is RedBridge. RedBridge is Java API to hook Ruby code up, easily.

But, wait. Why didn’t JRuby simply implement JSR223? Off course, JRuby has a JSR223 engine; however, it is, unfortunately, short for JRuby. Important methods and ideas are missing. That’s why JRuby had RedBridge, which is really JRuby friendly. For example, below is a list of the ideas/methods added to RedBridge:

• A local context scope
• A variable type
• A receiver object
• Loading from classpaths
• Configuration methods
• Termination method

This talk will cover the open source Brisk project: a tight integration of the Hadoop stack with Cassandra.

We will look at the operational and performance benefits of running Hadoop in a peer-to-peer masterless architecture. We will cover design and tradeoffs of the system and look at use cases people are solving with Brisk. Finally we will run some live demos!

Best practices come and go. Ideas that were considered indisputable, dogmas, sometimes fall out of favor, even becoming heresies. Let’s look at four ideas from the history of software development, ideas that have gone in and out of favor (at least in some circles), from dogma to heresy. Has our understanding what is “good” changed? Has the nature of today’s work influenced our thinking? What general lessons can we learn from these examples?

The four examples are:
1. Design Then Code.
2. Design Patterns.
3. Corba vs. REST.
4. Object Middleware and ORMs.

At MailRank, we’ve built our server technology stack using the Haskell programming language. Haskell gives us a tremendously different environment from Python, PHP, and so on, so why have we made such an esoteric choice?

In this talk, we’ll talk about the reasons for our choice, and some of the advantages and disadvantages we’ve observed along the way. In particular, we’ll survey the Haskell-based technologies that make it a great fit for companies working in tight constraints, who must produce excellent products quickly.

We’re on the cusp of the Personal Data era, where people take back their online information, sharing it with whom they choose, in ways they control. Tomorrow’s giants won’t be companies that exploit personal information—they’ll be those that help people to benefit from and enrich their lives. This sea-change is already underfoot through open source projects like TeleHash and the Locker Project.

We’ll do a deep dive on how TeleHash uses UDP, JSON, and a Kademlia based DHT to let anyone build apps that can work across any network and establish direct connections, and how to build a simple app that works fully distributed. Equally important is the ability to have a copy of your own personal data and the ability to then share it directly, so we’ll cover the basics of Lockers and how it can facilitate the flow of data with the owner at the center and always in control.

Erlang and Scala have a very complementary set of strengths and weaknesses for building large scale distributed systems. Cliff will show how to integrate Erlang and Scala using scalang, a library that allows scala actors to transparently participate in Erlang/OTP based distributed systems.

TorqueBox is a Ruby application server built on top of JBoss AS7 that extends the footprint of Ruby applications to include built-in support for services such as messaging, scheduling, and daemons. Infinispan is an extremely scalable, highly available data grid platform, designed to make the most of modern multi-processor/multi-core architectures while at the same time providing distributed cache capabilities. DataMapper is an Object Relational Mapper for Ruby. TorqueBox brings the two together to provide a fast, scalable, distributed NoSQL data store for your Ruby applications. In this presentation, I will take a brief look at each of these technologies and combine them with Sinatra to create a super awesome beer catalogue.

The R programming language has become a standard environment for statistical computing, but out of the box R is restricted to analysis on data sets that fit in memory. Hadoop has become a popular platform for storing and analyzing data sets that are too large to fit on a single machine. Not surprisingly, there’s significant interest in bringing these two platforms together to perform sophisticated analysis on data that’s too large to fit in memory on a single machine. Although there are several systems being developed by the R community to support this such as Ricardo and RHIPE, as well as newer interfaces such as Segue and Hadoop InteractiVE, there’s still considerable confusion as to how to effectively use these two systems together. This talk will provide a survey of available R/Hadoop interfaces and use an example use case to provide a comparison between systems. We’ll also discuss problems that are a good fit for distributed analysis with R, and those that aren’t.

Clojure has powerful concurrency primitives, but they don’t always play nicely with side-effects. Services that take a single input and produce a single output can be easily modeled as functions, but more complicated relationships between input and output lack a first-class representation in the language.

This talk will explore a potential solution: Lamina, which provides abstractions for event-driven workflows, and Aleph, which uses these abstractions to model network communication over a variety of protocols.

Topics will include:

• A survey of event-driven programming, discussing the benefits and shortcomings of various approaches
• An abstraction that models events as streams of messages, allowing familiar operations such as map, filter, and reduce
• Building upon these streams to create complex asynchronous workflows
• Using these abstractions to create sophisticated, performant network services with minimal boilerplate and ceremony

Android is a challenging platform. The market is full of ugly applications that crash the instant you hold your phone sideways. We can do better! Through working code examples, this talk shows how to make amazing Android applications that defy expectations.

• Scale to any screen size using custom layouts
• Create custom views from scratch
• Translate fixed-size design assets into scalable drawables
• Beat ListView into submission

We won’t waste any time on Hello, World in this session. Beginners may be exposed to uncomfortably realistic code, lifted directly from a world class Android application.

Like the tales of King Arthur, the history, mythology, and lore of script loaders is teeming with both fact and fiction. If we’re going to achieve the destiny of true web performance optimization in our page loads, we’re going to have to separate the myths from the truths.

We’ll first survey the history of script loading techniques, looking at what survived and what didn’t, and why.

Then we’re going to jump into a broad review of current script loading techniques, including both general and task-specific loaders. Our goal will be to identify the characteristics of each loader and loading technique, to find solid information for choosing the right script loader for your sites.

We’ll also discuss the current state of browser technology and the HTML specification standards for these loading techniques, and talk briefly about where those things are headed in the future. Most importantly, the community will be challenged to get involved in defining the next generation of loading technology.

The rich history, diverse current state, and bright future for script loaders is both technically challenging and highly rewarding in performance gains, if you accept the quest.

Server side JavaScript is exploding, and web applications written with NodeJS now have two JavaScript runtimes: Browser and Web Server.

I’d like to introduce Mojito, Yahoo!’s nascent web presentation framework that takes advantage of these two runtimes in a unique way. The core of the web framework deploys itself from the server runtime into the browser runtime, allowing Mojito programmers to write web modules that can be executed agnostically within either runtime. This opens up interesting client-server integration possibilities, and ways to decide at runtime in which context user code will be executed.

In this talk, I’ll introduce the concepts behind this framework and talk about the architecture and design behind it. I’ll also discuss the possibilities it introduces for bringing client and server closer together.

Stage magicians have been astonishing and delighting their audiences for years. But there is a surprising amount of repeatable principles behind the art of illusion. The bulk of the actual work in a practiced stage act is more about directing the audience’s attention and expectations. Your application can also benefit from the principled application of practices such as direction/misdirection and not letting your users see your secret preparations and many others. By consistent application of these rules you can help fulfill Arthur C. Clarke’s vision that “Any sufficiently advanced technology is indistinguishable from magic.”

Ever been envious of how easily Python, Ruby and even JavaScript can “meta-program”? Meta-programming provides new ways of writing your code that goes beyond traditional object-oriented composition or inheritance. It’s like magic: seemingly simple or innocuous code takes over big responsibilities; new methods appear out of thin air. Your code, your primary code, stays simple and easy to follow.

Now, we know you can do that for scripting languages, but what do we do about Java? With the proper context, it is possible to emulate many of those same capabilities, by applying a simple set of code transformations at runtime. In this session you’ll learn about meta-programming and how it can apply to traditional Java. You’ll learn about the techniques needed to transform classes at runtime, adding new behaviors and addressing cross-cutting concerns. The presentation will discuss a new framework for this specific purpose, but also draw examples from the Apache Tapestry web framework, which itself is rich in meta-programming constructs.

The Heroku application platform makes deploying, running and scaling applications incredibly easy.

Traditionally these apps have been Ruby web applications. But as both the platform and its users mature, we are seeing the complexity of hosted apps increase, with more complex infrastructure systems running on Heroku.

Today, nobody is more interested in running infrastructure on Heroku than Heroku itself, as self-hosting offers massive benefits and is a fascinating engineering puzzle to boot.

We will first discuss the concept of self-hosting and why it such an interesting computer science problem, and a vital property of many systems. Compilers, revision control systems and application platforms all exhibit similar properties of bootstrapping, cross-compiling, and avoiding circular dependencies.

Then we will take a look at the more interesting self-hosted components of Heroku such as the distributed process management application that is responsible for keeping track of of everything running in the cloud including itself, and the distributed application compiler that used to be a server farm but now is little more than a Heroku app that can even compile itself for releasing new versions.

All of this will show how working towards a self-hosted platform results in comprehensive consistency assurance and gains in efficiency, noble goals for such a complex software system.

The last decade the speed of CPU’s has been stagnating because of the inability to dissipate the heat and run them cost efficiently. The number of cores has been increasing steadily to compensate. 10 Years ago having access to a 48-core machine, most developer would consider unimaginable, but for $6000 you can order one on the Dell site today. So multi-core machines are here to stay.

Since more threads are needed to use all these cores, which is a problem in its own, the need to deal with concurrency control, is increasing as well. Traditionally this was the area of locks, semaphores and compare-and-swap instructions. And although they are extremely useful and probably will be for a long time to come, creating larger systems based on these lower concurrency primitives is a very daunting and error-prone task. I guess some of us have had the pleasure of running into race-problems and deadlocks and know how difficult it is to reproduce them.

Software Transactional Memory is a concurrency control mechanism that relies on a higher abstraction and tries to solves a lot of the traditional problems by treating the memory as a database where composition, isolation, consistency and atomicity are provided out of the box. During this presentation the general concepts behind STM are explained as well as some of the fundamental implementation difficulties. And an attempt is made the answer the question of STM is the silver bullet or just a tool in the toolbox.

Programming is a life skill. Kids needs to learn how to code for the same reasons that they need to learn physics, chemistry, and foreign language. They need to understand how their world works. We need to stretch their brains when they are young. But kids don’t care about all that, they want immediate gratification, but they are also motivated to take the tools they see on the web and put them to use for their own amusement and self-expression.

How do we craft a language to meet this goals? or should we? Sarah Allen will share how she made a little language called “Pie” for web and mobile game development. She’ll share positive and negative reactions from her test audiences. You’ll learn a bit about how to create a domain-specific language (DSL) in Ruby, along with more general ideas of what works (and doesn’t) in the creation of a new language.

Data gets lonely. Much of our data is trapped in proprietary formats, restricted cloud silos, or remote locations that require an “always on” Internet connection. What happens if the power goes out? or Twitter is down? or, worse, your bank? We’ll take a look at how CouchDB solves these problems with it’s schema-less data store, “kill -9” compatible, append-only database format, REST API, and HTTP-based replication.

CouchDB doesn’t stop there. We’ll also survey the surrounding ecosystem including plugins like the R-tree, spatial/geographical index, GeoCouch, check out some options for “scaling out” CouchDB, and look at “scaling down” with Mobile Couchbase for Android and iOS.

Dean Wampler will moderate this panel of pre-eminent language designers with questions from the audience.

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 using the Actors together with Software Transactional Memory (STM) to create 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.

The plan for cashing in on a “million dollar idea” tends to start with step 1, an idea, and end with step 3, profit. The mysterious step 2 turns out to be the hard part, both because it is mysterious, and because it is much, much more complicated than one bullet point will allow.

After having a doctor with a flashlight explain where ideas come from, we’ll explore step 2. We’ll start with costumed avenger Mike Lee’s €1000 an hour idea refinement service. Then we’ll lay out the steps necessary to turn a refined idea into a product.

We’ll look at planning, implementing, and testing features. We’ll explore team building, funding, and marketing. We’ll take a close look at your customers, your platform, and your market. And we’ll ask the all important questions of when and what we’ll finally ship.

Without virtual product hitting store shelves, we’ll look at the real meaning of step 3. We’ll talk about customer service, virality, and planned updates. Finally, we’ll learn about the fear and consequences of success, and how to deal with them.

Whether you have shipped an app, or are sitting on the next big thing, you won’t want to miss this hilarious and irreverent nontechnical look at the hows and whys of making a living in technology.

Programming today exhibits a voracious appetite for information, and one of the most important trends in languages today is to make access to data and services fluent and seamless. To help tame the data deluge, the F# team is working on a novel language and compiler extensibility mechanism, Type Providers.

Type Providers are a unique mechanism for applying the benefits of strong static typing to external, dynamic data sources. For example, Type Providers enable IDE support for “Intellisense”-style completion on dynamic data sources while exploring their APIs. When the code is compiled, programmers can then enjoy static typing against these data sources with a variety of options for code generation.

This talk will describe the foundations of Type Providers, their supporting F# language features and their benefits towards tooling. Relevant usage scenarios for Type Providers (such as data-oriented programming, application scripting and protection against spurious code generation) will also be discussed.

Almost all problems of Computer Science can be summarized as being some form of mapping dilemma, whether that means taking the results of proof theory and constructing an expressive type system or taking a graphical user experience and constructing a scalable model-view-controller architecture. Finding solutions to these challenges can be incredibly rewarding, yet as implementations solidify it often turns out we didn’t solve the mapping dilemma at all! The beautiful generality of the abstract idea becomes lost in the brittle specificity of concrete implementations.

In this talk we’ll discuss a library that attempts to solve the mapping dilemma – an optimizing pattern match compiler in the spirit of OCaml and Haskell targeting the Clojure programming language. The library attempts to provide the exact same general abstraction whether the user wishes to pattern match persistent data structures or the individual bits in a byte.

This controversial talk critiques our fundamental choice of tools, programming languages, and software methodologies from the perspective of how well they help us solve mapping dilemmas.

It’s increasing obvious that we are in the midst of a transformation of computing that will be as significant and disruptive as the emergence of personal computing was thirty years ago. There are technical advancements that enable this change, just like there were for personal computing. But this time it seems less clear where the changes are taking us. The PC era wasn’t just the result of random-walk application of emerging technologies. It was a revolution that was shaped by a shared vision. Where’s our vision? Is there a goal that is shaping the current revolution? Is it really just about mobility, clouds, HTML, content, and “not PCs”? Change is roaring at us and that makes this a great time for innovative technologists. But let’s find our shared vision and see if we can be intentional about using our innovations to shape the next era of computing.

Simple has a core meaning, an understanding of which is critical to developing robust and flexible software. We should be simplifying the problem domain, and creating solutions by composing simple parts. Instead, we endure complexity, and pride ourselves in our ability to manage it. We can do better. This talk will discuss simplicity, why it is important, how to achieve it in your designs and how to recognize its absence in the tools, language constructs and libraries we use.