Sessions at Open Source Bridge 2010 with notes on Thursday 3rd June

This talk will cover a lot of ground, and will be of most value to software developers that are new to testing or trying to improve their mastery of it.

Discussion to help you answer:
- How to prove the value of testing to bosses and clients?
- How to decide how much to test and how?
- How to rescue a troubled project?
- How to cope with deadlines?

Making good use of practices like:
- Test Driven Development (TDD)
- Behavior Driven Development (BDD)
- Code coverage
- Continuous integration
- Assertions and exception notification

Kinds of tests, along with their benefits, open source tools and sample code:
- Unit
- Functional
- Integration
- System
- Load

Testing application state and sample code for using:
- Instantiations
- Stubs
- Mocks
- Fixtures
- Factories

...and more! Audience questions will be welcomed.

This talk will examine some of the features that make JavaScript stand out, including its functional roots, its ultra-simple object-oriented implementation, and the details of event-based concurrency. All of these can seem quite alien when coming from a background in a different language. I will talk about how to get the best use out of these features - and I hope to show that the things that make JavaScript different are also its greatest strengths.

I will also go over common pitfalls in JavaScript development. These are non-obvious traps that unfortunately can put people off of JavaScript when they cause programs to behave in unexpected ways. As Douglas Crockford puts it, these are the "bad parts" that anyone who is working with JavaScript should be aware of.

Finally I will introduce some techniques for writing well-structured code for the client portion of a web application. Specifically I will talk about my own experiences using a model-view-controller pattern, making the best of JavaScript's object-oriented features, and using events to implement re-usable components.

There is a lot of ground to cover when it comes to the best practices of an entire language. So I will introduce topics and point you to resources for learning more. I also expect lots of questions. I am most interested in getting people the information that they want; so your questions will help to guide this session so that it is as useful as possible for everybody.

Puppet is a popular open-source configuration management solution. It’s written in Ruby and in use by organizations around the world to manage their assets more cheaply, more effectively, and with a view to delivering a higher quality of service.

Puppet is one of the easiest infrastructure tools you’ll ever use but it’s still helpful to have a hands-on introduction to how to get started. This tutorial doesn’t cover the deep technical details but allows you to focus on doing useful work as soon as possible.

In the course of the tutorial you’ll be exposed to most of the tools and configuration you will use in a functioning Puppet installation. By the end of the tutorial we’ll produce a simple Puppet architecture that can manage a few key services and applications. We’ll also demonstrate some of the more interesting problems Puppet simplifies solving and give you pointers towards developing more advanced Puppet patterns.

There has been a lot of interest in PHP performance lately, spurred by
Facebook's HipHop PHP announcement in February. Most people don't know
how fast their site is and will make uninformed architecture decisions or
spend time optimizing the wrong things based mostly on myths and innuendo.
This talk will try to get you started down the path of a systematic
approach to benchmarking, profiling and optimizing your entire web site.

For those of you who were at my performance talk last year, consider this part 2 of that talk with new deep-dives into Wordpress and HipHop PHP.

I wanted to be able to monitor temperatures in multiple locations in my house so that I could tell if changes made in the HVAC system were working or not. Although a commercial solution would be easiest to implement, I decided to build my own instead. I designed a simple wireless temperature sensor around a Digi XBee wireless module that would send temperature readings at regular intervals. The next step was to build software to interface with the wireless sensors and capture the data that they were sending. The interface software (called XBeeLib) uses Apache Mina as a major component to handle translation of packets to and from the wireless modules. The monitoring software (called pHomeNet) is a Java-based system running on the Apache Felix OSGi container. Observations from the sensors are recorded into a database (Apache Derby by default). Although the system is currently focused on recording temperature sensor data, it could easily be adapted to record data from other sensors or even to control devices based on sensor inputs. This presentation will delve into the hardware and software aspects of the system, although with more emphasis on the software and the role that packages such as Apache Felix and Apache Mina play in the system.

More info on 30 Hour Day can be found here: http://30HourDay.org

Infrastructure as code brings with it a single promise: enable the re-construction of the business from nothing but a source code repository, an application data backup, and bare metal resources.

In this session, I'll walk you through the skills you need to cultivate in order to fulfill this vision - you'll gain an understanding of Service Oriented Architectures, Configuration Management and Systems Integration, along with some insight on how to talk about the business value of operations.

Interested in using PostgreSQL for you next project, or migrating to it? This tutorial will go over the basics of PostgreSQL administration and database application design, including coverage of the features available in version 9.0.

Topics to be covered include:

• Installation & packaging options
• Basic performance configuration
• Basic security configuration
• Creating your first database
• Backups, PITR and Replication
• Common administrative tasks
• Application design patterns
• Managing database changes over time
• Special features you might not know about
• Tools you're likely to need

In order to get the most out of this tutorial, all users should bring a laptop with PostgreSQL Version 8.4 and pgAdmin installed. For users unfamiliar with installing PostgreSQL, the One-Click installer is here: http://www.enterprisedb.com/prod...

This talk will provide a general overview of some of the cool new features of USB 3.0 devices, including link and function power management, and bulk endpoint "streams" that support SCSI command queuing.

Operating system developers will be interested in how to support those new features, USB hardware hackers will be interested in how to communicate with USB 3.0 devices, and everyone else gets a sneak peek into what the next generation of USB 3.0 devices will look like.

XHP is a PHP extension which augments the syntax of the language such that XML document fragments become valid PHP expressions. It fits somewhere between a templating language and a programmatic UI library. XHP allows you to use PHP as a stricter templating engine and offers a very straightforward way of implementing reusable, extensible components. Facebook is increasingly using this technology across our web presence, include our home page, dashboards, and lite.facebook.com.

This session will cover: how XHP works; syntax of building simple, complex, and dynamic structures; and using XHP as building blocks that cater to your web apps. I'll include lessons Facebook has learned about moving quickly from concept to product using XHP.

Cloud computing is all about smart, dynamic allocation of the computing resources you have at hand. It doesn't take the resources of Amazon or Google to build a small private cloud for your own needs. Keith Hudgins will show you how to use off-the-shelf open source components to build and manage a real, working cloud infrastructure complete with networking and storage management, and do it all in plain view!

The cloud stack being demonstrated is based on Open Nebula, a leading open-source virtual infrastructure management tool from Spain. Comparable to Eucalyptus or vSphere, yet easily extensible and hackable via Ruby and C. It's the brains of the beast, handling API calls, telling your VMs where to live, and what they can do with themselves.

Chef is a configuration management tool built on Ruby that makes it easy to wrangle your servers into shape. It rides herd on all of our components to easily control our cloud.

Xen is not only one of the leading hypervisors available today, it also runs on almost any reasonable processor, so you can build your cloud with the spare boxes you have in your closet!

Best of all, the scripts and recipes used to provision and deploy this rag-tag band of freedom fighting software will be open sourced and available to you!

http://www.opscode.com/chef/
http://opennebula.org/start
http://www.xen.org/

The presentation will walk through these tools, the architecture and resources you need to build a cloud of your own. The recipes and resource references presented will be open sourced as part of the presentation.

The main challenge of the project was bridging the gap between PHP and C++. PHP is a scripting language with dynamic, weak typing. C++ is a compiled language with static typing. While PHP allows you to write magical dynamic features, most PHP is relatively straightforward. It's more likely that you see if (...) {...} else {..} than it is to see function foo($x) { include $x; }. This is where we gain in performance. Whenever possible our generated code uses static binding for functions and variables. We also use type inference to pick the most specific type possible for our variables and thus save memory.

The transformation process includes three main steps:

1. Static analysis where we collect information on who declares what and dependencies,
2. Type inference where we choose the most specific type between C++ scalars, String, Array, classes, Object, and Variant, and
3. Code generation, which for the most part is a direct correspondence from PHP statements and expressions to C++ statements and expressions.

We have also developed HPHPi, which is an experimental interpreter designed for development. When using HPHPi you don't need to compile your PHP source code before running it. It's helped us catch bugs in HipHop itself and provides engineers a way to use HipHop without changing how they write PHP.

Overall HipHop allows us to keep the best aspects of PHP while taking advantage of the performance benefits of C++. In total, we have written over 300,000 lines of code and more than 5,000 unit tests. All of this will be released this evening on GitHub under the open source PHP license.

What kind of database do you need?

Thanks to new database projects like CouchDB, TokyoCabinet, Solr and others, there are more non-relational database options available than ever for developers. Yet good information on how to choose what kind of database you need is still scarce. We'll cure that in this talk.

When do you want to use a SQL-relational database? When do you want to use a non-relational database? What are the types of non-relational databases available today? What kinds of things is each well-suited for?

Database geek Josh Berkus will explain how to evaluate the database tasks you need to accomplish, and put you on the road to choosing the database product ... or more likely, products ... which are right for you.

Sphinx makes documenting your project almost too easy.

You can even integrate your documentation with your code in that your documentation can be run as a test, and your class and function docstrings can become your reference documentation.

Markup as well-designed as reStructuredText is not only a lot of fun to use, but it also very cleanly separates content from design. Authors working in plain text tend to produce clean, readable content without the messy markup often associated with visual HTML editors, or, worse yet, the disaster that is Microsoft Word.

Sphinx is written in Python, but you can use it to document anything. It has a built-in search engine, generates table of contents and indexes, and because the files are just text files, you can check them into your favorite version control system and easily collaborate with and merge changes from other documentation contributors.

We will look at several popular open source software projects that are already using Sphinx, and show you how you can get started using Sphinx to document your software project.

You have so much you want to teach, how do you structure it so that your training course is both interesting and challenging? How much theory can you squeeze into an hour before your attendees have forgotten where you started? How do you structure your course to account for classes which move slower or faster than average?

Whether you are designing a class to be presented in person, a tutorial to be worked through on-line, a practical book on how to do something, or even if you’re writing extensive user documentation; correct structure makes a huge difference to how memorable the information is.

Burn-out and full brains are a major problem for anyone attending any intensive learning activity. At university, a student attends many classes all on different topics, but only has to learn one hour of material per class per day. At a conference, an attendee may sit through many hours of interesting talks, but they have the freedom to choose how much they participate in each. In an intensive training course, a student has to learn, understand and fully absorb 6 hours of material on the same topic, every day for several days in a row. Worse, each of these hours builds on the one before; requiring a level of alertness and participation not usually needed at educational institutions, conferences or in the workplace.

Make your training experience truly stand out by structuring it to help alleviate burn-out. These techniques are essential for a multi-day training course, but will provide you with a solid background for single or even half-day sessions as well.

This talk will describe what Perl Training Australia has learned about course structure for technical courses involving lots of hands-on programming exercises. We will cover answers to the questions above, as well discussing other issues such as cognitive load, learning fatigue and ideal classroom set up.

While our family had H1N1, I prototyped a device for adjusting our television's volume during the furnace's on cycle. Microcontrollers are ridiculously cheap, beginning electronics tools are affordable, and open source tools, such as the Arduino IDE and the underlying avr-gcc toolchain, combine to make it remarkably simple to create custom gadgets to improve your life.

In a single session, I'll demonstrate how to plan your gadget, gather everything you need, then build and program a prototype device using open source tools. A complete description of all steps will be provided so that attendees may duplicate the device on their own.

Facebook is now the #2 global website, responsible for billions of photos, conversations, and interactions between people all around the world running on top of tens of thousands of servers spread across multiple geographically-separated datacenters. When problems arise in the infrastructure behind the scenes it directly impacts the ability of people to connect and share with those they care about around the World.

Facebook’s Technical Operations team has to balance this need for constant availability with a fast-moving and experimental engineering culture. We release code every day. Additionally, we are supporting exponential user growth while still managing an exceptionally high radio of users per employee within engineering and operations.

This talk will go into how Facebook is “run” day-to-day with particular focus on actual tools in use (configuration management systems, monitoring, automation, etc), how we detect anomalies and respond to them, and the processes we use internally for rapidly pushing out changes while still keeping a handle on site stability.

This session takes a look at how to scale applications running on multi-core CPUs. It focuses on various application models such as one process per connection, one thread per connection, single threaded with non-blocking I/O, and hybrid approaches. I/O will also be covered, looking at the various blocking and non-blocking models, and polling methods for various open source operating systems. Details on how to handle the c10k problem (and beyond) are presented, along with how to best manage typical work loads that require other resources like disk I/O. Synchronization methods such as mutexes and atomic operations will also be briefly touched on to see what impact they have with resource protection.

Examples will be shown in C++, and the framework introduced can be used to develop your own applications. The concepts are also applicable to any programming language that supports proper threading.

Dropbox is probably the current leader in the storage application and service space for desktop users. Featuring an auto-commit-and-update mechanism to transparently send updates to a file repository, changes are reflected on any other machine in near real-time.

Unfortunately, while Dropbox promises security, you cannot use your own infrastructure for data storage. Most data security policies would make this a show stopper for many organizations that wish to deploy such a facility.

By gluing a few existing open source tools together, you can replicate the functionality with a version control system, a file system watcher and a scheduled task. Add in a sprinkling of open protocols and communications mechanisms and iizip promises to deliver what Dropbox currently cannot - flexibility, security and openness.

In this talk, Ben Dechrau will discuss the problem, the solution and give a live demonstration of the current system. He will discuss the implementation and design decisions and cover the road map ahead.

Attendees will be rewarded for challenging those decisions, clever heckling and funny jokes with the intention that healthy discussions will help guide iizip on its rightful path to world domination.

From targeted advertising based on your site profile or browsing habits, to checkins on geolocation services like Foursquare or Gowalla, we know we're putting a substantial amount of personal data out there for others to use. And as developers, we may find ourselves stumbling into hot button areas we don't know how to handle.

We'll explore personal data usage and try to sort out what elements create creepy or fun outcomes for the user, then talk about how to hack together experiments that reveal collisions between our underlying assumptions and how data is actually being used.

Attendees will take away a better understanding of why people share personal data, what they expect to get from it, and how not to be so creepy (unless that's what you're after).

Open Source distributed hacking is awesome, but you knew that already. Pair programming is awesome too, and you might not have known that yet. But Open Source hackers don’t tend to do much pair programming, except perhaps at the occasional conference hack session. We want to show you some tools and techniques for pair programming in a distributed manner, and some case studies where we solved hard problems this way. And we want to hear about your favorite tips and tricks for collaboration.

We all struggle to maintain the scope of projects, but it's sometimes difficult to tell a client "no". After all, they're the ones paying you, and they want you to deliver exactly what is in their head. It's not simple to manage their expectations, but not doing it can sink a project.

This session is going to go into the motivations behind clients pushing on companies to deliver more. It's also going to talk about why and how you should push back in order to ultimately create a better experience for everyone on the project. So you can get back to coding and not have the sinking feeling of dread when you open your email.

We're focusing on CMS projects as examples, but the lessons are applicable across software development projects.

Whether you need a small yet scalable development virtual machine (VM) environment or need to deploy a large cloud production environment, you need a tool that is easy to use, deploy, and maintain. "Ganeti":http://code.google.com/p/ganeti/ is a clustered virtual server management software tool built on top of existing virtualization technologies such as "Xen":http://xen.org/ or "KVM":http://www.linux-kvm.org/page/Main_Page. It is similar to "libvirt":http://www.drbd.org/ in many aspects, but different in others such as its built-in cluster support using "DRBD":http://www.drbd.org/.

The focus will be on a use case at the "Oregon State University Open Source Lab":http://osuosl.org/ (OSUOSL) where we were faced with scaling, performance, and reliability issues with our existing VM infrastructure. We’ll cover the overall design and features of Ganeti along with the basics of installing it. Additionally we’ll walk through some of the basic operations you may encounter (deployment, failover, expansion, hardware failures, etc).

Want to find out what your friends were doing on the weekend? Curious which parties you aren't getting invited to? Wish you could contact that interesting person you met at a 3,000 person event, but you only got their first name? Want to know what your potential new employee really does in their spare time? Or do you just like data, and lots of it?

In this talk we'll learn some simple tricks with open source tools that can help you access a wealth of information from the largest collection of social data ever created. We will also examine techniques and practices to help control what data you expose to the techniques presented.

The talk will describe in detail the new features in MariaDB 5.1 (stable), the new features in MariaDB 5.2 (beta / RC) and what's in the upcoming MariaDB 5.3 (alpha).

The talk will also explains the challenges we have had to do this fork, and the various systems (like buildbot) that we used to build the binaries and how we are working with the MariaDB/MySQL community.

This talk also includes information how we plan to continue developing MariaDB so that it still a drop in replacement of MySQL as times goes by.

"Spaz":http://getspaz.com is a mature, open source, free desktop and mobile client for Windows, Mac, Linux, and Palm webOS. Started in Spring of 2007, Spaz is one of the oldest Twitter clients available still under active development. Other systems have gone on to great commercial and popular success, but Spaz still continues to plug along, driven by a commitment to open standards, transparency, and community.

This talk will cover the history of Spaz's development, from early successes and awards, to competition from well-funded closed source projects, to the transition onto mobile, and finding a sustainable niche where it continues to grow.

Specific topics we'll cover include:

• Changing how you measure success
• Ignoring what everyone tells you about being successful
• Doing it for love, not money
• How one user can be more important than 100,000 downloads
• What to expect when you open your code
• Getting others involved in your project
• Creating a codebase for multiple platforms and systems
• Being open on a closed platform

The United States has a treasure trove of nautical charts in digital form, including plots of shipwrecks, navigation buoys, coastal and river depths, and other fine booty. OpenStreetMap is an open source, open format collaborative project for building a free map of the world. Join this session to find out more of the marine secrets of the National Oceanographic and Atmospheric Administration (NOAA), OpenSeaMap's plans to extend OSM to the high seas, and splicing the two (and your mainbrace) together. We'll use the Geospatial Data Abstraction Library (GDAL), OGR, Python, and the OSM API.

Using FTP, telnet (some of you must still be using telnet), sending mail, surfing gopher, and visiting web sites can all give away personal information and passwords.

We'll show how easy it is for your traffic to be intercepted (using open source tools) and what you can do to protect yourself (also using open source tools).

Including such excitement as:
* Packet sniffers and you
* The dark and ancient magic of SSL certificates
* Man/woman in the middle attacks
* Working around and tunneling through insecure networks
* Quitting passwords cold turkey with public keys and other tools
* Charts! Graphs!
* Public shaming!
* (and possibly more)