A whirlwind tour of the Erlang language. This session will be based loosely on Chapter 2 from Erlang and OTP in Action. This tour will serve to teach Erlang to any very astute developers that don’t know it yet and be a nice refresher for those that already know it to some degree. Even advanced users should be able to take some new information on the Erlang language itself out of this session.
Here is where you jump into the meat of things. In this section you use behaviours, supervision, and the application structure. These are the fundamental building blocks for the OTP framework which is at the heart of how Erlang delivers on its promises of high concurrency, scalability and high fault tollerance.
Unit testing is an important part of software development, and many frameworks exist to support it on iOS.
In this talk, I’ll give an overview of three unit testing frameworks (SenTestingKit, Google Toolbox for Mac, and GHUnit), two UI interaction frameworks (UISpec, UIAutomation), and a mocking framework (OCMock).
I’ll write tests for a simple application using all frameworks and evaluate them based on:
With the advent of the invokedynamic in Java 7, implementations of language runtimes on JVM will become much more performant and powerful. Invokedynamic in itself is however only the first stepping stone, the least amount of functionality exposed by the JVM sufficient to enable the new features. Language implementers still need a lot of plumbing for correct interoperability with Java objects: overloaded method resolution, property access, collections access, and so on. The JVM Dynamic Linker Framework provides these functions, a convention for specifying them as invokedynamic calls, and means to link the invocations. More importantly, it provides means for registration and discovery of the same functions for other languages, acting as a nexus that can transparently link call sites generated by one language implementation to code in another implementation. Thus, it allows a dynamic language runtime to handle not only POJOs, but also objects from any other dynamic language runtime that itself uses the framework.
Generic programming holds great promise – ultimate reuse, unprecedented flexibility, and never a need to reimplement an algorithm from scratch due to abstraction penalties.
Unfortunately, the shiny city on the hill is difficult to reach. C++’s generic power has effectively reached a plateau – anything but the simplest generic constructs quickly turn an exponential complexity/benefit elbow. C++11 fails to be a strong sequel in the generic programming arena, and many other languages don’t seem to “get” genericity properly at all. The D programming language is a definite exception from this trend.
D makes short work of the most formidable generic programming tasks achievable with C++, and makes virtually impossible tasks readily doable. It also reduces the relevance of “Modern C++ Design” to that of an introductory brochure (much to the dismay of that book’s author).
This talk has a simple structure. It will pose a few generic programming tasks that seem difficult or impossible with current language technology, and then will show solutions in D that solve said problems.
by Bill Odom
Vim deserves its reputation as one of the most powerful tools in a developer’s toolbox — but it’s not exactly friendly and approachable. Even long-time users rarely employ more than a fraction of its capabilities, and new users are often left wondering why so many apparently-sane people won’t shut up about how awesome it is. The stark UI, the steep learning curve, the host of idiosyncrasies… mastering Vim is a challenge, and that’s putting it politely.
In this hands-on session, you’ll learn why it’s worth the effort.
We’ll quickly review the essentials of Vim, like modes, motions, operators, and commands, with an emphasis on why Vim works the way it instead of just how. With the fundamentals firmly established, we’ll work our way through real-world examples of using Vim to perform astounding feats that poor souls using lesser editors can only imagine. We’ll cover ways to integrate Vim with your environment, tailor it to your work, and generally bend it to your every whim. We’ll discuss important settings, advanced techniques, useful customizations, handy scripts, must-have plugins, crafty tips, and sneaky tricks.
In short, we’ll explore how to use Vim most effectively, so it lives up to the awesome reputation that you’ll soon be telling all your disbelieving friends about.
The Actor model of concurrent computation is gaining in popularity. Designing actor-based systems requires thinking differently about how we decompose problems and construct solutions. We will explore the implementation of several patterns of actor interaction. These patterns can be applied in network-scale collaborative programs written in any language. They apply especially well to massively concurrent multi-core systems programmed in actor-friendly languages such as Erlang and Scala.
by David Geary
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.
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.
by Danno Ferrin
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.”
18th–20th September 2011