Posts from 2011

Wednesday, December 28, 2011

This was the first year CERN participated in Google Summer of Code, and it turned out to be an amazing experience for us! We were given four students to mentor, all of whom proved to be very skilled developers. The students quickly familiarized themselves with our code base and managed to make valuable contributions within the three month time frame of Google Summer of Code. Our students were very open and willing to learn and spent a considerable amount of their time researching tools, libraries, and the latest technological developments. As a result, all four students were able to solve their problems and come up with interesting ideas for future development. The code and the documentation they produced is available here. The specific problems (projects) that we suggested to our students spanned several domains, ranging from consistent replication of terabytes of data across several remote sites to automated testing of virtual machine releases.

Josip Lisec was working on the development of the monitoring system for the CernVM Co-Pilot framework, which is mainly used as a distributed computing platform within the LHC@home 2.0 volunteer computing project. The LHC@home 2.0 project currently has more than 9,000 registered users who contribute their spare CPU cycles for the simulation of the particle collision events in CERN's Large Hadron Collider (LHC). After some research, Josip decided to integrate existing tools with the Co-Pilot as opposed to trying to reinvent the wheel by rewriting everything from scratch. This resulted in a nicely engineered monitoring framework, parts of which were put into production while the Google Summer of Code was still going on (Josip's developments have now been fully integrated after completion of the program). Since this was Josip's first encounter with Perl, he has been seen adding support for 'my' keyword to every other major programming language since the Google Summer of Code concluded.

The goal of Yin Qiu's project was to devise a mechanism for a consistent replication of changes made to the central repository of CernVM File System (CernVM-FS) to a globally distributed set of mirror servers. CernVM-FS is used to host and distribute the application software of CERN LHC experiments to hundreds of Grid sites, as well as the laptops and workstations of users worldwide. As such, it is currently one of the central components of the distributed computing infrastructures on which CERN ATLAS and LHCb experiments rely. Yin's approach was to organize CernVM-FS mirrors into a Paxos-managed replication network and to enforce state machine version transitions on them. Following the suggestion of Jakob, his mentor, Yin implemented a messaging framework which is used to orchestrate the replication process and facilitates the implementation of new features. He also managed to implement a couple of Python plugins which ensure the consistency of data across replicas. The project is currently in the state of a working prototype.

Jesse Williamson took up the challenge of designing a new library for CernVM-FS to consolidate support for various cryptographic hashing algorithms. The first task was to survey the implementation of CernVM-FS and establish a list of requirements. Next, quite a bit of effort was spent on designing the library specifically so that it would be easy to use, comparatively simple to extend, and robust enough to support extensions like a streaming interface and compression. Since CernVM-FS is heavily used in production, it has been very important to make sure that the new developments do not break anything. Jesse has developed a set of unit tests which ensure that all the existing features and properties were maintained.

The design of new C++ libraries was certainly an improvement, but it also became clear late in the cycle that a further abstraction to fully separate digests and hash functions will be necessary to avoid memory fragmentation issues and ensure stronger const-correctness

Jonathan Gillet worked on implementing a solution for automating the testing of CernVM virtual machine images on multiple hypervisors and operating systems. The solution, which is a ready to use testing infrastructure for CernVM, was developed in collaboration with other open source projects such as AMD Tapper (used for the reports and web interface), libvirt (interaction with hypervisors), and Homebrew (OS X support). The main goals of the project were accomplished with support for all major hypervisors running on Linux and OS X platforms. The framework automates the task of downloading and configuring the CernVM images on the fly, and executing a series of thorough tests which check various features of CernVM images before release. Documentation was also an important goal of the project; in total there are now over two hundred pages of documentation which cover everything from setting up the testing infrastructure and virtual machines to a complete API reference.

We certainly enjoyed Google Summer of Code 2011, and we sincerely congratulate all of our students and mentors for successfully completing the program!

I’m one of those people who is more comfortable with 80 monospaced characters endlessly repeated than with a paintbrush. Earlier this year I worked with Sophia Foster-Dimino from the Google doodle team on a doodle celebrating Stanisław Lem, my favorite sci-fi writer and philosopher.

Just like picking the right paintbrush and palette is important for all our doodles, so is figuring out the right technologies and proper user interface for those we want to make interactive. That’s something I’m personally really excited about and that’s why today I wanted to share that excitement and the entire source code of the Stanisław Lem doodle with you – accompanied with an article explaining HTML5 technologies that we used… or didn’t use:

Please note: We are sharing the code of the doodle under the Apache 2.0 License, but the images and animations accompanying the doodle under the Creative Commons BY-NC-SA 3.0 License. The big difference between those two is that the first one allows commercial re-use, whereas the second one forbids it.

Monday, December 19, 2011

Ever wish you could get your students to stop texting and start using their phones productively in the classroom? Do you ever wish for an easy and quick way to measure what your students have learned? If so, you’ll be excited to learn that we recently open-sourced our internal Quiz & Poll App for Android. Developed by our internal learning systems team, “Quiz & Poll” enables educators to engage and challenge their students inside the classroom (using polls) and outside the classroom (using quizzes).

How it works
With Quiz & Poll, teachers & educators can create quizzes and polls easily using Google Spreadsheets. Quizzes and Polls are distributed to students via the Android app or an embeddable webplayer. Statistics data is written back to the spreadsheet so the instructor can track student responses and understanding.

Key Features

Quizzes and polls are easily created and administered on Google Spreadsheets.

Students can download the Android App to take the quiz or live classroom poll.

For students without Android phones, quizzes and polls can be accessed via a web interface (works on laptops, iPhones, iPads etc.).

Administrators can view quiz and poll statistics on the same Spreadsheet.

The quizzing app and leaderboard

How it’s built

The Quiz & Poll application showcases how you can combine several Google technologies to make an easy to use app. The code is useful for developers curious about following technologies and how they interact:

Friday, December 16, 2011

We are almost halfway through the Google Code-in contest and we are excited to announce that over 480 pre-university students from 55 countries have completed a total of 1615 tasks in just under four weeks. The students are working with 18 different open source organizations on a variety of tasks such as quality assurance issues, writing pieces of code, developing materials for outreach efforts, translating documents, and other tasks all related to open source development.

With students from 55 countries this truly is a global program. This year the following 16 countries have their first student participating in the Google Code-in: Algeria, Argentina, Bahrain, Bosnia-Herzegovina, Colombia, Croatia, Honduras, Ireland, Macedonia, Malaysia, Nepal, Puerto Rico, South Africa, South Korea, Sri Lanka, and Venezuela.

Monday, December 12, 2011

SymPy is a computer algebra system (CAS) written in pure Python. The core allows basic manipulation of expressions (like differentiation or expansion) and it contains many modules for common tasks (limits, integrals, differential equations, series, matrices, quantum physics, geometry, plotting, and code generation).

SymPy has participated in the Google Summer of Code program in previous years under the umbrellas of Python Software Foundation, Portland State University, and the Space Telescope Science Institute, where we were very successful. In fact, several of our core developers, including four of the mentors from this year, started working with SymPy as Google Summer of Code students. This was our first year participating as a standalone organization, and we would like to share our experience.

As part of the application process we required each student to submit a patch (as a GitHub pull request) that had to be reviewed and accepted. This allowed us to see that each applicant knew how to use git as well as communicate effectively during the review process.This also encouraged only serious applicants to apply. We had over 10 mentors available and we ended up with 9 students, all of whom were successful at final evaluations.

Tom implemented an algorithm for computing symbolic definite integrals that uses so-called Meijer G-functions. This is the state-of-the-art algorithm for computing definite integrals, and indeed the results of his project are very impressive. This project has pushed SymPy forward a long way to becoming the strongest open source computer algebra system with respect to symbolic definite integration.

Vladimir ported SymPy to work on Python 3 and ported all testing infrastructure so that SymPy gets regularly tested in Python 2.x, 3.2 and PyPy. Thanks to Vladimir’s work, the next version of SymPy, 0.7.2, which will hopefully be released later this year, will work in both Python 2 and Python 3, and it may support PyPy as well.

Gilbert implemented a physics module to assist in generating symbolic equations of motion for complex multibody systems using Kane's Method. He expanded on the code written by his mentor, Luke, in 2009, and the module can now generate equations of motion for a bicycle. Gilbert also wrote very thorough documentation both for the Kane’s Method and the module in SymPy.

Tomo has greatly improved the quantum mechanics module by implementing position/momentum representations for operators and eigenstates in various coordinate systems (including cartesian, cylindrical, and spherical) that allows you to easily represent many of the "textbook" quantum mechanics systems, including particle in a box, simple harmonic oscillator, hydrogen atom, etc.

Saptarshi’s project was to mimic the various capabilities of Combinatorica, a Mathematica package for combinatorics. Most of the functionality involving elementary combinatorial objects such as Permutations, Partitions, Subsets, Gray codes and Prufer codes are complete.

Sherjil improved the speed of the linear algebra module by using efficient coefficient types for values of entries of matrices. Previously, SymPy used generic expressions in this place, which slowed down computations considerably and caused trouble with solving of the zero equivalence problem. He also implemented sparse matrix representation and unified the API with dense matrices. In addition, Sherjil also added a few linear algebra related algorithms (e.g. Cholesky decomposition).

Matthew improved the statistics module to use symbolics and introduced a Random Variable type, with support for finite, continuous, and multivariable normal random variables. With these you can symbolically compute things like probabilities of a given condition, conditional spaces, and expectation values. As a side consequence of this project, he also improved some of our Sets classes and implemented a MatrixExpr class, which allows you to compute with matrices symbolically, including computing with block matrices.

Sean was working on the quantum mechanics module and has implemented symbolic Clebsch-Gordan coefficients, Wigner D function, and related mathematical concepts that are used very often in quantum physics when dealing with angular momentum and then the necessary classes to support coupled spin algebra.

Jeremias worked on implementing algorithms related to Groebner bases. Groebner bases are a useful tool in many areas of computer algebra. He implemented the F5B algorithm, which is an improved version of the classical Buchberger’s algorithm that was previously implemented in SymPy, and an algorithm for converting Groebner bases between different orders of monomials and worked on applications of Groebner bases. This allowed for handling problems of much larger size in SymPy.

The full report can be found here, where each student wrote a wiki page about their experience during the summer and you can also find their blogs and links to applications. Each student was required to blog about their progress each week and all blogs were synchronized at planet.sympy.org.

In previous years, there was usually one student from each summer who became a regular contributor and also a mentor for the next year. It has been a rewarding experience for the whole SymPy community.

Thursday, December 8, 2011

It has become an autumn tradition to host GitTogether, two days of unconference where Git developers, enthusiasts, and users gather at Google’s headquarters in Mountain View, California to share ideas on future directions of Git and to discuss the tools that support the larger ecosystem. This year was no exception. More than 55 people showed up for GitTogether 2011, and one thing that is notable is that at many of the attendees’ $DAY_JOB, the combination of Git on the desktop with Gerrit Code Review on the server side has become the standard set-up to run development work.

Photo by Brandon Casey

Google’s Dave Borowitz gave a talk about the recent addition of Git support to Google Code Project Hosting. Google also recently moved the Git server that hosts the Android open source community from kernel.org to an in-house Git server, which was the topic of Shawn Pearce’s talk. Junio C Hamano briefly described additional workflow elements being designed to help the kernel developers ensure the authenticity of the patch-flow after the recent break-in incident at kernel.org.

Since last year’s GitTogether, submodule support has been heavily enhanced. Jens Lehmann and Heiko Voigt, two Git developers who have been primarily working on the submodule support, gave an overview of where we are and what the future entails. The general direction is to make it easier to run various operations from the top-level superproject and have it go into submodules recursively when the project and the user choose to. There has been interest in using the native submodule support to update the implementation of “repo” wrapper used in Android and other projects. It seems that we are getting closer.

Support for large blobs that would not fit in the memory has been always lacking in Git. There recently has been a lot of work in the native support (e.g. storing them straight to the object store without having to read and hold the whole thing in core, checking out from the object store to the working tree without having to hold the whole thing in core, etc.). There are a few third-party tools and approaches with their own pros-and-cons, but it was generally agreed that adding a split-object encoding like Avery Pennarun’s “bup” tools uses would be the right way to help support object transfer between repositories to advance the native support of large objects in Git further.

The animated diff in Roberto Tyley’s Agit (git running on Android) demo was cool and received warm applause.

In addition to the technical discussions, we had a chance to get to know each other socially, enjoying lunches in the conference room (unlike the previous years, the group has grown too large to visit Google cafes without disturbing other Googlers) and dinners at some local restaurants. True to the tradition, there was a “patch of questionable value” to add different hash algorithm to Git in case SHA-1 hash collisions are found.

Monday, December 5, 2011

Earlier this year OpenMRS participated in Google Summer of Code, a worldwide program organized by Google’s Open Source Programs Office to expose university students to the world of free and open source software, and encourage those students to become long-term contributors to projects that interest them. OpenMRS is a web-based medical record system originally designed for use in the developing world, and is now used on every continent on the globe. OpenMRS is used in all kinds of health care environments, from research laboratories to hospitals to small clinics in remote villages, and even via mobile devices that collect data door-to-door.

OpenMRS has been participating in Google Summer of Code every year since 2007, and our 5th year was arguably our most successful yet. This year, 15 motivated students successfully completed projects to focus or extend the OpenMRS health care IT platform in ways that will have significant impact for our global community of users. Throughout the summer our students became full contributors in good standing in the OpenMRS community. They presented their projects’ work in progress to other developers and users and often contributed their code to our software releases to support health care professionals saving lives around the world. Unlike many other summer internships that students may have during the summer, our students were responsible for planning and delivery of “real-life projects” that came from needs and requests from people installing and using OpenMRS.

Some projects were dedicated to improving the core OpenMRS platform, and some built add-on modules to support specific types of clinical activities. There were projects focused on making the installation of OpenMRS easier, and others focused on helping improve collaboration for our volunteer community. And if the presentations our students made this semester were any indication, all of the projects were exciting ways to write code and save lives. There’s not space here to describe each project in detail, but we encourage you to check out our students and their projects on the OpenMRS Wiki and learn more about them:

Piotr Bryk enhanced our Metadata Sharing module to make it easier to manage the export and import of OpenMRS system configurations.

Rahul Akula’s work helped make it possible for OpenMRS to interoperate with external laboratory information systems.

Sai Manohar Nethi worked to create a framework for a comprehensive Human Resource add-on module for OpenMRS, allowing the system to help manage clinic personnel.

Sreya Janaswamy created a way for OpenMRS users to translate phrases used by the application into other languages, inside the application itself.

Sriskandarajah Suhothayan created a way for the OpenMRS Notifiable Condition Detector module to watch for certain large-scale patterns and send notifications to clinicians via SMS or e-mail.

Suranga Kasthurirathne created a new way for OpenMRS to store clinical observations that reference other people or locations.

Taras Chorny built a system to allow OpenMRS to be installed and upgraded using a variety of languages.

Victor Chircu built an “Atlas” add-on module that allows OpenMRS users to opt-in to report their location, type of clinic, and number of patients on a shared map to represent the active OpenMRS community.

Since we started participating in Google Summer of Code, we’re very proud that so many of our students have stayed active in the OpenMRS community and continued to contribute their talents after the program ended. In fact, three of our students have gone on to become full-time OpenMRS developers paid by various organizations involved in our community.

We continue to be more and more impressed with the students who are interested in our work, and are proud to welcome them into the OpenMRS family! In fact, this year, 2011 Google Summer of Code student Suranga Kasthurirathne was able to join us in October for our annual OpenMRS implementers meeting in Kigali, Rwanda. Suranga provided some excellent feedback about his involvement in Google Summer of Code this year, and about his experience meeting the OpenMRS community face to face. Read his blog post for more of his thoughts.

Once again, this year we were blown away by our amazing students during Google Summer of Code. Thanks to both our students who participated, and our community mentors who gave much of their time and talents to help spread the good work of the OpenMRS community!

By Michael Downey, Google Summer of Code Program Administrator for OpenMRS

Thursday, November 24, 2011

The R programming language has become one of the standard tools for statistical data analysis and visualization, and is widely used by Google and many others. The language includes extensive support for working with vectors of integers, numerics (doubles), and many other types, but has lacked support for 64-bit integers. Romain Francois has recently uploaded the int64 package to CRAN as well as updated versions of the Rcpp and RProtobuf packages to make use of this package. Inside Google, this is important when interacting with other engineering systems such as Dremel and Protocol Buffers, where our engineers and quantitative analysts often need to read in 64-bit quantities from a datastore and perform statistical analysis inside R.

Romain has taken the approach of storing int64 vectors as S4 objects with a pair of R’s default 32-bit integers to store the high and low-order bits. Almost all of the standard arithmetic operations built into the R language have been extended to work with this new class. The design is such that the necessary bit-artihmetic is done behind the scenes in high-performance C++ code, but the higher-level R functions work transparently. This means, for example, that you can:

• Perform arithmetic operations between 64-bit operands or between int64 objects and integer or numeric types in R.• Read and write CSV files including 64-bit values by specifying int64 as a colClasses argument to read.csv and write.csv (with int64 version 1.1).• Load and save 64-bit types with the built-in serialization methods of R.• Compute summary statistics of int64 vectors, such as max, min, range, sum, and the other standard R functions in the Summary Group Generic.

We’ve had to work around the lack of 64-bit integers in R for several years at Google. And after several discussions with Romain, we were very happy to be able to fund his development of this package to solve the problem not just for us, but for the broader open-source community as well. Enjoy!

Mentors began arriving on Friday and in the early evening attended a meet-and-greet party by the hotel pool, where old friendships were renewed and new ones were formed.

Large quantities of Thai food and refreshing beverages were consumed by mentors amid sounds of laughter and some decidedly technical conversations.

Mentors turned in relatively early, as two very full days of excitement lay ahead, and considering the distances many had travelled to attend, sleep was very welcome

Chocolate!

With the success of the chocolate session at last year’s Mentor Summit this year an entire room was reserved for participants to bring their favorite chocolates from their country and share with the group.

The response was staggering! Hundreds of pounds of chocolate from all over the world were brought for everyone to sample. From dark, milk, and white chocolate and lots of chocolate hazelnut goodness to unusual offerings such as fish chocolate (it must be an acquired taste), anything your heart desired resided somewhere in that glorious mound of chocolate.

Picture taken by Robert Kaye

Saturday Highlights

Saturday morning breakfast and lunch at Charlie's Cafe at the Googleplex. Great fuel!

Saturday welcome and unconference session selection process - A surprisingly efficient way to schedule conference sessions, with good humor.

Saturday night back 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 going on in the lounge, in the pool and hot tub, and at tables all 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!

The Google on-site store was open for business both days and many summit attendees loaded up with top quality swag!

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 things we learned about ourselves:

We are part of an incredibly creative, energetic and self-motivated community.

Given minimal structure we are able to create a productive and enjoyable event.

Magic happens when so many passionate, productive FOSS community members meet in one place with the space, time, and infrastructure to network and create together.

We can squeeze a lot of practical work and good fun into just two days.

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."

Monday, November 21, 2011

And we’re off! Starting today, 13-17 year old students enrolled in a pre-university program (high school, etc.) as of November 21, 2011 can begin working on tasks for Google Code-in. The contest introduces students to the world of open source software development by having students claim tasks involving things like translating documents, writing pieces of code, developing materials for outreach efforts, working on quality assurance issues and user interface projects among many other types of tasks. 18 open source organizations will provide mentors for the students as they work through tasks over the next two months.

Students will learn more about the many different activities involved in open source software development while also earning fun prizes during the contest. For successfully completing one task students will receive a certificate of participation and a tee shirt. For completing three tasks students will receive the tee shirt, certificate and 100 USD. Students can receive up to 500 USD when they complete 15 tasks. Each task is assigned a point value and students will receive the prize money, tee shirts and certificates based on the number of tasks they complete, regardless of the point values. Point values will be used to select the grand prize winners. The 10 students with the most points at the end of the contest period will win a grand prize trip to Google’s Mountain View, California campus for themselves and a parent or legal guardian late next spring.

Friday, November 18, 2011

In mid October a Document Summit was held at Google headquarters in Mountain View, California where documentation teams from 4 open source projects, KDE, OpenStreetMap, OpenMRS and Sahana Eden as well as a few documentation ‘free agents’ gathered to a write 4 books in the course of three days and take part in a two day unconference. Below, one of the dedicated documentation volunteers and the FLOSS Manuals founder/organizer recount their experiences over the course of the week.

This past month, Google took a big step toward giving documentation its due with a five-day Google Summer of Code Document Sprint. The event was inspired and driven by FLOSS Manuals, an organization of volunteers (of which I'm one) that has received increasing recognition for its documentation projects and the related community-building they stimulate.

It was predicated on the realization at Google (and at least among pockets of open source developers) that free software needed more than good coders to be successful. It needs communities of people caring for each other and guiding each other through the best use of the software, and part of this community effort is good documentation.

To understand the five-day conference itself (which I wrote about extensively on Radar), you have to know something about FLOSS Manuals and its intense "book sprint" process. FLOSS Manuals was started by artist Adam Hyde several years ago to fill the gap in free software's documentation. From the start it focused not on small articles or wikis but on full manuals. Adam developed the book sprint as a way to pull together a community and get something done quickly that everybody could point to as an achievement for their community.

Five to ten developers, power users, and core supporters meet in a workplace for three to five days and write, sharing their work. Remote contributions are encouraged, and outsiders often weigh in with key points. It's a chaotic process that converges suddenly on the last day into a 80-page to 150-page book, and it leaves a high-endorphin sensation among the participants that propels them toward other community-related activities. Books are frequently translated into other languages, are available both on web sites running FLOSS Manuals software and in print, and are kept "live" so that people can contribute to them later.

My Radar articles contain my own lessons from the Google/FLOSS Manuals sprint. The four projects that participated took back not only a book but guidelines for keeping it alive and capitalizing on the educational and promotional activities that a book permits.

By Andy Oram, O’Reilly Editor

-----

The Google Summer of Code Document Summit was the first of its kind - a special mix of formats with an unconference and book sprint tied together. This promised to be not only intensive and productive but exhausting!

We kicked off the first day of the summit with a one day unconference facilitated by Allen Gunn. It was a great way to get started, we covered many interesting topics related to free documentation. At the end of the day everyone was tired yet inspired. We also started to really come together as a group quite quickly under Allen’s guidance and there were many smiling faces and intensive discussions on the bus back to the hotel.

Day two - start sprinting! Well, the start of an ambitious process - 4 parallel book sprints. Zero to book in 3 days with 4 concurrent projects. I had a pretty good feeling it was going to work, having now done 30 or so sprints, but facilitating 4 sprints concurrently is extra tricky. Thankfully Anne Goldenberg (on the board of the French FLOSS Manuals) was there as I am training her to facilitate Book Sprints. I briefed Anne and she started working through the sprint with the OpenStreetMap team and I began facilitating Sahana and KDE while Allen helped here and there a lot for the first day especially with the generation of the table of contents and oiling the engine for OpenMRS. We also divided the "free agents" (people not affiliated to projects) to the groups.

Well, the rest is more or less the Book Sprint process. Writing, reviewing, discussing, workshopping and using the various tricks and methods developed over the last 3 or so years with this methodology. All went pretty smoothly. We finished 4 great books in 3 days. I think the final word counts were something like 25,000 words or so for each of OpenStreetMap, OpenMRS, and Sahana Eden; 10,000 or so words for KDE.

Laleh Torabi designed some wonderful covers for the books and Tuukka Hastrup was there working on a special new development for Booki (the platform we use for Book Sprints). Tuukka finished the beta and implemented it about 35 seconds before we were planning to use it and he didn’t even sweat!

After dinner on the 3rd sprint day we invited Sahana Eden up to the front of the group and they used the new Booki feature to export the book directly to lulu.com (a print on demand service). Thats right, one push of the button and their book was IMMEDIATELY for sale as a paper book online - it was magic!

The last day was feedback and a debrief unconference facilitated by Allen and then... you thought it had ended? No! The Google Open Source Programs Office team had agreed to get paper books printed so we distributed 20 each of the four *beautiful* books to the mentor summit the next day. All bound and shiny...they looked amazing and set off quite a buzz.

Many thanks to everyone involved. Especially the fabulous Google Open Source Program team.

By Adam Hyde, FLOSS Manuals

With this Document Summit, Google had the opportunity to support 4 important projects and the overarching need for good documentation of free and open source software.

Earlier this month we released the sfntly font programming library as open source. Created by the Google Internationalization Engineering team, the sfntly Java and C++ library makes it easy for programmers to build high performance font manipulation applications and services. sfntly is really, really fast: Raph Levien, Google Web Fonts Engineer, says, "Using sfntly we can subset a large font in a millisecond. It’s faster than gzip'ing the result."

Now, both Java and C++ programmers can use sfntly to quickly and easily develop code to read, edit, and subset OpenType and TrueType fonts. The Google Web Fonts team uses the Java version to dynamically subset fonts, and the Chrome/Chromium browser uses the C++ version to subset fonts for PDF printing.

sfntly (\s-’font-lē\) was built from the ground up to provide high performance, an easy to use API, and both high-level and low-level access to font data. Font objects are both thread safe and high performance while still providing access for editing. After about a year of internal development sfntly is stable enough to move it into open source and share with others.

Currently, sfntly has editing support for most core TrueType and OpenType tables, with support for more tables being added. Using sfntly’s basic sfnt table read and write capability, programmers can do basic manipulation of any of the many font formats that use the sfnt container, including TrueType, OpenType, AAT/GX, and Graphite. Tables that aren’t specifically supported can still be handled and round-tripped by the library without risk of corruption.

sfntly is already capable of allowing many really exciting things to be done with fonts, but there is much more planned: expanding support for the rest of the OpenType spec and other sfnt-container font formats, other serialization forms, better higher level abstractions, and more.

I encourage you to you join us on our journey as a user or a contributor.

Thursday, November 17, 2011

Correction: Students will not be able to start registering for accounts until the contest opens on November 21st at 12:00 am (midnight) PST. The blog below has been corrected. We apologize for any confusion this may have caused.

Every time you send a text, check a webpage or post a status update, you are using open source software. The Internet is made of open source. But have you ever created any yourself? If you’re a pre-university student between 13 and 17 years old, now you can—and win prizes along the way. Our Google Code-in contest starts this coming Monday, November 21. During the contest, which lasts for 57 days, participants can work on cool online tasks for 18 different open source organizations. Possible challenges include document translations, marketing outreach, software coding, user experience research and a variety of other tasks related to open source software development.

Participants earn points for each task they successfully complete and can earn prizes like t-shirts, cash and certificates of completion. The ten participants with the highest points earned by the end of the competition receive a grand prize trip to Google headquarters in Mountain View, Calif. next spring for themselves and a parent or legal guardian. They’ll spend the day getting a tour of campus, meeting Google engineers and enjoying other fun surprises.

Last year’s Google Code-in had 361 students from 48 countries completing 2,167 tasks over the course of the the eight week contest. We hope to have even more students participate this year. Help us spread the word by telling your friends, classmates, children, colleagues, teachers—everyone!

Tuesday, November 15, 2011

We were very excited about participating in the Google Summer of Code this year for the first time. We, the Theoretical Biophysics Groups at the Humboldt University Berlin, pursue scientific research in the field of Systems Biology by the means of computational models. Our focus is on developing techniques and tools incorporating both new and well established knowledge in order to get a better understanding of the fundamentals of life. In particular, we focus on biological processes in Yeast, Bacillus subtilis, and mammalian cells. Our goal has been to develop a web tool that produces an optimized layout for biological reaction networks.

We were overwhelmed by a large number of extraordinary applications from all over the world and had a difficult time in choosing only three students to mentor for the summer, but we were very excited with our choices. Ben Ripkins created a javascript component which can visualize biological networks dynamically in the browser, Matthias Bock created a server component which retrieves biological networks from public databases, and Wei Jing dealt with the graph layout that determines where the network nodes should be located in the final visualization. We were really surprised how far our students were able to carry their projects given the complexity of the tasks. The results of the student’s work went into the biographer project. We have set up two showcases which demonstrate the interplay of the different student projects. At http://cheetah.biologie.hu-berlin.de/networkexplorer a large network compiled from the public databases Reactome and PID can be walked through and by simply clicking on the next node, the view will refocus thereby uncovering further parts of the network. At http://biographer.biologie.hu-berlin.de networks edited from scratch or loaded from several resources are visualized.

To sum it all up, this year's Google Summer of Code was a great success for all of us and we hope to be involved in future editions of the program.

Monday, November 14, 2011

The Desktop Summit 2011 was held in Berlin, Germany, from 6-12 August 2011 and was the second joint conference of the GNOME and KDE communities. Almost 800 attendees gathered in Berlin to review progress, share ideas and work together on various free software projects relating to desktop and mobile user interfaces. While many participants were from Europe as expected, other contingents came from Brazil, India, the United States and beyond. The GNOME Foundation and KDE e.V. sponsored travel and accommodation costs for more than 80 attendees.

Desktop Summit organizers, mostly volunteers, worked for nearly a year to coordinate all the details that made the event successful. More than 50 volunteers pitched in to help the event run smoothly for the week. The collaborative spirit of Free and Open Source technology was an essential factor in how the group worked together.

There was a pre-registration event and two evening parties providing opportunities for people to spend time together without the stress of project deadlines. Other social activities included the traditional soccer and volleyball matches and as participants mostly concerned themselves with having fun (as well as a bit of beer drinking), it was not clear which of the KDE or GNOME teams won. There was an ice cream dessert gathering and unofficial curry cook-outs with food, drinks and conversation--both work and fun.

At the Summit, the City of Berlin announced the winners of its open source competition “Berlin – Made to Create”, a program promoting open source and open standards ideas and solutions. At the same session, the GNOME and KDE communities also announced their outstanding contributors.

From Tuesday to Friday, 85 Birds of a Feather (BoFs) sessions and countless informal hacking sessions took place. Two hacking rooms and the hallways were full of people working on projects. BoFs ranged from small working groups to popular and multi-faceted projects to the introduction of new projects. The GObject Introspection Room shows the kinds of work undertaken at the Summit: a dedicated space with 12 to 20 people at any time, it ran the duration of the Summit, and was primarily focused on bug fixing GNOME API bindings. The KDE community also participated by working on bindings between GObject libraries and Qt/C++ and smoothing out other cross-desktop issues.

The KDE Release Team got together to talk about their strategy for Git versioning migration and the move to Frameworks 5. The BoF session was well attended, and included release team members and downstream packagers. In a short time, the team gathered feedback and came up with a plan for adding predictability to the release team's work and output, and for making the work within the team more effective and sustainable. Working remotely, this would have taken considerably longer and would not have achieved such good results.

The fifth Text Layout Summit was held concurrently with Desktop Summit 2011. At present, there are several font and text shaping technologies and no unified system library. As a result, complex text layout scripts such as Arabic or Myanmar are not well supported, and Western/European fonts often lack advanced text formatting capabilities. As FOSS applications are intended for use by all nationalities and languages, this is a serious shortcoming. Text Layout Summit 2011 made substantial progress toward a common approach, especially with Graphite, which is focused on the minority languages of the world.

The Desktop Summit is an important enabling event, making it possible for teams to learn, share and make substantial progress in their Free and Open Source projects. During the GNOME and KDE Annual General Meetings (AGMs), the respective projects recognized the achievements of members, made important announcements and reflected on the lessons learned over the past year. New Executive Director Karen Sandler led the GNOME AGM, with the recent release of GNOME 3 being a central topic. Many perspectives were contributed, including design, marketing, bug fixes and quality. The location of the 2012 GNOME Users And Developers European Conference (GUADEC) was revealed. With three impressive bids to host GUADEC, La Coruña, Spain, was chosen! The GNOME community looks forward to seeing its members next summer.

At the KDE e.V. AGM, President Cornelius Schumacher presented the work of the Board and KDE e.V. activities of the past 12 months. KDE e.V. organized or helped to organize several successful international conferences such as Akademy 2010 in Tampere, conf.kde.in in India, Camp KDE in San Francisco, and financially supported 21 contributor sprints. Cornelius Schumacher also explained the e.V.'s role in supporting and representing the KDE community in legal issues like domain handling, trademarks and similar areas.

Speaking for both organizations, Lydia Pintscher said, "We consider Desktop Summit 2011 in Berlin to have been a huge success for the collaboration among free software desktop communities. We learned a lot during the first Desktop Summit in Gran Canaria and were able to improve on many big and small things that made a real difference for the conference. We are looking forward to seeing the results of this work and to increased future collaboration."

Friday, November 11, 2011

(CSS is for programming, not for pasting)

When the Closure Tools were first released a little over two years ago, they gave web developers the ability to organize and optimize their JavaScript and HTML in a new way. But there was something missing, namely, a tool to help manage CSS.

You see, the nature of CSS runs contrary to the DRY principle that is exhibited in good software engineering. For example, if there is a color that should be used for multiple classes in a stylesheet, a developer has no choice but to copy-and-paste it everywhere because CSS has no concept of variables. Similarly, if there is a value in a stylesheet that is derived from other values, there is no way to express that because CSS also lacks functions. Common patterns of style blocks are duplicated over and over because CSS has no macros. All of these properties of CSS conspire to make stylesheets extremely difficult to maintain.

To this end, we are excited to introduce the missing piece in the Closure Tools suite: Closure Stylesheets. Closure Stylesheets is an an extension to CSS that adds variables, functions, conditionals, and mixins to standard CSS. The tool also supports minification, linting, RTL flipping, and CSS class renaming. As the existing Closure Tools have done for JavaScript and HTML, Closure Stylesheets will help you write CSS in a maintainable way, while also empowering you to deliver optimized code to your users. We hope you enjoy it! Please let us know what you think in the discussion forum.

Wednesday, November 9, 2011

We are excited to announce the 18 open source organizations we have chosen to participate in this year's Google Code-in contest for 13-17 year old students. Please click on the link to the organization to see their preliminary task list. The organizations will be adding more tasks up until the start of the contest on November 21st.

You can check out our Google Code-in program site for more details about this year's contest. If you meet the eligibility requirements, you can go ahead and register for an account now, so once the contest starts on November 21st you can start claiming and completing tasks right away.

Tuesday, November 8, 2011

Every October in Italy we hold an event dedicated to GNU/Linux and open source software development called LinuxDay 2011 Italy. The event is organized by the Italian Linux Society (ILS) and local Linux User Groups (LUG's). LUG’s hold conferences in many cities spreading the philosophy of "Freedom, as in free speech,” with the goal of popularizing the use and development of open source software.

This year the event was held on October 22nd, and was special because 20 years ago a man named Linus Torvalds made the very first announcement in a mailing list about a new "(free) operating system (just a hobby, won't be big and professional like gnu) for 386(486) AT clones" that was the Linux OS.

My LUG and I have been involved in the organization of LinuxDay in Matera, a beautiful city that is a UNESCO World Heritage site. This year I decided to talk about my experience as a Google Summer of Code student because it has been an awesome experience that has allowed me to both improve my programming skills and to increase my involvement in the open source community. The concept of community is very important for open source development and this is the message I tried to spread through my talk. Many students were present during my speech and asked me for more information about the Google Summer of Code program. I hope my talk will encourage more Italian students to participate in the program in the coming years.

I would like to thank Google for offering us this opportunity and my colleagues who helped organize this wonderful event. Time spent together is always worthy of some sacrifice, we are maybe the last dreamers in the world, believing that changing the world is possible starting from changing ourselves. "Dreaming together a world of Freedom, and working to build it".

Monday, November 7, 2011

In France we say “Jamais deux sans trois” (everything comes in threes, if it's happened twice, it'll happen a third time). Scilab (free and open source software for numerical computation) was happy to keep this saying alive this year as we participated in our third year as a Google Summer of Code mentoring organization. Each year we have been impressed by the growing quality and diversity of projects submitted to us, the involvement of the selected students and the pleasure they have in working in the open source community. Our experience as a mentoring organization in Google Summer of Code shows us that even professional software raises interest amongst students yearning to contribute to its development both on a technical and professional level. For us, this is an acknowledgment of success in our daily work.

We consider our experience this year to be a very positive one as of the 9 selected Scilab projects, 7 have been successfully completed. We chose to focus here on the experience and work of two of our students that seem to be very representative of our Google Summer of Code experience.

CGLAB Module (a CGAL-based extension) by Edyta Przymus

Edyta’s work consisted in providing a binding of CGAL available from Scilab to offer to users of advanced computational geometry functions. Edyta got involved in the Google Summer of Code following the advice of a friend of hers who was one of our students in the 2010 edition of the program. She chose to work on Scilab because she considers it to be essential software in her domain of study: control theory and robotics. Edyta told us that participating in Google Summer of Code was a unique and wonderful experience that gave her a lot of satisfaction. She considers herself a more confident programmer (she wrote her first lines of code only 2 years ago) and has learned to organize her work process and correct her own bugs. She is continuing to work on her project in response to users’ demand and improving her code along the way.

A release of Edyta’s project (tagged as 2.0) has been published in ATOMS (the Scilab module packaging system).

Introduce a Scilab backend to Cantor by Filipe Saraiva

The goal of Filipe’s project was to provide the power of Scilab to Cantor software, a Qt/KDE front end for numerical computing software. Filipe Saraiva worked on the introduction of Scilab and its capabilities as a backend computing engine. Filipe was fond of Scilab since he began using it as an undergraduate. He considers it to be the best free tool available for numerical programming and is proud to have been able to help further its development. He summarizes his experience in the program by saying he learned how important communication is in development work, and that Google Summer of Code was an unique program to learn programming and management in free software communities that he could not find at university.

To achieve his project with success, Filipe worked very progressively. He began by studying the other back ends implemented in Cantor to see how they worked and how he could do the same for Scilab in enabling communication between the two software environments. In the midst of developing all the new needed features, he encountered some difficulties, which pushed him to consider and learn the specifics of the whole ecosystem of his application like kcfg and the processing of XML files in Q.

Since Filipe needed to modify some piece of code in Scilab itself, the Cantor/Scilab connector will not be released until Scilab 5.4.0.

The complete descriptions of all Scilab projects including the five other projects, Binary patching by Stefan Mihaila, Dakota module by Yann Chapalain, Mexlib from Scilab by Luri de Silvio, Accurate and Portable Elementary Functions by Shashank Sahni and .net called from Scilab by Igor Gridchyn are available on the Scilab website.

One of our students told us that working with technology and software used by thousands of people was rewarding. On the same note, having the opportunity to work with such passionate students each year thanks to the Google Summer of Code program is rewarding for us too, and we are thankful to Google for this opportunity.

Friday, November 4, 2011

Simian, the enterprise-class Mac OS X package management solution, released an updated version this week at MacTech. Originally open sourced at Macworld in January by Google, the latest version adds some significant new features. The new version of Simian is available through Google Code with source also available here.

Tuesday, November 1, 2011

The Montreal Summit 2011 turned out to be a very fun and productive gathering earlier this month of GNOME hackers and developers. With the 3.2 release behind us, there was a lot of discussion about the state of GNOME and its path going forward, reflected both in the technical and non-technical sessions that were held.

The group present went through all of the features for GNOME 3.3/3.4 and discussed kicking off the 3.3 cycle which tied in nicely with discussions currently underway on the mailing lists. There were presentations on Baserock by Lars Wirzenius, jhbuild by Colin Walters, and one on the application menu with canonical contributing a good chunk of code toward an improved application menu. A number of sessions talked about GNOME strategy, posing questions such as what are we building, who is it for and how do we get there. There were talks about building an OS, and the various complications that inevitably come up when you put together a system out of many evolving pieces. And Marina Zhurakhinskaya led a talk on how to improve and maximize GNOME’s participation in the Google Summer of Code program.

So much was going on that even though the event wasn’t huge there were many people there that I never even got the chance to talk to and I’m sure there was a lot accomplished that I don’t even know about (for example, Olivier Crete tells me that he made a fix to again allow the use of the free Theora codec for VoIP calls in Empathy). There were also some discussions around how quite a few of this year’s participants were involved in the GNOME Women's Outreach Program.

Monday, October 31, 2011

We’ve been busy compiling some more cool statistics from this year’s 7th iteration of the Google Summer of Code program: enjoy!

This year we had a total of 595 different universities participating in the program, 160 of which were new to the program. The 13 universities with the highest number of students accepted into this year’s Google Summer of Code account for 14.5% of the students. These universities are listed below.

The breakdown of college degrees for the 2011 Google Summer of Code program was as follows: 55% of the students were undergraduates, 23.3% were pursuing their Masters degrees, 10.2% were working on their PhD’s and 11.5% did not specify which degree they were working toward.

For the first time since starting Google Summer of Code in 2005, we asked the participants their gender. (Previously we had “guess-timated” based upon the style of tee shirt they requested). This year we had 7.1% female, 89.3% male and 3.6% that declined to state their gender. In previous years of the program the percentages of women based upon t-shirt requests was as follows: 7% in 2010, 6% in 2009, 5% in 2008, 4% in 2007, 3% in 2006 an 6% in 2005.

Thank you to all of the students for another great “summer” filled with code!