Google Data » Ellen Ko

Contracts for Java

Ellen Ko — Fri, 04 Feb 2011 21:46:00 +0000

If you’ve ever spent hours debugging your Java code, today’s blog post is for you.

Often bugs that are frustratingly elusive and hard to track down appear simple or even trivial once you have found their cause (the fault). Why are those bugs hard to track down? One possibility is that the fault is in a completely different part of the program than its symptom (the failure).

Contracted code reveals failures much closer to their fault, leaving you with a far simpler problem to solve:

Traditionally, Java programmers enforced preconditions using explicit parameter validation code in public methods, and assertions in non-public methods. Likewise, they enforced invariants and postconditions using assertions. This approach is described in detail here. Since then, new features in Java 5 have enabled a more convenient and expressive implementation of contracts.

Contracts for Java is our new open source tool. Preconditions, postconditions, and invariants are added as Java boolean expressions inside annotations. By default these do nothing, but enabled via a JVM argument, they’re checked at runtime.

• @Requires, @Ensures, @ThrowEnsures and @Invariant specify contracts as Java boolean expressions
• Contracts are inherited from both interfaces and classes and can be selectively enabled at runtime

Contracts help you turn interface documentation into code. For example:


/**
* @param left a sorted list of elements
* @param right a sorted list of elements
* @return the contents of the two lists, merged, sorted
*/
List merge(List left, List right);

Could be expressed as:


@Requires({
"Collections.isSorted(left)",
"Collections.isSorted(right)"
})
@Ensures({
"Collections.containsSame(result, Lists.concatenate(left, right))",
"Collections.isSorted(result)"
})
List merge(List left, List right);

The interface is now precise and every class that implements it can be checked at runtime.

Contracts are a powerful language feature and can provide great benefit if used correctly. We recommend that newcomers find an expert to learn from or spend some time reading around the subject to pick up good habits and avoid bad ones.

One point that often surprises people is that contracts must not be used to validate data. Contracts exist to check for programmer error, not for user error or environment failures. Any difference between execution with and without runtime contract checking (apart from performance) is by definition a bug. Contracts must never have side effects.

Another important point is that by convention module interfaces in Java are total, that is, they are defined for all input. In the case of incorrect input, they promise that a particular exception will be thrown. This behavior remains part of each method’s implementation and cannot be moved to the contract.

Contracts for Java is based on Modern Jass by Johannes Rieken. Rather than being a full time project it was conceived and developed in the 20% time of two software engineers and then developed further through an internship. The internship report (PDF) goes into detail about the work done and the methodologies used.

Contracts for Java was inspired by Eiffel, a language invented by Bertrand Meyer, which has built in support for contracts.

By David Morgan, Andreas Leitner and Nhat Minh Le, Contracts for Java 20% Team

Flip Bits not Burgers, the Student Guide

Ellen Ko — Tue, 01 Feb 2011 16:42:00 +0000

The Google Summer of Code Mentor Manual, published before the 2009 Mentor Summit, was an effort to help mentors choose the best students and get them involved in the open source community. The Mentor Manual had some extremely useful tips on how organizations can make the best use of the program, so in 2010 the authors printed a new edition that has tips for organization administrators as well!

When you have a manual for the mentors and org admins, it’s only fair and logical to have one for the students as well. After all, they’re the ones who need the most help preparing for and working on Google Summer of Code! So the authors of the Mentor Manual decided to write a Student Manual in the days before the 2010 Mentor Summit, and they realized it would be a good idea to get input from students. This is where I enter the scene–I was a Google Summer of Code student for the Systers organization in 2009, and a mentor for Systers in 2010. Jennifer Redman, my mentor in 2009 and co-author of the original Mentor Manual, suggested that I participate in the book sprint for the Student Manual so I could share my first-hand experience as a student.

We wanted the Student Manual to be the one stop shop for all the questions that students might have about Google Summer of Code. The manual has great insights for students before, during and after the program. These include:

• How to decide whether or not to apply for Google Summer of Code
• Getting code reviews and handling feedback
• Interacting with mentors
• Staying involved after the program ends

The book also has some very useful advice on making first contact with the mentoring organization, appreciating the open source culture, and most importantly, writing good project proposals.

Who can give better advice on writing good proposals for Google Summer of Code than the people who would actually evaluate them? I think the suggestions on how to write a good proposal, straight from the mentors, is something that makes the book extremely useful for the students. The book also has suggestions on selecting the projects that you should consider applying for, how to manage your time better, and how to get the most from your mentor and Google Summer of Code–there’s even a section on what to do if you’re not selected. This goes extremely well with the spirit of Google Summer of Code where one of the goals is to get students involved in open source projects irrespective of them being Google Summer of Code students or not. I guess I can go on and on about the book and the chapters, so a better option might be to check out the book and see for yourself: http://www.booki.cc/gsocstudentguide/

Google Summer of Code Student Manual Authors, photo by Selena Deckelmann

We have made a sincere effort to include as much useful advice and as many helpful suggestions in the book as possible, and in true open source style, there is an editable version available, so if you feel that something is missing in the manual, you can make a contribution to it!

By Malveeka Tewari, Google Summer of Code 2009 Student and 2010 Mentor for Systers

Googlers Down Under

Ellen Ko — Thu, 20 Jan 2011 23:59:00 +0000

Despite the recent flooding in Brisbane, Australia, linux.conf.au (lca) will proceed from January 24th to 29th, and Googlers from across the company will be there. LCA is a community-run technical conference for free and open source software enthusiasts, featuring but not limited to Linux. In addition to the many Googlers who will be attending, several Googlers will also be presenting at the conference.

The conference starts on Monday the 24th with a day of miniconfs, and Nóirín Shirley from Google’s Zurich office will be presenting “Open Source: Saving the World” as part of the Haecksen track.

Google’s Chief Internet Evangelist Vint Cerf will start the day on Tuesday the 25th with his keynote presentation, and later that morning he will present “In Search of Transmission Capacity - a Multicore Dilemma.” On Tuesday afternoon, Google Summer of Code Administrator Carol Smith will give a "Google Summer of Code Update" at the FOSS in Research and Student Innovation Miniconf.

On Wednesday January 26th, Google staff engineer and Linux kernel committer Ted Ts'o will explain “Making file systems scale: A case study using ext4.”

Andrew Gerrand and Nigel Tao of the Go team will give attendees “A Tour of Go” on Thursday the 27th, and Nóirín will present “Baby Steps into Open Source - Incubation and Mentoring at Apache,” which is based on her experience at the Apache Software Foundation.

On Friday the 28th, Carol will present her talk, “The 7 Habits of Highly Ineffective Project Managers” in the morning. A little later in the day, Daniel Bentley and Daniel Nadasi of the open source and Geo teams respectively will talk about “Opening a Closed World,” followed by Marc MERLIN, who works on infrastructure at Google. Marc will discuss “Saving Money with Misterhouse: Running Your Lights and HVAC System. Scaring your cat off the kitchen counter is just a bonus :)”

LCA always closes with Open Day, a free day-long event where the general public can learn about open source, open data - all things “open.” The Open Day is on Saturday the 29th, and Cat Allman of the Open Source Programs Office will be presenting her talk, “What is Open Source?” there.

Come learn more about the latest happenings in open source, and join us in showing support for Brisbane’s recovery. We hope to see you there!

By Ellen Ko, Open Source Team

OSUOSL’s Code-in results are in!

Ellen Ko — Fri, 14 Jan 2011 17:45:00 +0000

The Oregon State University Open Source Lab (OSL) participated for the first time in the Google Code-in contest, and we're pleased to report that the results of the contest were incredibly valuable for us. We had eight students actively working with us during the contest, from as far afield as Australia and Poland. Of these eight students, two have let us know they plan to keep working on projects with the OSL and one even let us know that he's hoping to attend Oregon State University so he can learn even more about open source and help out at the lab.

We had a total of 42 tasks completed, all improvements to Ganeti Web Manager, a homegrown project of the OSL. For those who aren't familiar with the project, it's a Django based web application that helps administrators better manage their Ganeti-based clusters. Our students completed a total of 42 tasks: 23 coding tasks, 18 user interface tasks, and one outreach task (logo design). We were especially excited that our students found several unknown bugs in our code base and proceeded to send us fixes for them. You can take a look at all of the tasks proposed by the Lab and all those completed by our students on the contest website.

As a result of participating in Google Code-in, several major features were implemented in Ganeti Web Manager, including:

•HTML5 VNC Support
•Creating a Status Dashboard for Administrators and Users
•Creating an Object Change Log

Of all these major features, creating the status dashboard was the most difficult of our tasks. We required a very concise layout for the feature and the student working on the task was not a native English speaker, but he did an outstanding job. In fact, if you'd like to get to know the student who worked on the dashboard, we've already published an interview with Piotr for your reading pleasure.

Overall, we were incredibly excited to be a part of Google Code-in and extremely pleased with our results. We certainly hope to continue mentoring for the contest, assuming Google chooses to run it once again. Many thanks to all of our students for their great work and many thanks to Google for doing awesome work to promote student involvement in open source! A full post about the OSL’s experience with Google Code-in is available on the OSL blog.

By Leslie Hawthorn, OSUOSL Open Source Outreach Manager

Chrome enables open innovation

Ellen Ko — Thu, 13 Jan 2011 17:10:00 +0000

Earlier this week, Google announced that Chrome’s HTML5 support will change to match codecs supported by the open source Chromium project. Chrome will support the WebM (VP8) and Theora video codecs, and support for the H.264 codec will be removed so that resources can be directed completely towards open codec technologies. This is in line with Google’s continued support of the open web.

For more information, check out the original post.

By Ellen Ko, Open Source Team

Geek Time with Chris DiBona

Ellen Ko — Wed, 29 Dec 2010 01:41:00 +0000

The end of the year is always a great time to take a moment and look back at the developments of the past twelve months. Two members of the Google Open Source Programs Office, Chris DiBona and Jeremy Allison, sat down together for a review of open source accomplishments in 2010, and the conversation is shared with you here. Chris is the Open Source Programs Manager at Google, which means he directs Google’s open source compliance, releasing, and outreach efforts. He reveals lots of insights into Google’s approach towards open source and the influence of open source on technology and business.

The video of their discussion is separated into five parts, with descriptions below.

Part 1
Chris and Jeremy discuss their favorite open source projects of 2010, including GoogleCL, Android, Chromium, Chrome OS, and WebM. Together they ponder the future of computing, debating whether or not 2011 will be “the year of the Linux desktop.”

Part 2
Chris explains how Google decides what software to open source and under which licenses. He also mentions tools such as Make Open Easy (MOE) that are used to help engineers release and maintain their code. The topic eventually turns to license defragmentation, and Chris describes his efforts to streamline the number of licenses that Google releases under. In the process he shares his theory about what makes open source projects succeed.

Part 3
Chris and Jeremy talk about Google Summer of Code, its history, and the impact it has on the open source community.

Part 4
Chris and Jeremy are old friends who met in the 90’s at a Silicon Valley Linux Users Group meeting. While reminiscing about the early days of Silicon Valley, they discuss the modern role of user groups, both here and abroad. Chris visited Qatar, Egypt, and Jordan earlier this year, and he compares the tech atmosphere in those countries to Silicon Valley in the late 90’s, with both open source and entrepreneurship developing simultaneously.

Part 5
Chris gives an overview of his career and explains how he came to be the Open Source Programs Manager at Google.

Happy New Year, and see you in 2011!

By Ellen Ko, Open Source Team

Notes from the 2010 LLVM Developers’ Meeting

Ellen Ko — Thu, 23 Dec 2010 16:30:00 +0000

My name is Lang Hames, and I am a PhD student at the University of Sydney where I research aggressive register allocation techniques. Last year I completed a six month internship with the LLVM team improving their register allocation infrastructure, and last month Google sponsored my attendance at the 2010 LLVM Developers’ Meeting.

I had a fantastic time at the meeting. Californian hospitality always makes me feel right at home, and it was great to see all my friends from previous Dev Meetings and my internship with the LLVM team.

The meeting was huge this year, with over 190 attendees and such a abundance of talks it was impossible to make it around to everything on the day. It's a good thing the entire proceedings are up on the web. The talks this year were impressive and diverse, including introductions to major new LLVM-family projects, new applications leveraging LLVM technology, and targets ranging from GPUs to FPGAs.

A few of my favourite talks:

Doug Gregor, a member of the Clang team at Apple and code owner of the Clang libraries, gave a great talk on "libclang: Thinking Beyond the Compiler.” (PDF) libclang is the Clang compiler's functionality packaged as a library. It lets you parse source, access diagnostics, examine ASTs and even find code completion targets. This raises the really exciting prospect of building new development tools on top of a feature complete front-end. Imagine having syntax highlighting, code-completion and cross-reference all handled by the same parser that's in the compiler. It's difficult to over-state how cool this is, and I say that as an optimization guy (I thought the front end was just there to feed me CFGs). I'd highly recommend checking out a copy of Clang and playing with it. Doug's talk included plenty of code snippets, and I've found reading through them to be a great way to get started.

Craig Silverstein of Google gave a talk on "Implementing Include-what-you-use Using Clang” (PDF). Include-what-you-use is the principle that C/C++ source files should directly #include header files that provide declarations/definitions that they use, rather than relying on transitive #includes. Building on Clang, Craig has developed a tool to analyse C++ code to detect and correct violations of this principle. This looks like a really handy and great example of what you can build on top of libclang.

Howard Hinnant of Apple introduced us to libc++ (PDF), a new C++ standard library built from the ground up with C++0x in mind. It has a lot of cool features, including fast default constructors, minimal memory footprints for default constructed objects, and fast move constructors. Dependence on libstdc++ is no barrier to trying it out: you can happily link your project against both libraries (libc++ uses inline namespaces to avoid confusion over ABI incompatible objects). One feature I thought was particularly neat was the adaptive sort: the sorting algorithms in libc++ automatically recognize partially sorted ranges and optimize their behavior to exploit the partial sorting for better performance. Howard's test cases showed impressive speedups (over 2x in a lot of cases). I'm really looking forward to trying this out in some of my code.

Greg Clayton, also of Apple, introduced LLDB (PDF), a debugger built on Clang and LLVM libraries. This looks incredible and deserves a blog post of its own, but I'll mention a few of my favorite features here. By building on libclang, LLDB is able to parse complex C++ expressions, up to and including multi-line expressions with local variables and control flow. It has been built from scratch to support a multicore, multithreaded world, with per-thread state and runtime control. Symbolic breakpoints allow you to set breakpoints with everything from File and Line to regular expressions (great for breaking on getters, setters, handlers, etc). Finally, following LLVM's design philosophy all this functionality will be available via a C-API, with python bindings provided too. Looks like another excellent base for new developer tools, and I can't wait to see what people do with it.

Other talks I particularly enjoyed included Nadav Rotem's talk (PDF) on using LLVM for C-to-Verilog synthesis (aka building circuits out of C-code). Nadav ran us though some of the optimizations necessary to prepare LLVM IR for efficient hardware synthesis. Xuejun Yang's talk, "Hardening LLVM with Random Testing" (PDF), was also fantastic. Xuejun's team have developed a system for generating expressive, unambiguous C programs with defined meanings which can be used to test compiler correctness. Since March, 2008 they've helped find and fix over 170 bugs in LLVM.

Slides and videos of the talks I mentioned, and many others, are available on the LLVM Dev Meeting 2010 website. I highly encourage you to check them out.

The Dev Meeting doesn't stop at the talks of course. It's an invaluable opportunity to meet and swap ideas with other LLVM developers. I got a chance to meet Jakob Olesen and Andy Trick, who have been doing great things with LLVM's register allocation framework (my PhD research area). I also chatted with some of the Google devs who are using Clang to tackle issues such as include-what-you-use in the Google codebase. Finally I attended “Birds of a Feather” meetings on LLVM optimizations, and on the progress that's been made (and plans for the future) in building Linux with Clang.

Many thanks to Google, Apple, Qualcomm, and the Qualcomm Innovation Center for making such an amazing event possible. I'd also like to add very special thank you to Google for sponsoring me to attend this event. At the end of the day I walked out amazed at what has been achieved in the last year, and how active the LLVM community has been. I look forward to trying out all these new tools for myself, and I can't wait for next year!

By Lang Hames, LLVM Developer

Now on YouTube: googleOSPO

Ellen Ko — Mon, 20 Dec 2010 17:28:00 +0000

You may have noticed that this blog has been featuring more videos recently. Today we are launching a new YouTube channel, googleOSPO, to organize videos relating to Google and open source in one place. There are playlists of Google Tech Talks that feature open source projects, Googlers speaking at open source conferences, and of course original content like Jeremy Allison’s Geek Time series.

In addition to our new channel, our student programs channel continues to grow with videos, screencasts, and presentations from our Google Summer of Code community. As the Google Code-in program wraps up, we hope to add more videos from those participants as well. Both channels will have content added on a regular basis, so subscribe if you don’t want to miss anything!

By Ellen Ko, Open Source Team

Geek Time with Peter Brown

Ellen Ko — Fri, 17 Dec 2010 17:20:00 +0000

When the Free Software Foundation’s executive director, Peter Brown, visited the Google offices last week, he graciously offered his time for an interview with Samba co-founder and Open Source Programs Office team member Jeremy Allison. Peter and Jeremy spoke for quite a while about several of the hot topics facing free software today. Some highlights of their conversation include:

• A brief history of the free software movement (0:14)
• The difference between open source and free software (4:12),
• The importance of specifying “GNU/Linux” when referring to the first fully free operating system (7:42),
• Linux Libre, a fully free kernel distribution, including the drivers (12:29)
• The Free Software Foundation’s hardware endorsement program, Respects Your Freedom (13:54)
• Unexpected places that free software is appearing around the world (18:42)
• Peter’s career with the Free Software Foundation (20:50).
• Ways that non-programmers can get involved and support the free software movement (26:23)

Throughout the conversation, both Jeremy and Peter provide fascinating anecdotes about ways that free software is shaping society. The video is an effective introduction to software freedom for those who have just discovered the concept, but it's also a great way for everyone to learn more about free software.

UPDATE: The video is now also available in the open video format WebM.

By Ellen Ko, Open Source Team

WindowBuilder becomes new open source project

Ellen Ko — Wed, 15 Dec 2010 23:04:00 +0000

When Google acquired Instantiations, the maker of a suite of Java development tools, we made many of their Java Eclipse tools available for free as part of the Google Web Toolkit. Today, Google is donating the source code for WindowBuilder, an Eclipse Java GUI design tool, and CodePro Profiler, an analytics tool that identifies code performance issues, to the Eclipse Foundation. This represents a major code contribution–learn more about this release on the Google Code Blog.

By Eric Clayberg and the Google Developer Tools Team

Postini EZCommand Shell makes things even easier

Ellen Ko — Wed, 15 Dec 2010 16:30:00 +0000

Today, we are open sourcing the Postini EZCommand Shell, a Perl script allowing Postini administrators to issue EZCommands to Postini from a command line.

The script is useful in two ways. First, it allows Postini administrators to make Postini EZCommands from a terminal. Second, it provides sample code for developers. For years we’ve had the Postini EZCommand, but never out-of-the-box sample code that companies could use. This code gives developers a helpful guide to integrate EZCommand with their internal systems.

Postini EZCommand Shell version 1.0.0 supports the following EZCommands:

adduser
modifyuser
deleteuser
suspenduser
addalias
deletealias

For more information, see our site on Google Project Hosting.

By Jeff Pickhardt, Enterprise Sales Engineering Team

Google Days in the Middle East

Ellen Ko — Tue, 07 Dec 2010 17:00:00 +0000

Chris DiBona, head of the Google Open Source Programs Office, is in the Middle East this week to talk to attendees at G-Egypt and G-Jordan, Google’s first ever Google Days hosted in those countries. The G-days will be held in Cairo between December 8th and 10th for G-Egypt, and in Amman between December 12th and 14th for G-Jordan.

Both events are 3-day conferences, with each day catering to a different audience. Day 1 is for Computer Science Students and Professors, Day 2 is for Software Developers, and Day 3 is for tech entrepreneurs, small businesses, and marketers. Chris will be discussing “Work in Open Source” each day, so there are lots of opportunities for attendees to listen to his talk or introduce themselves.

Registration for G-Egypt and G-Jordan is currently full, but you can discover other events coming up near you on our Google Developer Events Calendar.

By Ellen Ko, Open Source Team

A Summer of Accessibility

Ellen Ko — Mon, 06 Dec 2010 16:45:00 +0000

Tekla (formerly mEADL) is a collection of open hardware and open source applications that may be used to enable access to mobile devices for people with motor impairments. The idea for Tekla was the brainchild of the mobile accessibility team at the Inclusive Design Institute (IDI), which became a new mentoring organization for Google Summer of Code in 2010. Our goal has been to bridge some of the gaps currently preventing people with disabilities from using mobile devices.

Google Summer of Code student Eric Wan is a developer who employs accessibility switch access in his daily life. Having him on our team was incredibly valuable because he has a personal understanding of the practical issues involved in creating an accessibility solution. Google Summer of Code provided the means for Eric to "scratch his own itch" and now many more switch users may potentially benefit as the IDI is working with Komodo OpenLab to commercialize the technology.

The video above shows Eric using the “sip and puff” switches attached to his wheelchair to send commands to his Android handset in order to start the phone's SMS application and compose a text message - all without ever touching the phone!

How it works:
Switch events from Eric's wheelchair are sent to the phone via the Tekla shield, a bluetooth interface based on the Arduino open-hardware platform. Once on the phone, these switch events are used to navigate an on-screen keyboard provided by the Tekla open-source app, which is available for free from the Android market.

Challenges:
There is still some accessibility work to do on Android devices. For example, menus that appear when pressing the device MENU key and some pop-up windows will block the on-screen keyboard, sometimes locking switch users out of the phone. Also, some third-party application developers will disable access features in their interfaces, making their apps unusable with the Tekla shield. For example, Eric can sign in to Skype, but he cannot use the "call" button or the dialer due to limitations of the user interface. Luckily though, most functions and apps are accessible because developers generally have to go out of their way to make their apps inaccessible.

Acknowledgements:
Eric is an engineering grad student at the University of Toronto, and he helped develop Tekla with me (his mentor) and Zongyi Yang, another U of T student. In addition to funding from the 2010 Google Summer of Code program, development on Tekla has been funded by the Ontario Ministry of Research and Innovation. Tekla is also being developed as part of the AEGIS Project.

By Jorge Silva, Google Summer of Code Mentor for Inclusive Design Institute

Gulliver powers Lonely Planet’s Trippy travel planning apps

Ellen Ko — Tue, 30 Nov 2010 17:00:00 +0000

Gulliver is an open source platform from Google that helps users plan trips in real time with their friends. Using Gulliver, you can create applications for mobile, iGoogle, and mobile web platforms that make it easy to build and share itineraries using Google Maps resources and Lonely Planet recommended itinerary items.

You can use Gulliver to:

• Create, share, and sync trips between the AppEngine web application, iGoogle, and the Android application
• Create scheduled and unscheduled trips
• See Lonely Planet recommendations for hotels, activities, sights, restaurants, and more for top destinations
• Seamlessly show parallel Google results when there are no Lonely Planet results
• Rate and comment on items
• Create custom items
• On iGoogle, drag and drop items from the map into the itinerary list
• On Android phones, take photos from within the app

A fully functional consumer app has been built on the Gulliver code base: Lonely Planet’s Trippy. Trippy combines the travel expertise of Lonely Planet with the power of Google web search and Google Maps.

Trippy for iGoogle (click image to enlarge)

Trippy for mobile web (click image to enlarge)

Guilliver was created as a 20% time project, a well-known part of our philosophy and company culture which enables engineers to spend one day a week working on projects that aren't necessarily in our job descriptions. We can use the time to develop something new, or if we see something that's broken, we can use the time to fix it. And now you can take these open source apps and run with them! We’re making that possible by rolling them out to the open source community under the Apache license.

Want to get involved with Gulliver and help us make it an even better application? Join the Gulliver team! To get started, just visit our project page, join the community, and download the code.

By David Yu Chen and Alex Cuthbert, Google Gulliver 20% time team

Life after Google Summer of Code

Ellen Ko — Mon, 29 Nov 2010 17:00:00 +0000

My name is Oscar Castañeda, I am a student from Guatemala currently doing a master’s in Computer Science at Delft University of Technology (TU Delft) in The Netherlands. For the 2010 Google Summer of Code I completed a project with the Google Open Source Programs Office as my mentoring organization and professor Michel van Eeten (TUDelft) and Nitin Bhide (Founder SVNPlot) as my project mentors.

In my research I study behavior in code production for all open source projects in the Apache Software Foundation (ASF) from 2004 to 2009, and this research was the subject of my Google Summer of Code project. I contributed to SVNPlot, a tool that creates various type of graphs and statistics from Subversion logs. My contributions enable SVNPlot users and developers to generate networks of file co-authorship that can be used to study behavior in code production, like the graph below which shows code production in the Apache Hadoop community and sub-communities in 2009.

After having finished my project in August, one remaining goal I had was to give a talk about my project, so presenting at ApacheCon NA this year was a good opportunity to accomplish that task.

I was able to travel to Atlanta and attend ApacheCon thanks to sponsorship from the ASF’s Travel Assistance Committee (TAC). The experience has been outstanding and packed with lots of fun. Other students and open source enthusiasts from all over the world were also sponsored by the ASF. We assembled into what became known as the “TAC Team.” As part of the TAC Team, we were in charge of chairing conference sessions, hosting Meetups and helping out behind the scenes. Best of all, we could attend the full conference and all the fun events that followed.

For me the experience was particularly interesting because I met many of the committers that power the ASF. Having done research on how ASF developers organize into communities, attending ApacheCon allowed me to put faces to usernames several times.

My challenge at ApacheCon was to give a talk to the very people whose code production behavior I had studied. The approach I took was to practice, practice, practice.

BarCamp offered an initial ice breaker in the preparations for my talk. The unconference style of BarCamp made it easy to propose a topic to talk about for 30 minutes. I simply posted a sticky note on the white board with the title “What is Meritocracy?” As soon as my slot started I noticed that BarCamp would be an interesting experience. Rather than just a presentation, the BarCamp talk I had proposed turned into an active exchange of ideas where I received many challenging questions.

Chairing conference sessions also helped me prepare for my talk. As session chair I was introducing speakers and assisting them with time management. In addition, I was sitting in on sessions, and seeing the speakers present helped me get into the flow of speaking at a conference. I found extraordinary examples in talks on Hadoop, Tuscany, and Mahout. And finally, the day came for me to present.

I was scheduled for the first morning session in the community track. It was a pleasant surprise to see that over 30 attendees showed up for my talk. All of them were well-prepared with mugs full of coffee, ready to listen to my morning talk. And in the end I found that practice does pay off. I wasn’t nervous and felt confident giving my presentation, a feeling that was reinforced when I saw that the audience was actually awake! However, deeper into the session I lost track of time. Luckily a fellow TAC team flashed the 20 minutes card, showing me that I could finish all my slides and still leave time for questions. The slides and a recording of my talk are available for those who want to know more.

Overall the experience has been very gratifying. I met lots of interesting people and learned more about open source and new developments there from the developers themselves. I highly recommend future Google Summer of Code students to consider including presenting their project at a conference as one of their project goals.

By Oscar Castañeda, 2010 Google Summer of Code Student

Objects in mirror…

Ellen Ko — Wed, 24 Nov 2010 17:30:00 +0000

Nearly a year in the making, kernel.org has announced four new machines coming online in November of 2010. This is quite the change in infrastructure, covering two new "heavy lifting machines" and two new backend machines to round out kernel.org's infrastructure of 12 boxes running worldwide.

As many people know, particularly if you are reading this blog, kernel.org runs the infrastructure that the Linux Kernel community uses to develop and maintain a core piece of the operating system. That said, kernel.org provides a lot more services than just a couple of git repositories and a place to download kernel releases. It hosts the Android source, provides Internet bootable utilities and installers, one of the fastest and most comprehensive mirrors of Linux distros, a plethora of wikis, and the Linux Kernel bugzilla. It also hosts and maintains a variety of other websites that are central to the development of the Linux Kernel or to the greater Linux ecosystem.

The four new machines that have fully come online in November were donated by Google with a generous discount from HP, and they are some impressive pieces of hardware to say the least!

Mirrors1 and Mirrors2, the two machines in the United States that service mirrors.kernel.org, fully replace machines that had been in service for 5 years. The new machines live up to their names of the “heavy lifting machines” (both because they move the most data for kernel.org, but lifting 6-10u worth of equipment is actually quite heavy)! Specs for those are:

Mirrors1:
DL380 G7
2 x E5640 Intel Xeon Processors
144GB DDR3 ECC RAM
2 x MSA70 external drive chassis
2 x P812 Array controllers
66 x 300GB 10K RPM SAS drives

Mirrors2:
DL380 G6
2 x X5550 Intel Xeon Processors
144GB DDR3 ECC RAM
2 x MSA70 external drive chassis
2 x P812 Array controllers
66 x 300GB 10K RPM SAS drives

Each setup uses up 6u of space now, saving us about 4u per-setup over our old equipment, and they give us a lot more storage space and a lot more RAM to be able to handle mirroring for so many people.

We also upgraded the master backend machine for kernel.org, and took our still-awesome previous master backend and turned it into a live spare should anything ever happen to the primary machine. We added a second dynamic web infrastructure box as well, to help host the wikis and things like bugzilla, giving us an active fail over as well as a load balanced system.

With these two additional boxes coming online, kernel.org reached a milestone as we now have a redundant machine for everything currently in our inventory. We've been quite successful with the redundancy we have with our frontend facing machines, and now we have that same level of redundancy available to us on our backend machines.

master:
DL380 G6
2 x X5550 Intel Xeon Processors
32G DDR3 ECC RAM
1 x MSA60 external drive chassis
2 x P812 Array controllers
8 x 300G 10K RPM SAS drives
12 x 300G 15K RPM SAS drives

dynamic web box 2:
DL380 G6
2 x X5550 Intel Xeon Processors
32G DDR3 ECC RAM
1 x MSA60 external drive chassis
1 x P812 Array controller
8 x 300G 10K RPM SAS drives

Needless to say we can talk a lot about specs and numbers. But really, a photo is worth a thousand words:

Those are the new backend boxes hosted at OSUOSL.

Our thanks go out to Google and HP for helping make this happen, with special thanks going to
Chris DiBona of Google for making this happen, Shawn Pearce of Google for putting up with with me through all of this, and Bdale Garbee of HP for helping us get the equipment we need and being such a great friend of kernel.org for so many years!

To quote our saying on mirrors.kernel.org, “Objects in mirrors may be closer than they appear!”

By John “Warthog9” Hawley, Chief Kernel.org Administrator

TYPO3’s Huge Summer Success

Ellen Ko — Fri, 19 Nov 2010 19:46:00 +0000

After having participated in Google Summer of Code for the second time, TYPO3 is now looking back at a truly successful summer where five students worked on projects for TYPO3 4.x, FLOW3, and TYPO3 5.0. Now that the summer has come to an end, we would like to give you an overview of the achievements our students made this summer.

Enhanced Usability for the List Module
Nuwan's proposal for the project included ideas to introduce collapsing and expanding tables in the list module by using AJAX, introducing modal dialogs for detailed information instead of the currently used pop-up windows, in-place editing, drag & drop sorting, and a quick search feature. At the end of the summer Nuwan completed all the tasks except the quick search, but added dynamic selection of columns to display on top of the planned feature set. Being completely new to TYPO3 Nuwan first struggled with current documentation, missing tutorials, and getting into TYPO3 development in general. Thanks to the help by his mentors, Thomas and Tobias, he got moving in the right direction. The feature is available as an extension and Nuwan is looking forward to finishing the missing features and providing more extensions for the core.

Generic i18n and l10n strategy for FLOW3 and TYPO3 v5
Karol reports that Google Summer of Code was a great experience, as it made him learn many new things and improved his programming skills. Looking back to his initial proposal he completed most of the tasks. Some details changed during implementation while others became harder than expected and again other tasks turned out to be easier. For more details you can take a look at Karol's weekly reports. As it looks now, Karol will also stay around with the FLOW3 project, taking further care of his project. All of Karol’s code has been integrated into FLOW3.

Enhanced Media Content Element with oEmbed
Aishwarya was not able to reach all of the goals for the enhanced media content element, but the finished ones are quite nice. It now supports oEmbed, which allows you to use a video's page URL like YouTube URLs to embed the video on a page, whereas before you needed to know the exact URL of the video file itself. For such videos the media content element will now also fetch preview thumbnails where possible. The feature is integrated in TYPO3 core and will ship with version 4.5 in January 2011.

Modular Community System
Pascal managed to create a community extension based on extbase and fluid. As he had experience with the new MVC framework for extension development he found it quite easy. Most of the basic features for a community system are implemented. However, to eventually make everything work we need to wait for two issues in extbase to be fixed. The extension is available at http://forge.typo3.org/projects/show/extension-community.

Private Resource Handling for FLOW3 / TYPO3 5.0
Andreas and his mentor Robert discussed implementing a solution for content security in general, as resources in FLOW3 are represented by persisted “Resource” objects. They came to the conclusion to first implement a solution for generic security policies for persistable objects. Andreas found a solution to automatically rewrite queries by using FLOW3's AOP mechanism so that now there is no need to explicitly write security constraints for queries to the persistence layer anymore. The publishing process is also intercepted using AOP and their publishing path is being extended by a security component to eventually protect private resources from unauthorized access. The publishing feature was finished for the FLOW3 release at T3CON10 in Frankfurt.

Looking back at what has been achieved by the students and having won new contributors for the TYPO3 project we see this year's Google Summer of Code as a huge success for TYPO3 and its community. Students come for the code, then stay for the fun and the great community. All the students passed the final evaluation, so congrats to all of them! We’d also like to express thanks to the mentors who helped the students to find their way into TYPO3 and offering a guiding hand.

By Ingo Renner, TYPO3 Google Summer of Code Mentor

Cross posted from the TYPO3 blog

A name check, no more

Ellen Ko — Mon, 15 Nov 2010 19:09:00 +0000

When we first launched Google Project Hosting back in 2006, we wanted to do what we could to encourage best practices around open source development. This was expressed in a variety of ways, one of which was tied into SourceForge’s namespace.

Here's how it used to work: people would create a project on Google Project Hosting, and if that project’s name was already in use at SourceForge, we would email that project’s administrator and ask them if it was cool to use the name again. Most of the time, the person creating the project on Google Project Hosting was the same person on SourceForge, looking to reserve the name on both.

Sometimes though, the project on SourceForge was inactive or had never been active, so we would manually approve the name on Google Project Hosting. In the last few years, it's almost always been the latter case where people want to use a name that has never been active, so we've stepped in to allocate that name to the new project leader.

Since this is, by a long shot, how most of these name arbitration requests have turned out, in the spirit of efficiency we've decided to shut down the SourceForge name check on November 22nd.

Happy hacking this Thanksgiving* and we hope you enjoy Google Project Hosting!

By Chris DiBona for the Google Project Hosting Team

GitTogether ‘10 at Google

Ellen Ko — Thu, 04 Nov 2010 18:30:00 +0000

Last week around 30 Git developers and users gathered for GitTogether ‘10 at Google’s headquarters in Mountain View, CA for three days of hacking, sharing ideas, and making plans for the future of Git and its supporting tool ecosystem. This was the third time we’ve hosted a GitTogether, and we were really excited about the turnout this year. Based on attendees’ $DAY_JOB employers, Git is becoming much more popular in commercial development organizations, demonstrating yet-again how open source can be an effective alternative to traditional propriety development methods.

Here at Google we use Git on our big open source projects like Android and Chromium OS, but also for smaller projects like Gerrit Code Review or the Eclipse Git plugin, as well as our continuing contributions to the Linux Kernel. During my last 2 years at Google, I ( Shawn) have been working on Gerrit Code Review (a web based code review system for Git), as well as maintaining and improving JGit (a pure Java reimplementation of Git). Junio C Hamano, one of the earliest Git contributors and the current Git maintainer, also joined Google last May and continues to contribute to Git as part of his job duties.

The schedule for the three day conference was determined in “unconference” style, with topics for discussion originally suggested on the wiki and later developed in-person through sticky notes posted on a white board. Attendees also took advantage of the #gittogether IRC channel on freenode and an Etherpad server hosted by the OSUOSL, allowing individuals who couldn’t make it in-person to at least have a virtual presence.

The session scheduling process

In addition to the technical discussions, we had a chance to get to know each other socially, enjoying lunches in Google cafés and dinners at some local restaurants. Unfortunately the group failed to develop a “patch of questionable value,” where in prior years Sverre wore a hat, diff learned --pirate, bash completion earned a splash screen, and git auto-upgraded itself.

Photo by Thomas Rast

by Shawn Pearce, Open Source Team

Test your app from right to left

Ellen Ko — Wed, 03 Nov 2010 15:43:00 +0000

Can you spot the error in the following webpage?

Unless you are one of the 56 million Internet users who read Arabic, the answer is probably no. But BidiChecker, a tool for checking webpages for errors in handling of bidirectional text, can find it:

Oops! The Arabic movie title causes the line to be laid out in the wrong order, with half of the phrase "57 reviews" on one side of it and half on the other.

As this example demonstrates, text transposition errors can occur even if your web application is entirely in a left-to-right language. If the application accepts user input or displays multilingual content, this data may be in one of the right-to-left languages, such as Arabic, Hebrew, Farsi or Urdu. Displaying right-to-left text in a left-to-right environment, or vice versa, is likely to cause text garbling if not done correctly. So most user interfaces, whether left-to-right or right-to-left, need to be able to deal with bidirectional (BiDi) text.

Handling BiDi text can be tricky and requires special processing at every appearance of potentially BiDi data in the UI. As a result, BiDi text support often regresses when a developer adds a new feature–and fails to include BiDi support in the updated code.

Called from your automated test suite, BidiChecker can catch regressions before they go live. It features a pure JavaScript API which can easily be integrated into a test suite based on common JavaScript test frameworks such as JSUnit. Here's a sample test for the above scenario:


// Check for BiDi errors with Arabic data in an English UI. function testArabicDataEnglishUi() { 
   // User reviews data to display; includes Arabic data. 
   var reviewsData = [ 
      {'title': 'The Princess Bride', 'reviews': '23'},
      {'title': '20,000 Leagues Under the Sea', 'reviews': '17'},
      {'title': 'ستار تريك', 'reviews': '57'}  // “Star Trek”
    ];

     // Render the reviews in an English UI.
   var app = new ReviewsApp(reviewsData, testDiv);
   app.setLanguage('English'); 
   app.render();  

     // Run BidiChecker. 
   var errors = bidichecker.checkPage(/* shouldBeRtl= */ false, testDiv);

   // This assertion will fail due to BiDi errors! 
   assertArrayEquals([], errors); 
}

We’ve just released BidiChecker as an open source project on Google Code, so web developers everywhere can take advantage of it. We hope it makes the web a friendlier place for users of right-to-left languages and the developers who support them.

By Jason Elbaum, Internationalization Team

2010 Google Summer of Code Mentor Summit

Ellen Ko — Tue, 02 Nov 2010 18:44:00 +0000

The 2010 Google Summer of Code Mentor Summit was held Saturday and Sunday, October 23rd and 24th, 2010 at Google’s headquarters (the “Googleplex”) in Mountain View, California. 230 Mentors and Organization Admins from over 120 open source projects attended the summit, once again demonstrating how productive, vibrant, and creative our community is.

The conference was organized as an "unconference," where attendees were responsible for deciding on and providing content for sessions on site. This format works very well because FOSS community members naturally seem to enjoy taking initiative to effect positive change. From organizing conference sessions, to solving logistical issues, to cleaning up conference rooms after the event, everyone helped to efficiently get things done.

The major activities of the conference can be summed up in three words: fellowship, food, and fun.

Attendees began arriving on Friday evening to the meet-and-greet party by the hotel pool, where old friendships were renewed and new ones were formed. Guests turned in relatively early though, as two very full days lay ahead...

Saturday Highlights

• Saturday morning breakfast and lunch at Charlie's Cafe at the Googleplex. Great fuel!
• Saturday unconference session selection process - A surprisingly efficient way to schedule conference sessions very quickly, and with good humor.
• 56 scheduled conference sessions were interesting and well-attended. Notes from many sessions are on the Mentor Summit wiki.
• Although it was a rainy Saturday night, you would never have known it from the amount of fun we had at the hotel. Massive amounts of pizza (and quite a bit of beer) was consumed while equally impressive amounts of social and technical networking was happening at tables in the lounge, in the hot tub, and in the covered tents around the pool.
• Live musical entertainment was provided by Bart Massey, David Percy, myself, and lots of people who sat in on guitar, bass, and keyboards. Thank you all!

Sunday Highlights:

• More great sessions!
• The Google on-site store was open for business and many summit attendees loaded up with top quality swag. Android figurines proved to be extremely popular this year.
• A guided tour of the Googleplex.
• We received our 2010 Mentor Summit t-shirts!
• The summit wrap-up session was built around the question "How can we make the Mentor Summit better?" Many interesting suggestions were discussed during this introspective, conversational talk, and will no doubt be incorporated into future mentor summits.

Some unusual, but very popular summit sessions:

• A chocolate session was presented by Robert Kaye of MusicBrainz. This mouth-watering session included massive amounts of chocolate combined with stimulating discussion of the many merits and uses of this wonderful confection.
• An Advanced Trolling Session, presented by Bart Massey, Jonathan "Duke" Leto, and Selena Deckelmann, explored the fine art of trolling, complete with live examples, and demonstrations of how to deflect, defeat, or subvert trolls, while protecting the host venue. This session was great fun with a serious message.

Some things we learned about ourselves:

• We are part of an incredibly energetic and self-motivated community.
• Given minimal structure we are able to create a productive and enjoyable event.
• There is magic in getting together so many passionate, productive FOSS community members in one place, and allowing them the space to network and create together.
• We can squeeze a lot of practical work and good fun into just two days.
• We are always looking to improve, and given the opportunity we can create solutions and invent better ways of doing things.
• One attendee described the mentor summit as "a rare place where pretty much everybody understands what you're talking about when you discuss code and community."

Major Thanks:

• To the Google Open Source Programs Office for providing the venue, meals, travel reimbursements, and local transportation for the weekend. Special thanks go out to Carol Smith and Cat Allman for all the energy and care they put into the event.
• To OSUOSL for for ongoing hosting of the Google Summer of Code Wiki and setting up an EtherPad instance for note taking use during the conference!
• To the organization Mentors and Admins who attended for making this another productive Mentor Summit!
• To everyone who has supported Google Summer of Code through the years -- you have made a big difference countless ways!

We’re already looking forward to next year!

By Marty Connor, Corporate Operations Engineering team

Integrating R with C++: Rcpp, RInside, and RProtobuf

Ellen Ko — Thu, 28 Oct 2010 22:33:00 +0000

Last week the R “intergrouplet” at Google invited Dirk Eddelbuettel and Romain Francois to come and give a Tech Talk about their joint work on Rcpp, RInside, and RProtoBuf. Dirk and Romain agreed and also let us share the video of their talk:

We were also happy to have John Chambers, creator of the S programming language and member of the R Core team, join us for the talk and discussions afterward.

At Google we use a lot of C++ and an increasing amount of R for data analysis, so the Rcpp package is very interesting to us as a modern type-safe way to write R packages that interface with other Google technologies written in C++. Likewise, the RProtoBuf package makes it easy for analysts and engineers to use R with Protocol Buffers read from Bigtable or other data stores.

By Murray Stokely, Quantitative Engineering Team

Facebook Likes Google Summer of Code

Ellen Ko — Wed, 27 Oct 2010 18:28:00 +0000

This summer Facebook participated in Google Summer of Code for the first time and we want to share an update on the progress our students made. Unlike most organizations participating in the program, we have a number of open source projects rather than just a single project. This meant that we accepted a few students to work across open source projects which we actively contribute to in addition to projects that we've released.

We received many applications from students all over the world who were excited to spend their summer working on adding new features to HBase, HipHop for PHP, Scribe, Three20 and XHP. While some projects are still working on merging their changes, by the end of the summer:

• Chongxin Li designed and coded some initial support for snapshotting in Apache HBase that will allow for easier recovery from data loss.

• Hui Chen ported HipHop for PHP to 32-bit operating systems, implemented some missing extensions, and helped improve the stability of the project. All of these changes are already in the core and some are running on the very web servers you're using right now.

• Souvik Roy added regular expression support to Scribe for category names and implemented some unit tests into the existing system which makes future development easier.

• Chih-Wei Lee spent his time working on adding iPad support to Three20, the UI library we released which is used by many iPhone applications. Some of this support has been merged into trunk and the rest is being reviewed.

• Avgoustinos Kadis added support for new HTML5 elements to XHP. This allows PHP developers to write their HTML once and have XHP handle gracefully degradation from native HTML5 elements to JavaScript implementations in older browsers. (We wrote about how we’re using HTML5 two weeks ago.)

As part of Google Summer of Code, both the students and mentoring projects receive a stipend, and we asked that what would be given to Facebook is donated to the Apache Software Foundation instead. We really enjoyed having the opportunity to take part in Google Summer of Code and want to thank these five students for their awesome work!

By Scott MacVicar, Facebook mentor for Google Summer of Code

This post is cross posted from Facebook’s Engineering Notes

Perl and Parrot Spread Open Source Love

Ellen Ko — Sat, 23 Oct 2010 16:00:00 +0000

The Perl Foundation and the Parrot Foundation took part in Google Summer of Code this year, and as the organization administrator, I am very proud of and humbled by all the students and mentors that I worked with. I am constantly reminded that there are very intelligent developers who are very young, and the Perl and Parrot Foundations are very lucky to attract them and have them in our communities. I firmly believe that the passing Google Summer of Code 2010 projects have had a large positive impact on our codebases and many people will benefit from them for years to come.

We were lucky to get proposals from very bright and capable students. We started the summer with 10 students and had 8 students pass their final evaluations. The passing projects include:

Ryan Jendoubi -- Ctypes for Perl
Mentor: Reini Urban (Repo)
This project is exciting many Perl developers, because it minimizes the need to use XS, which makes many more pure-Perl modules possible. This improves portability, because XS-based modules are notorious for being fragile across operating systems and compiler versions. This adds up to a whole lot of WIN.

Nat Tuck -- Hybrid Threads for Parrot
Mentor: Andrew Whitworth (Repo)
Threads allow a single program to use more than one CPU, which is becoming increasingly important these days. Even mobile phones are multicore! This work aimed to add threading support to Parrot Virtual Machine. Much was accomplished, but this effort is still on-going. So-called "green threads" were implemented, which is a necessary step to get Hybrid threads working.

Tyler Curtis -- A PAST Optimization Framework for Parrot
Mentor: chromatic (Repo)
This project is about providing a framework for optimizing PASTs (Parrot Abstract Syntax Trees). This will be used by language implementers when optimizing their HLLs (High Level Languages). This framework allows all languages on Parrot to benefit from optimizations that are written once, instead of each language implementer writing their own optimizations.

Daniel Arbelo Arrocha -- NFG and single-representation strings for Parrot
Mentor: Allison Randal (Repo)
NFG stands for Normal Form Grapheme, and basically means having a standard internal representation of Unicode strings, so that very expensive conversions do not have to repeatedly take place. This makes string-heavy computations much faster and unifies a lot of code.

Carl Masak -- Add support for binary data in Rakudo
Mentor: Jonathan Worthington  (Repo)
Rakudo Perl 6 now supports various binary data formats that were implemented as part of this project. Many relevant tests were also added to the Perl 6 Spec Test Suite as well as improvements and clarifications to the Perl 6 Specification.

Muhd Khairul Syamil Hashim -- Instrumentation Tool for Parrot
Mentor: Christoph Otto (Repo)
This instrumentation tool for Parrot allows developers to dynamically peek into the execution of Parrot op-codes. This allows for profiling tools that can answer questions like "who calls functions X" and "how many Objects of type X were created."

John Harrison -- Improvements to NCI/LLVM Stack Frame Builder for Parrot
Mentor: Peter Lobsinger (Repo)
This project is a prerequisite for a JIT (Just In Time compilation) framework, which is an important goal for the Parrot community, since Parrot decided that our old JIT subsystem was broken beyond repair and removed it. Parrot has decided to use the very popular LLVM project in our rewrite of our JIT, and this project brings us a step closer on our journey.

Pawel Murias -- Mildew and SMOP on CPAN
Mentor: Daniel Ruoso (Repo)
This project involved working on Mildew and SMOP. Mildew is a Perl 6 implementation, and SMOP is the library Mildew uses for meta-object programming. You can think of Mildew as a sister to Rakudo Perl 6. Having many implementations of Perl 6 helps to better define the Perl 6 specification. Updated versions of SMOP and Mildew are now available on CPAN.

The two projects that did not pass the final evaluations were:

Justin Hunter -- Rework Catalyst framework instance initialization code
Mentor: Florian Ragwitz  

Mirko Westermeier -- Bulletproofing the Mojolicious test suite
Mentor: Marcus Ramberg

Both of these projects passed their midterms, but due to circumstances outside of the program, these students were not able to complete their goals for their final evaluation. Sometimes Real Life throws you a curve ball, like starting a new job, moving to a new city, having a baby or similar things. We wish these students the best of luck, and hope that they complete their projects outside the structure of Google Summer of Code.

To all that participated in Google Summer of Code - Rock on and keep spreading the open source love!

By Jonathan “Duke” Leto, Google Summer of Code Administrator for Parrot and Perl

Cross posted from dukeleto.pl, my personal blog about Perl 5, Perl 6, and Parrot Virtual Machine.

Greetings from Santa Kurara, Kariforunia

Ellen Ko — Tue, 19 Oct 2010 21:00:00 +0000

Hello from the Unicode Conference in Santa Clara, California, where the Maps Transliteration team is giving a talk about ICU-based transliteration. Transliterating this originally Spanish city name to Japanese, we get サンタ・クララ, which (when morphed back to the Latin writing system) becomes “Santa Kurara.”

Machine Transliteration is an active area of research (slides), which means it can be rather challenging in general. Typically, transliteration emulates the pronunciation, but sometimes it also preserves some aspects of the original written spelling. We created transliteration modules with the open-source ICU library for languages that have highly regular spelling; if you’re using Google Maps in Japanese, Russian or Chinese, you can see how we use it to display labels in both the local language and your own:

Today, we’re announcing the contribution of our ICU transliteration rules for Czech, Italian, Japanese, Korean, Mandarin, Polish, Romanian, Russian, Slovak and Spanish to the Unicode Common Locale Data Repository. (For languages with very irregular spelling, like English, we supplement ICU with some more advanced techniques.) If you would like to try writing rules for your own language, have a look at the instructions in the ICU user guide.

アスタ・ラ・ビスタ — “Asuta ra bisuta,” from sunny “Kariforunia!”

By Sascha Brawer, Martin Jansche, Hiroshi Takenaka, and Yui Terashima, Maps Transliteration Team

Geek Time with Rusty Russell

Ellen Ko — Mon, 18 Oct 2010 21:46:00 +0000

Free software advocate and Linux developer Rusty Russell sat down for an interview with Google’s Jeremy Allison when they were both in Japan for LinuxCon. They discuss Rusty’s role maintaining the Linux kernel (0:15), why Australia has produced so many top notch open source developers (3:13), and suggestions for people starting out in their careers and looking to get into open source (9:13). Enjoy!

Thanks to Simon Horman for operating the camera.

By Ellen Ko, Open Source Team

Another Successful Summer for Haiku

Ellen Ko — Wed, 13 Oct 2010 20:29:00 +0000

For the past four years, the Haiku Project has had both the honor and privilege of being a mentoring organization in Google Summer of Code. This has been a wonderful opportunity for the project, as it exposes us to many young and energetic minds that are interested in developing open source software. Even more exciting, it provides a unique opportunity for the project to generate income while growing a handful of carefully selected students into knowledgeable and potentially long-term contributors.

Seven students were allotted for the Haiku Project in 2010 and of those, five students successfully passed the program! More important than the short-term contributions of code is the fact that the students are now more experienced open source developers -- specifically for Haiku. During the program, one student (Alex Wilson) was granted commit access to the Haiku Project, and several other students have expressed plans to continue contributing in the future. As an open source project that develops an operating system, our pool of active committers is relatively small and being able to embrace new contributors is a wonderful thing.

Student Summaries

Atis Elsts, Implementing IPv6 (Code)
At the moment, IPv6 is not included in default images. However, basic IP address assignment, ICMP, and ping6 are working. Some code, which includes NetServer and ifconfig has yet to be merged and is accessible at Atis’s github account: haikuipv6.
Atis plans to continue working on the existing problems in the network stack (e.g., #6502) and to eventually bring IPv6 to full working status.

Janito Vaqueiro Ferreira Filho, Implementing ext3 support (Code)
Ext3 Indexed Directory Lookup was committed in r37295 and was needed for implementing read support. For write support, the basics of journaling is implemented, but needs more thorough testing. The majority of his code was committed earlier as r38573. In addition to working on ext support, Janito fixed some issues relating to BFS and the block cache (r37899, r38103).

Christopher Humphries, Improving and Extending Media Player (Code)
Shortly after the start of the coding period, Christopher received news that his university had retracted their word on accepting Google Summer of Code as a valid internship. This necessitated changes to his project proposal -- specifically reducing the scope of the project to DVD support. Originally, he started out making a media plug-in, but finally opted for an add-on. The latter provided better interfacing and control for applications -- mostly because the library needs path information. Other problems cropped up, such as the absence of a demuxing node and faulty mpeg decoding. This led to the realization that the kit needs more work before it can do the job. Christopher has even presented some thoughts to the community: Pitching Media Kit ideas, Alternatives to plug-in sniffing, and A true streaming equivalent of BDataIO. His code is hosted on his github account, Haiku-DVD-addon.

Christophe Huriaux, Creating Services Kit core elements (Code)
As mentioned in his recent blog post, the Services Kit is now capable of handling HTTP requests (file uploading, POST requests, authentication, cookie support, etc). It supports asynchronous as well as synchronous requests. Christophe has also started updating WebPositive to utilize Services Kit. This provides a real world test-bed scenario and will improve WebPositive by replacing the cURL backend with native API.

Alex Wilson, Taking the Haiku Layout API public, (Code)
This involved archiving of BLayout, BLayoutItem and subclasses (#5525), deriving BLayout from BLayoutItem (#6407), and updating numerous applications to use the new Layout API. In addition to his original proposal, numerous archiving features were implemented as part of #6256 (BArchiver, BUnarchiver, BArchivable). Alex was also granted commit access halfway through the coding period! In the future, he plans to working towards making the Layout API suitable for public consumption.

In closing, many thanks to Google for sponsoring this program and allowing the Haiku Project to participate, to Carol Smith, Google Summer of Code Program Administrator, and to our mentors who helped make this endeavor successful. All in all, this was another successful year for Haiku. Congratulations to all who have participated!

By Matt Madia, Haiku Administrator for Google Summer of Code

This post is cross posted from the Haiku blog, where there are more details about our participation in this year’s Google Summer of Code.

Geek Time with James Bottomley

Ellen Ko — Mon, 11 Oct 2010 20:00:00 +0000

When people first meet Linux Kernel SCSI subsystem maintainer James Bottomley, one question that often comes up is, “Why the bow tie?” Jeremy Allison, Samba co-founder and Google Open Source Programs Office team member, spent time with James at LinuxCon last month and uncovered the answer. After that, Jeremy gets the backstory on the inspiration behind James’ LinuxCon talk about how to convince management to embrace open source (4:58). James also talked about how he became the SCSI subsystem maintainer (1:54) and how he started working on open source (6:47).

Thanks to Sergio Victorino for operating the camera.

By Ellen Ko, Open Source Team

Google Summer of Code report: WorldForge

Ellen Ko — Wed, 06 Oct 2010 22:47:00 +0000

For the third time in a row, Worldforge participated in Google Summer of Code, with three students completing the program this year. Worldforge is the original open-source Massively Multiplayer Online Role-Playing Game (MMORPG) project, so it’s great at getting students who are interested in games into open source.

This post showcases some of the work done by one of our students, Tiberiu Paunescu, to implement a series of improvements to the Ember UI. These improvements were all end-user focused and meant to provide a better and more streamlined user experience.

The first feature implemented was an improvement to the inventory which makes it possible to drag items from the inventory widget into the world, and place them there. When an item is dragged off the inventory and into the world a preview model is created, showing where the item will end up.

The second feature Tiberiu worked on was a new quick-help system. This is designed to provide context-sensitive help messages to the user, triggered by various actions performed. The overall goal is to make it easier for new users to quickly get immersed in the world, and to get proper help messages when they are needed.

The last feature implemented is a new action bar framework. The action bar allows the user quick access through either the keyboard or the mouse to frequently-used items and actions. Action bars can be created and destroyed on the fly, and items can be dragged from the inventory onto an action bar to create a new binding.

Action bars are also property persisted between server sessions.

As you can see from the videos, these are all solid and very useful features which greatly improve the user experience. Tiberiu is a great example of the amazing contributions that can be made in just one summer, we’re all very proud of what Tiberiu has achieved.

By Erik Hjortsberg, WorldForge Mentor

This post is cross posted from the WorldForge Developers Journal.

Geek Time with Ric Wheeler

Ellen Ko — Mon, 04 Oct 2010 17:00:00 +0000

Ric Wheeler is the File System Group Manager at Red Hat, and Jeremy Allison caught up with him at LinuxCon in Sao Paulo, Brazil earlier this month. Ric tells Jeremy how he got into file system development as a grad student, then how he progressed into building storage arrays, eventually becoming a Linux advocate. From there, Jeremy and Ric talk about the direction that Linux is headed and the future of desktop computing. At the very end of the video, you can even hear about Ric’s brush with Hollywood!

Thanks to Sergio Victorino for operating the camera.

By Ellen Ko, Open Source Team

Geek Time with Linus Torvalds

Ellen Ko — Mon, 27 Sep 2010 15:45:00 +0000

Linus Torvalds and Jeremy Allision were both in Sao Paulo, Brazil a few weeks ago for LinuxCon, where they were both presenters. Later in the week when they were waiting to go on a safari at the Sao Paulo Zoo, Jeremy seized the opportunity to go on a trip down memory lane when he asked Linus about the Sinclair QL they each owned while growing up. Because it was so hard to get software for it in Finland, Linus wrote his own assembler and editor (in addition to Pac-Man graphics libraries). They continue to reminisce about more archaic hardware like floppy drives, microdrives, 512 K RAM expansion packs and the Acorn Archimedes.

It’s a geek fest for fans of British computers from the ‘80s! Who knew that the Sinclair QL would play a role in the development of the modern free operating system?

By Ellen Ko, Open Source Team

GenMAPP’s Summer Harvest

Ellen Ko — Fri, 24 Sep 2010 14:45:00 +0000

The GenMAPP organization’s efforts focus on building software tools to analyze and visualize biological data. We joined forces with Cytoscape, WikiPathways, PathVisio and Reactome for this year's Google Summer of Code to offer students a unique opportunity to work at the intersection of biology and computing.

This was our 4th year participating in the program and we reached some new milestones. We mentored 10 excellent students (more than any prior year) with a 100% success rate. We integrated and released more code from this summer’s harvest than in prior years. And most importantly, we continued to expand our development community, as many of this year’s students are enthusiastic about continuing to work with us beyond the summer.

Our projects this year covered a broad range of topics:

• Alternative Splicing Analysis Plugin for Cytoscape, by Anurag Sharma
• CyAnnotator and CyAnimator Plugins, by Avinash Thummala
• User Interface Development in PathVisio, by Bing Liu
• Tools for Exploring Pathway Relations in WikiPathways, by Chetan Bansal
• Expression Data Reader plugin for Cytoscape, by Dazhi Jiao
• Improving Cytoscape’s Labels Experience, by Gerardo Huck
• KEGG Global Map Browser, by Kozo Nishida
• Semantic Network Summary for Cytoscape, by Layla Oesper
• Reactome-WikiPathways Converter, by Leontius Pradhana
• Edge-Weighted Layout for Cytoweb, by Tomithy Too

As part of the open source experience, we invite our Google Summer of Code students to our annual Cytoscape Retreat. This is a great way to engage students in both our development and user communities. One student pointed out a truism that is rediscovered from time to time in our digital age, “face-to-face meetings turn out to be very efficient.” Here are some other gems of reflection and advice from our students this year:

“The most rewarding part was when I was told that I should merge my changes back from my branch into the trunk"

“It has been the chance to meet and interact with wonderful people from various parts of the world, be it virtual or physical. I had a chance to physically meet another graduate student from my university and a professor from USA due to Google Summer of Code.”

“They opened up my perspective about a lot of things — how the industry looks like, where people with similar skill domain as me put themselves in the society, how important the projects I am involved in are, and other subjects unimaginable if I were to not join Google Summer of Code.”

“Got a taste of open-source development which is just amazing and I would like to keep attached with this project even after this GSOC ends.”

“This program is a great initiative, I loved the amount of exposure the participating students get and it definitely is one of the most exciting summers someone can ever get.”

“The most rewarding part is to be able to go to the cytoscape retreat. It is absolutely helpful to the project, and helpful to get to know the mentors and others.”

“Be the best user of the software. If you are the best user, you write and participate [in] the software project spontaneously.”

“At the beginning of the summer, I really had my doubts on whether or not I had gotten in too far over my head. So I very much enjoy being able to look back at what I was able to accomplish and realize that I was able to supersede my original expectations for myself.”

“Don’t be afraid to ask questions. Your mentors are an amazing source of information, and they are really interested in helping you in any way possible.”

“Be cool.”

This post is cross posted from my Next Nucleus blog, where you can read more about our previous years with Google Summer of Code.

By Alexander Pico, Google Summer of Code Mentor for GenMAPP

Get ready to Rocksteady

Ellen Ko — Thu, 23 Sep 2010 15:30:00 +0000

Rocksteady is an effort to use Esper Complex Event Processing (CEP) to analyze user defined metrics. You can use it to parse your data and turn it into events that Esper CEP can query so that you can respond to events in real time.

Too often, metrics and graphs are only useful as an aid in analyzing what happened after things have gone wrong. Staring at a dozen graphs on a TV wall isn't monitoring, it's a waste of time. The goal of Rocksteady is to determine the root cause of breakage based on metrics in real time. Metric analysis is only part of the whole picture though, as we also present solutions including metric convention, metric sending, load balancing, and graphing.

Rocksteady can be used in a number of different environments, but here on the AdMob operations team, we use it to determine the cause of events such as latency. We monitor requests per second (rps) and a slew of other metrics such as CPU and network traffic, then put them together in a prediction algorithm such as Holt Winters to predict a confidence band for the next arriving value. We then record an event whenever metrics are outside the band more than a certain number of times in a row. This is what we call auto threshold establishment. Now, if we have a SLA we really care about, such as response time, we can set a hard threshold, say 250ms. When response time slows beyond 250ms, Rocksteady tells us whether rps, CPU or network crossed their respective thresholds. Now instead of just knowing there is a latency problem, we can also quickly pinpoint the potential cause.

Rocksteady was briefly mentioned in Ignite talks at the 2010 Velocity Conference and Devops Day and now it’s finally ready for open source. Let us know if you have any questions, and enjoy!

By Mark Lin, Operations Engineering Team

Changing the Look of the Web with Stylebot

Ellen Ko — Tue, 21 Sep 2010 17:25:00 +0000

Stylebot editing the Open Source Blog in advanced mode

Stylebot editing the Open Source Blog in basic mode

Cascading Style Sheets (CSS) are a part of every web designer’s vocabulary when styling websites, and since its inception, the C (Cascading) in CSS was intended as a way to empower users to have the final say over how they perceive content on the web. But because creating user stylesheets generally requires programming, end users have not always been able to easily leverage this functionality. Stylebot, a new Google Chrome extension created as a Google Summer of Code project, hopes to finally unlock the power of the C in CSS by giving the end user final control on how web content is displayed.

At Google, the Accessibility Engineering team is very excited about the potential of extensions like Stylebot to improve the accessibility of the web, making it possible for users to customize the web to fit their needs. For example, a Stylebot user with special reading needs might change a webpage by removing images, picking new text and background colors, and even moving blocks of text around. And Stylebot saves the custom style they create, so the next time they access that page the changes will still be there. Even better, they can sync their saved styles across computers so that webpage will always appear with their preferred style.

We invited Ankit Ahuja, the Google Summer of Code student who worked on Stylebot, to write about his experiences creating the extension. While there’s still a lot of work to be done to make Chromium more accessible, extensions like Stylebot are a great step - giving users themselves the power to shape the way they interact with the web.

My name is Ankit Ahuja, and I successfully completed my Google Summer of Code project this year for Chromium. I was mentored by Rachel Shearer. My project is Stylebot, a Chromium extension that enables users to easily customize the web’s appearance. Ultimately, Stylebot aims to make the web more accessible and adaptable.

StyleBot screencast demo

One of the main objectives of the project was to allow users unfamiliar with CSS to be able to use this extension with ease. In the Basic mode, users launch Stylebot on a page, select an element and style it. Changes made by the users are automatically saved, so the next time they visit the page, their custom styles are already applied. This mode provides an easy-to-use GUI for the commonly used CSS properties. For the more advanced users, there is a separate mode in which they can write their own CSS.

A nontrivial problem was allowing the users to preview the changes instantly. So although a stylesheet is used to apply the custom CSS when the page is initially loaded, inline CSS is deployed while the user is in editing mode for a smooth, dynamic editing experience. Another important issue was determining the best way to position the Stylebot panel on the page. During testing, I found drag-and-drop to be slow. Instead, allowing the panel to be moved to a fixed left or right position felt the most user friendly. CSS parsing was required and luckily there already existed a CSS parser in JavaScript.

On my part, I’ve tried to make sure the Stylebot code is useful for other developers. I’ve kept the implementation of features like extension data synchronization, selection of elements, CSS selector generation, etc. separate, so that anyone can reuse the code easily. I’ve also used code from other open source projects. For example, the user interface is the CSS version of Cappuccino’s Aristo and the selection of elements is similar to Firebug’s implementation.

Take a look at a few examples we created using Stylebot. You can install the extension from the Google Chrome extensions gallery. We’re already receiving some positive and critical feedback, which is exciting!

I had an amazing experience participating in Google Summer of Code this year. I had a great time interacting with my mentor through the summer, who was very helpful and motivating. Finally, I would like to thank Google for sponsoring and making this project possible.

By Ankit Ahuja, 2010 Google Summer of Code Student and Rachel Shearer, Google Accessibility Engineering Team

Interviews from GUADEC, Part 5

Ellen Ko — Fri, 17 Sep 2010 17:20:00 +0000

This week we have the last video in Jeremy Allison’s series of interviews from his trip to GUADEC, the GNOME conference. In this video, he talks to Michael Meeks, early GNOME hacker and OpenOffice.org developer. Jeremy and Michael talk about collaboration, malware, and how Michael started his involvement with GNOME. For those who are new to open source, Michael gives tips for those who want to get involved in the GNOME community, developer and non-developer alike. For non-developers, Jeremy also gives translations of geek-speak throughout.

If you missed the earlier videos, you can watch all of Jeremy’s GUADEC interviews together in a playlist. Even though this is the last in the GUADEC series, don’t worry, more interviews are coming up soon because Jeremy just returned from LinuxCon Sao Paulo, Brazil, where he was able to get some amazing interviews. Stay tuned!

By Ellen Ko, Open Source Team

FreeBSD’s Summer Highlights

Ellen Ko — Wed, 15 Sep 2010 16:30:00 +0000

FreeBSD is a modern open source operating system for servers, desktops, and embedded systems, based on over 30 years of continuous development. The FreeBSD Project has participated as a mentoring organization in Google Summer of Code each year since the program’s inception in 2005. This year, FreeBSD mentored 18 students with a final success rate of 89%. The cumulative total over 6 years has been 117 students improving FreeBSD. This participation in the program has brought many new features into FreeBSD, several new long-term committers to the project, and many of the former students have by now joined some of the mentors as colleagues at their respective companies.

A complete list of FreeBSD Projects is available from the wiki, but I wanted to select a small number of the many successful projects to showcase here.

Efstratios Karatzas's project extended the FreeBSD NFS server to support security auditing (logging) of client activity -- before his work, as with most systems out there, FreeBSD logged only local file system activity. This work is valuable and timely: FreeBSD is used widely as a file server, as well as being the foundation OS for numerous storage products including NetApp, Isilon, Panasas, and the open source FreeNAS. We look forward to shipping this feature in FreeBSD 9.0, as the patches mature, as well as seeing Efstratios at EuroBSDCon in Karlsruhe this autumn!

Zheng Liu spent the summer working with veteran FreeBSD kernel hacker John Baldwin on enhancing FreeBSD’s ext2fs to support preallocation and implementing read-only support for ext4 file systems. This was a particularly challenging project and Zheng Liu’s efforts at benchmarking his new implementation and documenting his work were particularly appreciated. This work will likely be included in an upcoming FreeBSD release.

David Forsythe returned to the Google Summer of Code program this year to work on developing a robust library with a clean API to manage FreeBSD packages. The goal is to abstract out some of the capabilities used in the current package tools into a library so they can be easily reused by new tools. David has even started assembling some replacements for the existing package tools implemented on top of his new library, and did a great job coordinating with other students and developers working in this area over the summer.

As usual our mentors are looking forward to continuing to work with their students to leverage all the great work that was done this summer, and to working with new contributors on exciting projects in operating systems, networking, and security research throughout the year.

Thanks to FreeBSD Administrators Robert Watson, Brooks Davis, and Tim Kientzle for helping to put together this post, and to all the other FreeBSD Mentors for helping run another successful Google Summer of Code for the FreeBSD Project.

By Murray Stokely, Software Engineering Team

Introducing the Mobile Bookmark Bubble

Ellen Ko — Tue, 14 Sep 2010 23:49:00 +0000

Today, we’re pleased to announce that we’re open-sourcing the Mobile Bookmark Bubble, a JavaScript library that helps users of your web application bookmark the app to their home screen, just like a native app. We’ve been using this library in several of our own web apps, and hope you’ll find it useful for your users, too.

The bubble, which currently supports iPhone, iPod and iPad devices running iPhone OS 3 and above, slides in at the bottom of the application with instructions for creating the bookmark. The bubble automatically slides back out again after a few seconds if the user does not interact with it. HTML5 local storage is used to prevent the bubble from being shown after the user has dismissed it too many times. The amount of time the bubble remains visible, as well as the number of times the bubble can be dismissed, can be easily configured.

The Mobile Bookmark Bubble is released as an open source project under the Apache license, and is available now on Google Code. The repository includes a small sample application demonstrating how the library can be used. If you’d like to send feedback or have any questions, please see our discussion group. Happy hacking!

By Neil Thomas, Software Engineering Team

Interviews from GUADEC, Part 4

Ellen Ko — Fri, 10 Sep 2010 16:24:00 +0000

Stormy Peters is the Executive Director of the GNOME Foundation, and when Jeremy Allison from the Google Open Source Programs Office ran into her at GUADEC, he was eager to talk to her about the direction that GNOME is heading. In the video above, Stormy and Jeremy discuss release schedules, GNOME 3, and hackfests. Enjoy!

By Ellen Ko, Open Source Team

Thousand Parsec HackWeek at the Googleplex

Ellen Ko — Tue, 07 Sep 2010 19:00:00 +0000

On the 7th of August, the Thousand Parsec core developers congregated for the first time at the Googleplex. We arrived in Mountain View, CA from six locations around the world for a week long hackathon including coding, frivolity and fun!

The Thousand Parsec project was started in January 2002 and is a framework for creating a specific group of games, often called 4X games (from the main phases of gameplay that arise: eXplore, eXpand, eXploit and eXterminate). You might be familiar with some of the games that Thousand Parsec draws ideas from such as Reach for the Stars, Stars!, VGA Planets, Master of Orion and Galactic Civilizations. The ultimate goal of Thousand Parsec is to allow multiple different 4X games be playable in a single client.

A primary focus of the week was to increase the playability of the “rulesets” (different game implementations). We spent plenty of time playing games, especially the Risk and Minisec games. While tempted to spend a week just playing games, we also fixed numerous bugs, cleaned up obsolete code, made lots of client improvements and reviewed Google Summer of Code students’ work.

By having many of the core developers in one location, changes could be made significantly quicker. An example is the new “Who is ready?” feature, which lets players know who is holding up the game and hence they are now able to guilt them into hurrying up! You can check out all the improvements that we made during the hack week by cloning out our latest git repositories and following setup instructions on our wiki.

Thousand Parsec still has a long way to go before it is as polished as the games which it draws ideas from, but hopefully with the continuing work by the contributors on line and in person at additional meetups, we have a bright future ahead.

Google Summer of Code was instrumental in making the hackfest happen. The event was primarily funded though the mentor payments, and the majority of the developers consisted of former Google Summer of Code students. Stay tuned to this blog for a wrap up of our 2010 Google Summer of Code student projects coming soon!

In the above photo you can see,

• Alan ‘alanp’ Laudicina (from Canada), a Google Summer of Code student in 2009, working on MTSec ruleset.
• Lee ‘llnz’ Begg (from New Zealand), project co-founder who wrote majority of the C++ Code.
• Kornel ‘Epyon’ Kisielewicz (from Poland), a Google Summer of Code student in 2009 and again this year. Working on refactoring the C++ server.
• Tim ‘mithro’ Ansell (me, from Australia), project founder who wrote the majority of the Python Code.
• Vincent ‘Iwanowitch’ Verhoeven, (from Belgium), a Google Summer of Code student in 2008, created our premier AI, daneel-ai.
• Eugene ‘jmtan’ Tan Jie Ming (from Singapore), a Google Summer of Code student in 2008, working on 3d client.

By Tim Ansell, Technical Solutions Engineering Team

Interviews from GUADEC, Part 3

Ellen Ko — Fri, 03 Sep 2010 15:45:00 +0000

For the past two weeks, we’ve been sharing Jeremy Allison’s video interviews from his trip to GUADEC. Today we have a third video where he talks to Lennart Poettering, creator of PulseAudio. Jeremy and Lennart talk about PulseAudio features, how Lennart got started improving audio on the linux desktop, and how to be successful in free software. Enjoy!

Thanks to Fabian Scherschel of Sixgun Productions for operating the camera.

By Ellen Ko, Open Source Team

Eclipse Day at the Googleplex 2010

Ellen Ko — Thu, 02 Sep 2010 18:08:00 +0000

Here at Google, we have engineers using Eclipse every day to build our external and internal products, as well as engineers building and releasing Eclipse tools. Earlier this year, we announced Eclipse Labs, which is “a single place where anyone can start and maintain their open source projects based on the Eclipse platform with just a few clicks.” Since we use Eclipse so much here at Google, hosting Eclipse Day at the Googleplex is one way of giving back to the community and providing an environment for Eclipse contributors and users to network and share ideas. We hosted Eclipse Day before in 2009 and 2008, and last week we hosted our third year where we tried out some new ideas: a brief lunchtime unconference and post-conference Ignite talks.

Ian Skerrett of the Eclipse Foundation wrote on his blog,

Wrap-up of Eclipse Day at the Googleplex

...Over 150 people attended the day long event that included 12 sessions related to Eclipse and Google technology. The presentations are now available online. There was lots of great information presented, like upcoming improvements to the Android SDK (based on Eclipse), Git support in Eclipse, a review of the Instantiations tools that Google just purchased and an introduction to the new Tools for Mobile Web project.

Most important, all of us at Google would like to thank Ian Skerrett and everyone at the Eclipse Foundation for assembling three of these great events. We were happy to welcome the Eclipse community to our campus, and we are happy to continue to support Eclipse. Don’t forget that we’re always looking to make this conference better, so give us your ideas! Tell us what you would like to see at future events in the comments, or if you were able to attend, tell us what you thought about this year’s program.

By Robert Konigsberg, Software Build Tools Team

Interviews from GUADEC, Part 2

Ellen Ko — Fri, 27 Aug 2010 16:49:00 +0000

At many open source conferences, discussions about diversity come up and there is a lot of talk about how to make the open source community more inclusive and welcoming. While the Open Source Programs Office’s Jeremy Allison was at GUADEC, he had a chance to talk to someone who is actively doing something to get more women involved in free software. Marina Zhurakhinskaya, GNOME Shell developer and Senior Software Engineer at Red Hat, is an organizer of the GNOME Outreach Program for Women and she spoke to Jeremy on camera about the program’s activities.

One of the projects that the program has completed was a mentoring program similar to Google Summer of Code, which provided six women with mentors and stipends to help stimulate open source development. They plan to repeat their success again this year with the 2010 GNOME Outreach Program for Women, which will run from mid-December through mid-March to coincide with the Southern Hemisphere’s school break. If you’re interested in participating, take a look at the list of participating projects to see what sparks your interest, check out the mailing list, or help spread the word to anyone who you think should apply!

Thanks to Fabian Scherschel of Sixgun Productions for operating the camera.

By Ellen Ko, Open Source Team

Acre, an open source platform for building Freebase apps

Ellen Ko — Wed, 25 Aug 2010 18:23:00 +0000

Freebase is an open, Creative Commons licensed repository of structured data that contains information about 12 million real-world entities including people, places, films, books, events, businesses, and almost any other thing you can imagine. Our graph database has about 400 million facts and connections between entities, and all of it is accessible via our REST API. Freebase was acquired by Google last month, and one thing we knew would happen was that Freebase would become “even more open.”

We first launched Acre, the hosted, server-side JavaScript platform behind Freebase Apps, just over a year ago. Since then it's become more and more important to us and to the Freebase community. Not only are all kinds of individual developers and businesses using Acre to build apps and integrate Freebase data into their own platforms, but we've also recently announced our intention to develop the Freebase.com site on the platform, too.

Until now, Acre development has always been tied to Freebase.com, meaning that you need to develop your Acre apps on our server, using our app editor. But we know that most software developers prefer to use their own native development environments -- their favourite text editor, version control system, and so on -- so lately we've been working on ways to make Acre work with source code that's not stored in Freebase.

Last week we announced that we're releasing the Acre platform as open source software. This means that you can run Acre on your own machine, pulling templates and other files from your local disk and using your own development environment. While Acre still has close ties to Freebase (such as API hooks for easily making Freebase queries), this also means that you'll be able to develop standalone, non-Freebase apps using the platform if you want. And, by running Acre on your own platform, you can avoid the resource limitations that are necessary in a shared environment.

If you're interested in server-side JavaScript platforms, you may also be interested in some of the technical details of Acre.

Acre is based on Rhino, Mozilla's implementation of Javascript in Java. (In fact, "Acre" stands for "A Crash of Rhinos Evaluating.") Acre, by default, uses the Jetty servlet engine as its HTTP server, but can be run in any servlet container.
Acre includes a module system that supports high-latency source retrieval using extensive caching. Although Acre was originally designed to fetch data only from Freebase itself, it can also fetch data from disk and will support a wider range of require() options such as WebDAV.
Acre is capable of running on Google AppEngine, with support for the Keystore and for synchronous and asynchronous HTTP requests. Soon, Freebase's own Acre installation will run on AppEngine.

Please download Acre and try it out, and let us know what you think! You might also like to look at some of our other open source releases, like freebase-python (a Python library for working with the Freebase API) or freebase-suggest (a jQuery plugin that makes it easy to have your users select Freebase topics based on any criteria). For more information about Freebase and our open source efforts, see the Freebase wiki or post to the freebase-discuss mailing list.

By Kirrily Robert, Freebase Team

Interviews @ GUADEC, part 1

Ellen Ko — Fri, 20 Aug 2010 23:13:00 +0000

Jeremy Allison, co-founder of Samba and member of the Google Open Source Programs Office, recently returned from GUADEC, the GNOME conference held in The Hague, Netherlands. Jeremy was kind enough to bring his video camera along with him so he could interview some open source community notables and share the recordings here on this blog.

Jeremy’s first interview is with Bradley Kuhn, who is a board member of the Free Software Foundation, the president of Software Freedom Conservancy, and the Policy Analyst and Technology Director at the Software Freedom Law Center. Jeremy and Bradley discuss the GPLv3 and Bradley’s work as an advocate of free and open source software.

By Ellen Ko, Open Source Team

Ready, Set, Go

Ellen Ko — Thu, 19 Aug 2010 18:04:00 +0000

Rob Pike, Google Distinguished Engineer and co-creator of the Go programming language, presented an OSCON keynote last month about his motivations for creating Go. For those of you who weren’t able to catch Rob in person, you can now watch the video of his talk.

If you’ve been curious about an open source programming language that offers, in the Go team’s words, “the development speed of working in a dynamic language like Python with the performance and safety of a compiled language like C or C++,” check out the video and then get Going!

by Ellen Ko, Open Source Team

FISL, I was there \o/

Ellen Ko — Fri, 13 Aug 2010 21:48:00 +0000

GNU and Me

My name is Marcos Paulino Roriz Junior, and I’m participating in Google Summer of Code™ for the first time this year. I’m really excited because I’ve been developing in Java for some time and this is my first step into FOSS. My project is hacking on GNU Classpath on Escher which is an X11 client written in Java, used by the XPeer code to request and handle drawings. I’m learning the X11 protocol which is amazingly cool and surely ahead of it’s time. This is not only helping me with Google Summer of Code but is also the main protocol behind thew idea that I’m using in my final year project.

When I applied to Google Summer of Code I had no idea how it was going to change my life. So far I have not only learned new things, but also met awesome developers. The climax of this was when I joined several other Brazillian students to ask Google for some financial help so that we could travel to FISL (Forum Internacional de Software Livre – International Free Software Forum) in Brazil. Google did an amazing favor and helped us so that we could learn about and spread free software to others. I met with several other students from the #gsoc-br IRC channel, met excellent FOSS developers, and gave a lecture about the Google Summer of Code experience.

At that talk I met more Google Summer of Code students, we shared our difficulties and we exchanged tips on how to solve problems. They all laughed a me when I said that I preferred svn over dscm, like git or mercurial. But at the same time they gave me a very brief and informal talk/introduction to git (which I’m kinda liking). I talked also a lot about X and XCB with friends and hackers there since it’s directly related to my proposal.

Google Summer of Code Students

I had a chance to meet some seriously cool developers (like Jon “Maddog” Hall) and attend amazing talks (like Glassfish in OSGi Bundles and What’s New on OpenJDK 7). Overall, It was a amazing experience, and I want to thank again Google, all the cool people at FISL and my mentor Mario Torre, who understands that I’m a little behind on my project but getting back to the schedule now =).

By Marcos Roriz, 2010 Google Summer of Code Student

BSDCan through the years

Ellen Ko — Mon, 09 Aug 2010 16:00:00 +0000

I’m Kirk Russell, a Google Site Reliability Engineer who moves files around the cloud at a massive scale. I use BSD software on a daily basis -- in my Android phone, my home NAS and my MacBook. My newest toy is a small ARM board that runs FreeBSD.

Earlier this year I attended BSDCan, a software conference for BSD based operating system projects. I attended this conference to learn about new BSD technology that will someday become part of my daily life and to meet people with similar interests -- there is time to chat in-between the scheduled talks and in the pub. BSDCan is a conference where I learn about new development that I can put to use both at work and at home. Learning these things from the original developers makes it that much more interesting.

Here is a quick reflection on some highlights of past conferences:

In 2004, I attended Ryan McBride's talk about PF, a BSD licensed packet filter.

In 2005, I learned about spamd at a talk from Bob Beck. After the conference, I deployed spamd at home -- my spam count dropped to almost zero. Spamd uses PF to block spam at the IP level. This saves resources on your server because you do not actually receive the mail. Adding packet filtering features to the base operating system has enabled new applicaitions, like spamd, to develop.

In 2006, I attended the Debugging Kernel Problems tutorial (PDF) given by Greg Lehey-- I continue to use these debugging tricks when debugging FreeBSD kernels today.

I attended Pawel Dawidek's ZFS talk in 2007. Today I use FreeBSD/ZFS on my home NAS -- I wouldn't think of running my NAS without the features of ZFS. I want my data to have data corruption detection. It is fantastic that a production filesystem can work in my tiny NAS! In 2007 I also saw the brilliant Poisonous People talk by Brian Fitzpatrick and Ben Collins-Sussman. Part of this talk is about avoiding bikeshedding -- it was funny to watch when Fitz and Ben realized that Poul-Henning Kamp, the author of the original bikeshed email, was attending their talk.

2009 was a good year for NetBSD and filesystems. There was a talk about WAPBL a journaling filesystem in the NetBSD tree and RUMP -- a framework that allows NetBSD kernel filesystem code to execute in user space.

2010 showed BSD continuing to be used as a platform for OS research. Kirk McKusick's new Journaled Soft-Update improvements now allows fsck in a few seconds, instead of hours.

The BSD community continues to produce exciting software that can be used in small gadgets and production servers and BSDCan continues to be a fantastic venue to meet the people behind the scenes. Congrats to Dan and his team to volunteers -- I am looking forward to 2011.

By Kirk Russell, Site Reliability Team

São Paulo Open Source Jam 2

Ellen Ko — Fri, 06 Aug 2010 20:07:00 +0000

On July 14th, Google Brazil hosted the 2nd Open Source Jam in São Paulo, Brazil. We had about 40 attendees and 10 talks! Here is a quick summary of the talks that were given.

The jam began at about 19:00, and after Rodolpho Eckhardt welcomed our guests, João Paulo Rechi Vita presented his Google Summer of Code™ project on improving support of AVRCP (Audio and Video Remote Control Profile), a Bluetooth protocol for controlling media players, in BlueZ.

Next, Rodrigo Strauss talked about his “nosql“ multi-platform container server Tio built using a publish/subscribe pattern.

Rodrigo Strauss and his NoSql project Tio

The third project presented was the GPL v3-licensed LibreDWG by Anderson Cardoso, an Open Source implementation of the DWG format used by several CAD applications.

Guilherme Chapiewski talked about acceptance tests using Pyccuracy, a tool for behavior-driven development written in Python.

CoGroo, an open source grammatical structure checker for Portuguese for OpenOffice, was presented by Wesley Seidel.

For the last talk before a break, Saracura was introduced to us as a concept to fill the gap between weather forecasts, reports and collective intelligence among people. By cross-checking the available information, disasters could be prevented or alleviated.

André Luiz introducing Saracura

After six talks it was time for a break. Delicious pizza helped spur conversations among attendees, who talked about their projects and established new contacts. There was so much pizza it had to be delivered by taxi instead of the usual delivery by motorcycle.

Following the break, Radames presented IT3S, a project which intents to promote the use of information technologies with non-profit organizations.

Radamés describing his work at IT3S.

Milton Afonso showed his concept for a framework providing a multi-language programming environment. Alan Justino took the opportunity to start a small debate on certain issues with object-relational mappings. Potential solutions were discussed, as well as comments and ideas.

Alan Justino answering the questions

Our last talk of the day was presented by Luciano Ramalho who talked about ISIS-DM, an independent API for database schema definition and data extraction.

We'd like to thank everybody who attended the 2nd Google Open Source Jam in São Paulo and hope to see you again next time. If you have missed this jam, stay tuned on our events by joining the Open Source Jam Brazil Google Group! Open Source Jams are hosted by the Google Open Source Team.

By Licio Fonseca, Hardware Operations Team

Swivel Viewer, an open source embeddable album viewer

Ellen Ko — Fri, 30 Jul 2010 00:58:00 +0000

A while back, we noticed that lots of sites were starting to show 360 degree views of their products.

So a few months ago we added a feature to Picasa Web Albums that lets you flip through the photos in an album in “Full Screen View” or “Slideshow” mode by dragging left and right on the current photo. This works especially well if you put an object on a turntable, but it also works fine for other albums, like our featured shots from the 2010 Winter games.

The embedded album viewer also supports this feature:

So any albums you've embedded already support swiveling.

If you prefer to host a viewer and images on your own site, check out
the Swivel Viewer site at code.google.com, where you'll find an open source embeddable album viewer that also supports zooming and panning. Alternatively, you can go directly to the page about hosting your own viewer, or check out these other albums from the gallery:

We also posted tips on how to take your own 360 views, and even some sketches for our experimental high-volume object scanner:

Swivel viewers are fundamentally simple, but it’s tricky to communicate to the end user what they can do. I actually used the viewer for several weeks without realizing I could shift+drag to pan around while zoomed in! So we’re excited to see what UI enhancements you can come up with.

By Jason Holt, Google Street View Team

Notes from useR! 2010

Ellen Ko — Thu, 29 Jul 2010 15:30:00 +0000

R is a free software environment for statistical computing and graphics, used by a growing number of economists, engineers, and data analysts every day at Google. We’ve even published our R Style Guide on Google Code. The R community has done a lot of great work with Google APIs, such as integrating the R programming language with Google Earth, Protocol Buffers, and Google Docs.

I've just returned from the annual useR! conference for the open source R programming language. This year the conference attracted nearly 500 individuals to the NIST campus outside Washington D.C.

The conference provided a great opportunity to meet with some of the package authors that are working on third-party extensions, including Romain Francois and Dirk Eddelbuettel who jointly gave a pair of well-attended talks on their RProtoBuf and Rcpp packages.

In addition to the 3 days of tutorials, panels, and presentations, Google sponsored a dinner for conference attendees at the National Zoo in Washington D.C. to facilitate the "hallway track" of informal discussions outside of the official conference program.

Thanks to all those presenters, sponsors, and organizers involved in putting together a successful conference. For those who weren’t able to attend, the abstracts and slides from the 168 presentations and a more limited number of videos are available from the technical sessions. Hope to see you next year...

By Murray Stokely, Software Engineering Team

London OS Jam 17: Speeeeed

Ellen Ko — Wed, 28 Jul 2010 14:43:00 +0000

Just over a week ago, we hosted Google London Open Source Jam 17. The event is an opportunity for open source developers to give five minute presentations to their peers, socialise, eat pizza, and drink beer. The topic for this Jam was “Speed” and — unusually for us — many of the talks were on-topic:

Simon Stewart, pondering

Simon Stewart started off by telling us how to measure things: using tools like Firebug and Speed Tracer to break down client-side latency.

Matt Godbolt gave us some tips for making speedy Android apps, and Tim Cox presented a “Rant at Speed” that covered everything from CPU cache latency to the speed of light, all in five short minutes!

Glyn Wintle gave a quick rundown on common exploits: “How to break into a computer — fast”, covering the top five security mistakes made by web developers. You can try out some of these attacks yourself using the Google Gruyère codelab.

Ade Oshineye gave an impromptu (and not entirely serious) plan for “Making it faster.” Mike Mahemoff talked about speeding up web applications with the new shiny features in HTML5, and chatted briefly about the ever-blurring distinction between web applications and web pages. Paul Downey gave us an overview of TiddlyWiki, and TiddlySpace, where he hosted his presentation.

Squirrel

Squirrel gave a talk about Performance Secrets, which — uniquely for a Squirrel presentation — didn’t involve a flipchart.

Matthew Wild told us about Prosody, an XMPP server written in Lua. Apart from praising Lua as a great language, he also showed us how his continuous build generated annotated performance graphs on each commit to the repository.

George Cox proposed a need for making operational changes at speed — new deployments, and so on, while Luca Colantonio discussed his experiences implementing txty.mobi, a cloud-based web application for sending SMS messages via your own Android phone.

Tom Quick talked about the open source stack he’d used to develop GlastoTag, using Redis as a fast, persistent storage layer, and how using Django had helped to speed up their development process.

Jag

Last but not least, OS Jam favourite Jag gave us an overview of some of the performance decisions he’d made while developing Din.

As always we retired to the pub afterwards to continue our discussions. If you’re around London you’re welcome to join us for the next Jam. Join the mailing list or keep an eye out on the Jam site to find out more.

By Malcolm Rowe, Software Engineering Team

Chris DiBona’s OSCON Keynote: Your Work in Open Source

Ellen Ko — Tue, 27 Jul 2010 15:01:00 +0000

If you missed seeing Google’s Open Source Programs Manager Chris DiBona speak live at OSCON last week, the video from his keynote is now available online.

There are also notes available from multiple OSCON sessions on Google Wave - check out the full listing if you want to catch up!

By Ellen Ko, Open Source Team

Live Waving at OSCON 2010

Ellen Ko — Wed, 21 Jul 2010 18:18:00 +0000

With OSCON underway, we're excited about the opportunities that many of us have to present at the conference and we've taken some time to prepare resources for OSCON attendees to use Google Wave to "live wave" during the event.

If you're not familiar with live waving, it's a way of capturing what is occurring at a live event in real time on a wave. It’s similar to live blogging, but provides a smoother experience for the publishers and viewers. For example, you can take a look at the live wave that was used to capture the keynote address at this year's Google I/O conference.

We've put together the following resources for OSCON:

A public wave that users can use to view an index of all OSCON sessions, with a corresponding link to a live wave for each session (http://bit.ly/OSCON2010LiveWaves)
A "Live Waving 101" introduction wave for users to learn about live waving (http://bit.ly/LiveWaving101)

If you'll be attending OSCON, we would like to ask for your help in getting the word out about the live waves. You can let your fellow attendees know about the waves by tweeting, waving, or emailing the following link to folks: http://bit.ly/OSCON2010Waves. Everyone can contribute and we encourage you to join in on the live waves -- or start your own for one of the hundreds of sessions.

We think that live waves will serve as a great resource for attendees to share information and to connect in real time. If you want to learn more about Wave, please join us for Joe Gregorio and Dan Peterson’s talk, “Open Source Google Wave: Building Your Own Wave Provider” at 5:20 PM on Thursday or for the “Wave - Open Source and Open Protocols” Birds of a Feather (BoF) session at 8 PM on Thursday.

By Andrés Ferraté, Developer Advocate Team

Googlers on the Loose at OSCON

Ellen Ko — Wed, 30 Jun 2010 15:00:00 +0000

In three weeks, Googlers from offices around the world will be gathering in Portland, OR for OSCON, O'Reilly Media’s annual open source convention. OSCON will take place from July 19th - 23rd, and we’re looking forward to the opportunity to meet and interact with the open source community.

There is an impressive lineup of Googlers speaking at OSCON this year, with 20 of them presenting talks and even more attending. Click on the session names below for more information on each talk’s time and location.

Robin Anil: Mahout: Mammoth Scale Machine Learning

Dan Bentley: Make Open Easy

Tim Bray: Practical Concurrency

Ben Collins-Sussman: How to Lose Friends and Alienate People: The Joys of Engineering Leadership

Chris DiBona: Google Open Source Update 2010 and Your Work in Open Source, 3 years of Incremental Change

Brian Fitzpatrick: How to Lose Friends and Alienate People: The Joys of Engineering Leadership

Joe Gregorio: Extending Wave with Robots and Gadgets

Sam Johnston: What We Need are Standards in the Cloud

John Koleszar: Introducing WebM: High Quality, Royalty-Free, Open Source Video

Ikai Lan: Introduction to Google App Engine and What is Google App Engine?

Alex Martelli: Practical Python Patterns and Powerful Pythonic Patterns

Mark Miller: E, Caja

Dan Morrill: Android: The Whats and Wherefores

A. Ali Pasha: Challenges of running Google Code - Porn, Malware, Hacks, etc.

Dan Peterson: Extending Wave with Robots and Gadgets

Rob Pike: Go, Public Static Void, and Another Go at Language Design

Mark Pilgrim: HTML5's Multimedia Future

Mark Smith: Build Your Own Contributors (One Part at a Time)

John Woodell: Ruby and Duby on App Engine

Roni Zeiger: Google Health: Connecting Mobile Patients

If you have a particular interest in Android, in addition to Dan Morrill’s talk there will be an Android Hands-On session at 7 PM on Wednesday. This event promises to be “an intense, technical, and structured event led by Google Android experts.” Advance registration is required for this event, so don’t forget to sign up!

We’ll also be holding a Google Summer of Code™ Birds of a Feather (BoF) session on Wednesday. This BoF is a chance for anyone who has been involved in Google Summer of Code or is interested in learning more to meet face to face and talk about the Google Summer of Code experience. The fun and community bonding starts at 7 PM!

In addition to all the talks and events listed above, the Google Open Source Programs Office will be holding Office Hours on Wednesday, at 2:30 PM. If you’ve ever had a question about open source and Google, this is a great opportunity to meet the team and ask it in person. You’re also welcome to just come by, say hello, and hang out.

Hope to see you at OSCON!

By Ellen Ko, Open Source Team

Google Summer of Code 2010 San Francisco Meetup

Ellen Ko — Wed, 23 Jun 2010 19:15:00 +0000

Carol Smith and Cat Allman (5th and 1st from right) with with meetup participants

Two weeks ago, Google’s San Francisco office hosted a Google Summer of Code™ meetup. I joined a group of about a dozen others, including Carol Smith and Cat Allman from Google's Open Source Programs Office. There were program participants from all over California, including two exchange students and one who came all the way from Guadalajara, Mexico. We didn't have a huge agenda, we just planned to get together and geek out.

We started the event off just after 3 PM with introductions and some background info on the 2010 projects. There were two 2008 Google Summer of Code alums in attendance: João Antunes, who worked on a file transfer protocol for SIP Communicator and myself (John Britton), who worked on a localization server for Gallery.

João and I shared our advice on succeeding in Google Summer of Code. We each gave short demonstrations of our projects and some background to put them in context. We also fielded tough questions on how to make sure to set reasonable expectations for mentors and deliver on promised goals.

After talking about the program, I took the floor to talk a bit about projects that I've been working on recently. I started by giving an interactive demo of Twilio and explaining how my experience duiring Google Summer of Code was instrumental in getting a job there. The program was especially good for preparing me to work on building the community around our first open source project, OpenVBX. After I finished up talking about community building, I shared an update on Mozilla's Drumbeat initiative which naturally segued into a discussion on P2PU and the School of Webcraft.

The team from Scripped followed me by giving some advice on the importance of communication in software projects and on managing expectations. Last but not least, we got an official tour of the Google San Francisco office. Tour highlights included a pit stop in the micro-kitchen, a chance to ride the Google slide, and a giant Android phone.

We rounded out the day with a trip to a pub on the waterfront overlooking the Bay Bridge. Overall, it was a pretty sweet day.

Check out the Google Summer of Code Flickr Group Pool for more photos.

By John Britton, 2008 Google Summer of Code Alum

Introducing the Google Command Line Tool

Ellen Ko — Fri, 18 Jun 2010 15:55:00 +0000

Ever wanted to upload a folder full of photos to Picasa from a command prompt? We did, a lot, last summer. It made us want to say:

$ google picasa create --title "My album" ~/Photos/vacation/*.jpg

So we wrote a program to do that, and a whole lot more.

GoogleCL is a command-line utility that provides access to various Google services. It streamlines tasks such as posting to a Blogger blog, adding events to Calendar, or editing documents on Google Docs.

For example:

$ google blogger post --blog "My blog" --tags "python, googlecl, development" my_post.html
$ google calendar add "Lunch with Jason tomorrow at noon"
$ google docs edit --title "Shopping list" --editor vim

GoogleCL is a pure Python application that uses the Python gdata libraries to make Google Data API calls from the command line.

Read more at the GoogleCL project page, or jump right to the examples. Along with a standard tarball, we have a .deb package ready for download, and hope to have it included in Debian and Ubuntu repositories in time for their next releases. We're adding features all the time, so check in frequently. Or better yet, contribute.

GoogleCL brings cloud computing to your fingertips, literally!

By Jason Holt, Street View Team and Tom Miller, former Street View Intern

Notes from SambaXP 2010

Ellen Ko — Fri, 11 Jun 2010 21:22:00 +0000

Hello, I’m Jeremy Allison, a Google engineer in the Open Source Programs Office and a Samba Team member. I recently returned from SambaXP, the annual Samba Team coding bash and get-together in Göttingen, Germany, held from May 5th - 7th. There were several notable outcomes from the conference, which I’ll share here.

We launched the new look for the samba.org web site at the conference, refreshing the Samba web site with a 21st Century design.

We listened to many presentations, had lots of meetings, and drank fine German beer. I gave a presentation on "How to make a product with Samba," (PDF of slides) aimed at helping companies use Samba in commercial products.

The Microsoft engineers who are working on the SMB (Server Message Block) and SMB2 file-sharing network protocols are Samba Team friends and they returned to the conference this year - in fact, Tom Talpey from Microsoft announced a new project to design UNIX extensions for the SMB2 protocol.

The Samba Team is still making great strides on the next release of Samba, Samba4. Samba creator Dr. Andrew Tridgell from IBM (just to be formal for once... everyone still just calls him "tridge") demonstrated two-way replication between a Microsoft Active Directory domain and a Samba4 Domain. There is still much work to be done on the AD domain controller code, but there is starting to be light visible at the end of the tunnel in getting to a "stable" 4.0 release. Maybe by SambaXP next year there will be an exciting new announcement on this subject.

After consultations with Original Equipment Manufacturers (OEMs) and Linux distributions, the Samba Team decided to move to a nine month period between major Samba releases instead of the previous six month release cycle. The strain of keeping to the six monthly cycle was too great on the release process, and nine months should give a better balance between having time for feature development and time for testing of the Samba production release code.

Plans for the merging of the existing file server (smbd) and authentication daemon code (winbindd) with the Active Directory code (samba) were made, and tridge demonstrated Samba4 printing for the first time.

Günther Deschner from Red Hat won the "Code Janitor of the Year" award yet again, for his clean up of the old printing code, and was only just beaten to the post as the top code commit contributor into Samba by Stefan "the Machine" Metzmacher from SerNet.

John Terpstra of Primastasys announced the clean up of the Samba.org support page as part of the new look for the Samba.org web site. John will be ensuring all companies offering Samba support on the site are kept up to date for users to contact.

Thanks to Google for sponsoring the event, and SerNet for hosting. The slides from all the presentations are available here. If you didn't go, you were missed - and you should certainly make an effort to be there next year!

By Jeremy Allison, Open Source Team

Umit Project 2010

Ellen Ko — Thu, 10 Jun 2010 16:46:00 +0000

Umit Project is an international open source organization focused on network monitoring, with the goal of making life easier for network administrators and others who need to be aware of what is happening in their networks. The project developed out of Insecure.org in 2005, becoming an independent organization in 2007.

Umit Project has been a proud participant in Google Summer of Code™ since 2005. This year Umit Project participates in Google Summer of Code again with two students working on the Nmap Security Scanner.

In 2009, Umit Project received more good proposals than allocated slots, and students contacted us wishing to accomplish their projects even without funding through Google Summer of Code. To address this need, we created Umit Summer of Code (USoC) to enable those "extra" motivated students to participate in our project. Even without a stipend, the students accomplished their projects and they're still contributing in our community.

This year we have decided to operate the USoC program again, and everyone is welcome to join us! Check out more details about it at Umit's blog.

By Luis A. Bastiao Silva, Umit Project Lead Developer and former Google Summer of Code Mentor

Code, Open Source, and Summer Love on the 17th Floor

Ellen Ko — Tue, 08 Jun 2010 15:45:00 +0000

Jon Trowbridge and Borja Sotomayor welcome students to the Google Chicago office

It's springtime in Chicago, and that can only mean one thing: time for the 3rd Annual Chicago-Area ACM-Student/Open-Source-and-Google-Summer-of-Code™ Lightning-Talks-Meetup! Ok, ok, so we haven't settled on a good name yet, although it's mostly a Google Summer of Code meetup. I say "mostly" because, although the event revolves around a series of lightning talks delivered by accepted Google Summer of Code students and by Google engineers, it is open to all students from Chicago-area universities with ACM Student Chapters. (The local ACM chapters helped to organize this event.) Roughly 70 students, mostly Computer Science undergraduates from The University of Chicago, Northwestern University, DePaul University, the Illinois Institute of Technology, Loyola University Chicago and the University of Illinois at Chicago stormed the Google offices in downtown Chicago on May 7th for an evening of intercollegiate mingling and geeking out.

This year, we had three Google Summer of Code student speakers, starting with Michael Lucy from The University of Chicago:

Michael will be working on Guile this summer, as part of the GNU project. His project will involve writing a module for compiling Parsing Expression Grammars (PEGs).

Next up, Jamie Schwettmann:

Jamie is a 2009 Google Summer of Code alumna from The University of Oklahoma, but now she now lives in Chicago because her summer work for The Globus Alliance rocked so hard that the University of Chicago ended up offering her a job to continue working on Globus software! Jamie told us about her project, Project Performance characterization of GridFTP on 10+ Gigabit networks using hosts with 10 Gigabit network interface cards. She also told us not to be intimidated by the title- her summer work ended up revolving mostly around creating an automated parameter optimization utility for GridFTP. She also reflected upon her experience in Google Summer of Code, and all the wonderful things that have happened as a result of it.

Finally, Emily Brand from Loyola University Chicago:

Emily will be working for Drupal on porting QueryPath to D7.

We were also treated to talks from three ~~Googlers~~ G-Men who, according to them, were there for comic relief, although they also provided many insights on real-world coding. First up, Jacob Matthews told us how his views on software development have evolved since his pre-college years. Here he is shown emphasizing the importance of testing:

Next, Vijay Menon extolled the benefits of learning multiple programming languages:

And finally, Jon Trowbridge told us how relational databases are not the be-all-and-end-all of data storage and management, and how Google relies on different approaches for its own data.

Besides the talks, there was also a truly scrumtrulescent dinner:

The captive audience:

And some truly awesome views of downtown Chicago from the 17th floor where Google's conference space is located:

Many thanks to Google's Chicago office for being such an awesome host! And congratulations to our Chicago-area students for making it into Google Summer of Code!

By Borja Sotomayor, University of Chicago Ph.D. Candidate and Google Summer of Code Organization Administrator (Globus Alliance) and Mentor (OpenNebula)
Photos by Anne Celestino and Borja Sotomayor.

Google Chrome’s RLZ library is now open source!

Ellen Ko — Wed, 02 Jun 2010 19:25:00 +0000

Today on the Chromium blog, we announced that we’re open-sourcing the RLZ library in Google Chrome as its own project. The RLZ library gives us the ability to accurately measure the success of marketing promotions and distribution partnerships in order to meet our contractual and financial obligations. For example, the RLZ library generates a query parameter that sometimes appears in Google search URLs in distributed products:

We’re excited to not only improve the transparency of Google Chrome, but also offer potentially useful code to the open source community. Please check it out and let us know what you think!

By Glenn Wilson, Product Manager