Sessions at Open Source Bridge 2011 about Java

Your current filters are…

Tuesday 21st June 2011

  • Hardware/Software Integration with Txtzyme

    by Ward Cunningham

    Inexpensive 8-bit microcontrollers include many dozens of i/o pins backed up by interesting hardware including USB interfaces.

    We show how a simple interpreter, called Txtzyme, running on an 8-bit micro-controller, can support generalized hardware interaction and expose that to a regular computer over the flow-controlled USB bus. The result is to make your hardware feel "command line friendly" while concentrating your system development efforts into a more powerful and interactive development environment: the shell.

    Sources for Txtzyme and all the "demo projects":https://github.com/WardCunningham/Txtzyme are on GitHub and have been blogged at DorkbotPDX. See our "original announcement":http://dorkbotpdx.org/blog/wardcunningham/shell_programming_with_txtzyme there and a "more recent post":http://dorkbotpdx.org/blog/wardcunningham/txtzyme_accepted_for_open_source_bridge describing additional preparations for this talk.

    At 3:45pm to 4:30pm, Tuesday 21st June

    Coverage note

Wednesday 22nd June 2011

  • Preventing Runtime Errors at Compile Time

    by Michael Ernst, David Lazar and Werner M. Dietl

    Are you tired of null pointer exceptions, unintended side effects, SQL injections, concurrency errors, mistaken equality tests, and other run-time errors that appear during testing or in the field? A pluggable type system can guarantee the absence of these errors, and many more real, important bugs.

    Are you a software architect who wants to be able to quickly and easily implement custom checks that prevent more errors at compile time? You need a framework that supports you in creating a formally correct code checker.

    This presentation is aimed at both audiences. A pluggable type system can give a compile-time guarantee of important properties. We will explain what it is, how to use it, and even how to create your own. You can create a simple pluggable type-checker in 2 minutes, and you can enhance it thereafter.

    The demo uses the Checker Framework, which enables you to create pluggable type systems for Java. It takes advantage of features planned by Oracle for Java 8, but your code remains backward-compatible. The pluggable type-checker can be run as part of javac or via an Eclipse plug-in, and integration with build tools such as Ant and Maven is provided. The tools are "freely available":http://types.cs.washington.edu/checker-framework/.

    The Checker Framework provides 12 pluggable type systems that are ready to use, including nullness, immutability, and locking checkers. The presentation will first develop a simple declarative type checker that checks the consistency of method signature strings. The presentation will then discuss the design and usage of more advanced checkers.

    The Checker Framework has found hundreds of bugs in over 3 million lines of open source code, including from Oracle, Google, Apache, etc. Overall, we found that the type checkers were easy to write, easy for novices to productively use, and effective in finding real bugs and verifying program properties, even for widely tested and used open source projects. It is easy to improve the quality of your Java code, and you can start using the Checker Framework today!

    At 10:00am to 11:45am, Wednesday 22nd June

    Coverage note

Thursday 23rd June 2011

  • The History of Concurrency

    by Michael Schurter

    Whether it's node.js, goroutines in Go, gevent/eventlet in Python, Rubinius's hydra branch for Ruby, Akka for the JVM, or async primitives for C# 5.0, concurrency is a hot topic.

    It's too easy to forget that coroutines were first defined in a 1963 paper and that preemptive multitasking, like traditional Thread interfaces offer, were a part of Unix's first release in 1969.

    This talk aims to present a historical context for all of the "new" concurrency models and attempt to peer into the future to see how existing concurrency paradigms will serve hackers in a massively multicore future.

    At 11:00am to 11:45am, Thursday 23rd June

    Coverage note

  • Have Your Cake and Eat It Too: Meta-Programming Techniques for Java

    by Howard M. Lewis Ship

    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.

    At 3:45pm to 4:30pm, Thursday 23rd June

    Coverage note