Skip to content

Software Development News: .NET, Java, PHP, Ruby, Agile, Databases, SOA, JavaScript, Open Source

Methods & Tools

Subscribe to Methods & Tools
if you are not afraid to read more than one page to be a smarter software developer, software tester or project manager!

Google Open Source Blog
Syndicate content
News about Google's Open Source projects and programs.
Updated: 3 hours 32 min ago

Haskell Hacking in the Google Zurich Office

Thu, 07/23/2015 - 17:46
The Google Open Source Programs Office recently co-sponsored a three-day hackathon for Haskell, an open source functional programming language. Johan Tibell from Google’s Zurich office talks more about the event below.

On the weekend of May 29th, 120 Haskell enthusiasts got together for the 5th installment of ZuriHac, a yearly open source Haskell hackathon held in Zurich, Switzerland. This year we were back where it all started in 2010: the ground floor of the Google Zurich office.

The schedule was packed solid, and we also put together a complete three day experience for the many beginners in attendance. One room was dedicated to beginner talks and staffed by volunteer mentors (thanks all of you!) that made sure everyone had someone to turn to for questions or just some casual chatting about Haskell. Videos from three of those talks are now online: Monads by Example, Beginning Web Programming in Haskell, and Performance.

The main event featured a mind-bending talk about interesting implementations of sorting algorithms by Edward Kmett (slides) and a deep-dive into writing high-performance binary serialization code by Duncan Coutts (slides).

20150529_131051.jpgWe ran out of whiteboards so we had to use flipcharts!

After the intense hacking sessions, we had organized barbeques down by the Zurich lake. We had a very good turnout, taking over a large part of the park.

2015-05-29 18-38-22.JPGSharing a public barbeque with the locals.

All in all it was a very intense and enjoyable weekend, and we’ll try to organize the event again next year. Perhaps we can beat the current 120 attendee record!
By Johan Tibell, YouTube team

(edited 23 July 2015 with a correct link for the Beginning Web Programming in Haskell video. Thanks to our sharp-eyed reader who commented!)
Categories: Open Source

Google Summer of Code 2015 midterms are here!

Fri, 06/26/2015 - 17:00
Today marks the halfway point of Google Summer of Code 2015. Both students and mentors will be submitting their midterm evaluations of one another through Friday, July 3 as indicated in our timeline. If you would like to read more about these midterm evaluations, please check out the "How Do Evaluations Work?" link on our FAQ.
The next milestone for the program will be the “pencils down” date of August 17, after which students can take a week to scrub their code, write tests, improve calculations and generally polish their work before the firm end of coding on August 21.
There has been fantastic progress made so far, and we encourage all the students, mentors, and org admins to keep up the great work!

by Carol Smith, Open Source Team
Categories: Open Source

Impressions from the European Lisp Symposium, Goldsmith University April 2015

Wed, 06/24/2015 - 22:50
Martin Cracauer is a software engineer for Google’s Travel team and a dedicated Lisp enthusiast. Below, he shares his impressions of the recent European Lisp Symposium.
In April, I attended the 8th European Lisp Symposium in London. It was good to be there and I'm proud to have played a part by giving a talk about unwanted memory retention.

More than anything, I was struck by the professionalism of the performance-oriented Lisp programmers giving talks. The Lisp community has moved beyond fighting with their compilers and settling for a couple useless microoptimizations. At a modern Lisp conference like this one, the same terms used at any other performance computing conference rain down upon the audience. There isn't a generic "probably didn't fit the cache" -- now we talk specific caches and line counts. We don't say "swapping" -- we give specific counts of major and minor page faults and recognize the relative cost of each. We have a deep awareness of what will end up being a system call, and which ones are cheap in which OS.  I had a lot of interest at the 2006 European Common Lisp Meeting by describing how ITA uses Lisp only at compile time and gets full performance at runtime. In 2015, that’s just normal.

There’s still work to do, however. It’s not there yet, but I think Lisp should become the ideal language for both SIMD computing (via new primitives allowing the programmer to tell the compiler instead of relying on arbitrarily smart compilers) and for speculative execution (allow the programmer to make promises and crash if they turn out untrue). I'm always hoping somebody (else) will kick off that effort.

The second thing that struck me was how much people at this conference leverage two of Lisp’s major advantages:

  • compile time computing (having the full runtime language at compile time to expand your compiled code from whatever abstraction is most suitable)
  • and the "commandline", the REPL, inside a high performance language

Several presenters combined those features to construct 3D objects, and even built a bridge between computed 3D objects and interactively built objects (in a graphical editor). One of those sessions was Dave Cooper’s tutorial. Both could create sets of 3D objects that mixed computed objects and interactive building at an astonishing rate.

Breanndán Ó Nualláin’s talk, "Executable Pseudocode for Graph Algorithms", was useful to me because it gave a digestible example of more complex compile time computing. It’s difficult to illustrate the concept, but Breanndán used Lisp’s power as a "programmable programming language" to make a frontend that expresses pseudocode for algorithms in an optimized s-expression syntax. The result is readable, executable, and fast. In addition, you can easily create a backend that targets LaTeX so that you could put your running algorithm in a textbook. This is so useful when trying to understand what the power of a "programmable programming language" really means. Now your LaTex for the algorithms paper is derived from proven working code.

To me, the most jaw-dropping talk of the conference was Christian E. Schafmeister’s "Clasp - A Common Lisp that Interoperates with C++ and Uses the LLVM Backend". The title is the understatement of the year. What is going on here is building tiny 3-nanometer protein-like structures to do useful things like cure cancer and destroy sarin. Although many C++ libraries exist for building such structures, it would be too painful to glue them all together in C++. Instead of feeding C++ through a layer of C and back into some object representation (like the rest of us, cough) Christian presented a Common Lisp implementation running in LLVM, using the LLVM runtime libraries that provide introspection to directly interface to C++. He was kind enough to give the talk again at our Google Cambridge office where it was recorded.

At large scale, Lisp exposes some rough spots. A lot of Googlers like really clean modularization, but Common Lisp packages don't quite provide it. This used to be a big problem for CMUCL, reducing the number of people who could build it. Robert Strandh talked about “First-class Global Environments in Common Lisp”. I am sure people would love to see that in SBCL. I also liked Paul van der Walt's talk, bringing forward ideas to improve restricted runtime environments (such as mobile devices) while keeping them easy to describe in their dependencies.

In my own talk on “Unwanted Memory Retention”, I didn’t just limit the discussion to Lisp, SBCL, and its garbage collector. I addressed group culture and perception bias: how imbalanced performance tradeoffs come about in long-running software projects, how they mix with rapid changes in the computing environment around your Lisp, and how Lisp is just a bit more flexible dealing with them.

This conference was an enlightening experience and I hope slides and videos will become available. For now, many of the topics covered are also discussed in the Symposium’s peer-reviewed papers (16MB PDF). But honestly, just reading doesn't do justice to the conference. People there were great presenters, too, and attending it was inspirational.

by Martin Cracauer, Travel team

2015-06-24 Edited to clarify the subject of Martin's 2006 talk.
Categories: Open Source

Easier provisioning of Google Apps accounts for your domain

Mon, 06/22/2015 - 18:44
Creating a large number of Google Apps accounts (for Work or for Education) can be challenging. Today, we are introducing a new API to generate available usernames and create Google Apps accounts in your domain: Account provisioning for Google Apps. We are releasing the implementation of this API as open source under Google's GitHub organization. It can be installed as a RESTful service or Java library and can be used in a website where users create their own accounts or in a script that creates accounts in bulk.Each user selects and creates their account (included under demos)
Account provisioning for Google Apps uses configurable patterns to generate usernames based on first name, last name and optional custom fields (e.g. second last name). For example: for someone named "Carlos Alvarez Martinez", the pattern [C1_firstname].[lastname][C1_secondlastname] will generate the username c.alvarezm. Further custom fields can be defined (e.g. [studentId]) and a list of patterns can be configured to generate multiple available usernames. In addition, this API caches existent usernames, so it's fast and prevents hitting Admin SDK API limits.Accounts are created in bulk (included under demos)
by Miguel Alvarez, Enterprise team
Categories: Open Source

Google Code-in Wrap-up: Beyond the winners...

Thu, 06/18/2015 - 17:00
To conclude our series of posts about Google Code-in (GCI) 2014, we have an inspiring story from FOSSASIA mentor Praveen Patil. Although we’ve been shining a well-deserved spotlight on the contest winners -- including the two from FOSSASIA -- GCI is also about helping students take their very first steps toward becoming contributors to open source projects. For some students this year, GCI was even more than that: it was a first step toward essential computer literacy and the new possibilities it opens up for them.

December 2014 and January 2015 marked FOSSASIA’s first time participating in Google Code-in (GCI). Attending the FOSSASIA conference in February 2014 was a life-changing experience for me, and I spent the summer contributing to a FOSSASIA-sponsored project during the 2014 Google Summer of Code. Mario Behling and Hong Phuc, the mentors who helped me complete my project, asked me to take part in GCI with them and help pre-university students take their first steps into the world of free and open source software.
Ahead of the contest’s start, I began spreading the word about GCI with presentations at local schools and through online social networks. But when the contest began on December 1st, I noticed that most of my tasks had been claimed by students outside of India and that there was hardly any response from students of my own institute or the neighboring pre-university colleges. The few local students we did see participating were finding it difficult to complete even the beginner tasks, and none claimed any tasks in the coding category. So we began trying to understand why and see what we could do about it.
Ours is a small city in south India and we found that the main reason students weren’t participating was a lack of IT infrastructure in schools. Less than 1% of high school students have access to computers and the internet. They get a chance to learn coding after high school in the 11th standard, but only if they’ve opted to study computer science. In rural India, the situation is even worse. I realized that students are willing to participate in programs like GCI, but most are unable to do so because they lack even basic computer skills.
With suggestions and guidance from Mario and Hong Phuc, we organized a series of workshops at my home for students on every Saturday, Sunday and holiday. The first workshop in the series was “An Introduction to Free and Open Source Software and Google Code-in”. More than 100 students turned out for the session. We also held a session on installing Gnu/Linux and software like Libre Office, Gimp, Inkscape, and more. I was happy to see students engaged with FOSS, learning ‘til late in the evening even though their final exams were approaching.

Our next few workshops focused on using FOSS for documentation, basic image processing, designing, blogging, and an introduction to Python. These interactive sessions helped develop confidence and motivation in our students. More than 70 students registered for GCI! Many said that it was the first time they’d been able to have hands-on experience with computers and that they enjoyed learning and creating.

Many of our friends helped us by providing laptops, internet dongles, a projector, and -- most importantly -- their valuable time. My best friend (and better half) Minal Patil provided snacks for students and helped us conduct the workshops. We even had a GCI session on Christmas Day and celebrated in a different and meaningful way.
It was amazing to see the happiness on the face of students when they completed their first GCI tasks. After starting with no previous hands-on experience with computers, many were able to complete beginner tasks related to documentation and outreach. Some could create blogs and write about themselves and their GCI experiences. And a few students were even able to contribute to our open source project ExpEYES (Experiments for Young Engineers and Scientists) which turns a $35 Raspberry Pi computer into a lab for conducting science experiments. Some students also worked on building a small website about our group intended to give the students an opportunity to experience open source development culture.
It was great fun to learn new things every day along with the students, and it was incredibly fulfilling when the GCI 2014 results were announced on Google’s Open Source Blog. FOSSASIA had more completed tasks than any other participating organization, with 587 tasks completed by 174 students. And our school, Govindram Seksaria Science P.U. College, Belgaum (GSS), ranked #2 among 397 schools worldwide for participation with 49 students completing tasks. The school’s management were happy to learn about our success with GCI, displaying a congratulatory banner on the campus, and they are exploring ways to work with FOSSASIA to continue helping students in our region learn to code and contribute to FOSS.

Participating in GCI with FOSSASIA was a great learning experience for myself also, and I’m very grateful to Hong Phuc, Mario Behling, and the Google Open Source Programs Office. You have inspired me to take up this task of helping kids from this region to learn to code as a lifelong mission. Thanks a billion to all the students who participated in the contest, and I wish them a great future ahead.

by Praveen Patil, GSoC alumnus and GCI mentor
Categories: Open Source

Google Code-in 2014 wrap up with Wikimedia, part two

Thu, 06/11/2015 - 17:00
The Wikimedia Foundation was one of twelve organizations who participated in Google Code-in (GCI) this past December and January, our open source contest for 13 to 17 year old students. Today, grand prize winner Danny Wu tells us about his experience. He was also a GCI winner in 2012 with Fedora.

We all use open source software every day, but although I had contributed patches here and there, I’d never contributed in-depth to a major project before taking part in Google Code-in (GCI). This year, GCI helped me dive into open source development and join the wonderful, helpful, and talented community of Wikimedia.
This year’s contest wasn’t my first time participating in GCI, though. I had completed tasks with KDE and Fedora in the past. But this time, I was intrigued when I saw that Wikimedia -- the non-profit behind Wikipedia and MediaWiki -- was a mentoring organization. Like many people, I've used Wikipedia countless times. I also knew that MediaWiki powers several of the sites I visit. The web-dev nature of Wikimedia sites meant my skills were a good match too.
My first task involved refactoring Citoid, a Node.js service for looking up citation metadata. I was initially a little scared. There are so many established conventions, and everyone seems so busy. What if I make a mistake? I hoped I wouldn't waste anyone's time. Regardless, I followed a guide and set up my development environment for Gerrit code review, then submitted my first patch. My mentor helpfully pointed out some code convention issues (like trailing whitespace). After fixing those, my patch got merged!
I also completed a variety of other interesting tasks like improving extensions, adding internationalization, and working on MediaWiki core. They were fun and I even learned Python through working on pywikibot. More importantly, it was fun to work with my mentors and the other people in the community. Software isn't made in a vacuum -- it’s written by real people with real interests. Being a part of a community is one of the best things about many open source projects. People helped me graciously when I couldn’t figure something out, and I was happy to answer others’ questions on IRC when I could.
I’ve learned a lot through GCI: new tools, the value of code reviews, and even that it’s fine to not know exactly what you're doing at first as long as you're willing to learn! I had a fantastic time and am grateful to have been selected as a Grand Prize winner. I'd like to repeat what Wikimedia mentor Andre Klapper said previously -- thank you!

by Danny Wu, GCI grand prize winner
Categories: Open Source

Google Code-in 2014 wrap up with OpenMRS, part two

Thu, 06/04/2015 - 17:00
OpenMRS is a medical records system used around the world, especially in places where resources are scarce. This past December and January, the OpenMRS community took part in Google Code-in. Today, grand prize winner Parker Erway tells us about writing code during the contest. (We previously featured a story from OpenMRS’ other grand prize winner.)

I’m Parker Erway. I worked with OpenMRS as part of Google Code-in 2014, a contest encouraging kids ages 13-17 to contribute to open source organizations. I’d say it’s working!
OpenMRS itself has a wonderful mission statement: “to improve health care delivery in resource-constrained environments by coordinating a global community that creates a robust, scalable, user-driven, open source medical record system platform.”
I had fun and learned a great deal contributing to OpenMRS. I spent about three weeks on developing an iOS client and its accompanying tasks (adding more features to, documenting, and publishing the app). Although I could have done this faster, I wanted to incorporate every best practice I knew of. One of my favorite things to do is start a fresh new project and try to do everything perfectly. It was great seeing all that hard work and learning pay off, and I’m proud to have made a lasting contribution to the community.
Through six tasks, I also spent time helping to overhaul OpenMRS-ID’s user interface in accordance with their new designs. I had never worked with Node before, and I learned a lot about how partials work, how the asset pipeline works, etc… Other projects I got to work on included deploying OpenMRS to OpenShift and suggesting improvements to the documentation, improving the Modulus search algorithm, correcting bad code practices using Sonar, and fixing a few bugs.
I’d never contributed to a large open source organization before, but I think it’s totally worth it. You meet amazing people doing amazing things, and you get to work with and learn from them. Before working with OpenMRS, I had the impression that large organizations -- even open source ones -- tend to take forever to make changes and review work and such. But once I started, I found that things happened quickly and you could really get stuff done. I truly felt like a member of the community after the contest period, and I’m very grateful to the OpenMRS mentors.
Although I could have completed a larger number of tasks, what’s important to me is that every line of code I write is maintainable, solid, testable (ideally tested as soon as I write it), and in general, good. I want to do good work, not a large amount of mediocre work. Google Code-in has helped cement that concept in me, and I plan to continue contributing to OpenMRS. I hope to see other GCI students stay in the community, too!
by Parker Erway, GCI Grand Prize Winner
Categories: Open Source

Roboto: Google’s signature font is now open source

Tue, 05/26/2015 - 18:00
The Roboto family of fonts, and the toolchain used in creating it, are now an open source project. Roboto is Google’s signature font, created by Google designer Christian Robertson. It is the default font used in Android and Chrome OS, and is the recommended font for Google’s visual language, Material Design.
The font files for the Roboto family of fonts were first released under the Apache license as part of Android 4.0 (Ice Cream Sandwich) in 2011. With this launch, we are making Roboto a true open source project, with a revamped font production toolchain that is completely based on open source software.
Another key improvement in the Roboto font family has been the vast expansion of its character coverage to include all Latin, Cyrillic and Greek characters in Unicode 7.0, as well as the currency symbol for the Georgian lari, to be published in Unicode 8.0. For the expansion, the number of glyphs provided in the fonts more than tripled in number, going from around 13,000 (1071 per font) to more than 40,000 (3350 per font). An earlier version of the expanded font family is included in Android 5.0 (Lollipop) and later.
This project involved close collaboration between various teams at Google: Material Design, Internationalization Engineering, Google Fonts and Android.
The Roboto open source project lives at Bug reports and other contributions are welcome.
By Roozbeh Pournader, Android Text team
Categories: Open Source

Google Summer of Code coding has begun!

Mon, 05/25/2015 - 18:00

Today is the first day of coding for our 11th year of the Google Summer of Code program. This year more than 1,046 students will spend the next 12 weeks writing code for 137 different open source organizations.
We are excited to see the contributions this year’s students will make to the open source community.
For more information on important dates for the program please visit our timeline. Stay tuned as we will highlight some of the new mentoring organizations over the next few months.
Have a great summer!
By Carol Smith, Open Source Programs
Categories: Open Source

Pie in your face — without the mess

Thu, 05/21/2015 - 23:00
Fun Propulsion Labs at Google is back with an exciting new release for game developers. We’ve updated Pie Noon (our open source Android game) to add support for Google Cardboard, letting you jump into the action directly using your Android phone as a virtual reality headset! Select your targets by looking at them and throw pies with a flick of the switch.
Look out for incoming pie!
We used the Cardboard SDK for Android, which helps simplify common virtual reality tasks like head tracking, rendering for Cardboard, and handling specialized input events. And you might remember us from before, bringing exciting game technologies like FlatBuffers, Pindrop, and Motive, all of which you can see in use in Pie Noon.
You can grab the latest version of Pie Noon on Google Play to try it out, or crack open the source code and take a look at how we brought an existing game into virtual reality.
By Anthony Maurice, Fun Propulsion Labs at Google
Categories: Open Source

GSoC 2015 Stats Part 2: Universities

Tue, 05/19/2015 - 23:10
For the second statistics post for Google Summer of Code (GSoC) 2015 we focus on the universities that our accepted students attend. With this being the 11th year of GSoC we have listed the top 11 schools with the highest number of accepted students for 2015. You’ll notice many familiar names on the list with a couple of new additions to the list. Congratulations to the International Institute of Information Technology - Hyderabad for claiming the top spot for the second consecutive year.
UniversityCountry# of Accepted Students in 2014# of Accepted Students in 2015International Institute of Information Technology - HyderabadIndia6962University of MoratuwaSri Lanka4444Birla Institute of Technology and Science, Pilani (BITS Pilani)India2618Birla Institute of Technology and Science Pilani, K.K.Birla Goa CampusIndia2515Budapest University of Technology and EconomicsHungary1214University POLITEHNICA Of BucharestRomania1714Bejing (Peking) UniversityChina513Indian Institute of Technology, BombayIndia1513Indian Institute of Technology (BHU) VaranasiIndia1312National University of SingaporeSingapore1411University of BueaCameroon310
As no surprise, the majority of this year’s students are enrolled in Computer Science, IT and other technical degree programs. GSoC is by no means only for those pursuing CS degrees though — in 2015 we have students pursuing degrees in fields including Astronomy, Geomatics, Law, Music, Oceanography and Philosophy.
A big thank you to all of the professors, schools and alumni who support the Google Summer of Code program. The goal of GSoC is to get students excited about open source development, help build their coding skills and gain real world experience working with open source software projects. We hope that the experience will help them in their careers regardless of the university they attend.
For more statistics on this year’s program check out our country post and be on the lookout for more GSoC 2015 statistics posts in the coming weeks.
By Stephanie Taylor, Open Source Programs
Categories: Open Source

Google Code-in 2014 wrap up with KDE

Thu, 05/07/2015 - 17:00
The KDE community was one of the twelve mentoring organizations which took part in Google Code-in 2014, our open source coding contest for 13 to 17 year old students. Mentor and co-administrator Heena Mahour wrote in to tell us about the students’ accomplishments with KDE.

KDE is an international free software community. We’re best known for the Plasma Desktop which is the default for several Linux distributions, but we produce an entire integrated set of cross-platform applications designed to run on Linux, FreeBSD, Solaris, Windows, and OS X systems. We’re also an umbrella project for many standalone applications based on our technology.
The KDE community participated in Google Code-in (GCI) to inspire young contributors and offer them an opportunity to get involved with KDE and open source. We created 277 tasks for students to choose from, and 29 mentors volunteered to help the students with their work. Of the many projects that are part of KDE, the team behind the Marble virtual globe created the most tasks for us with 50. We also provided 65 different beginner tasks to help students without any experience take their first step as an open source contributor before moving on to more challenging tasks.
Tasks in GCI come in several categories. We offered 190 coding tasks, 26 for documentation and training, and 41 for quality assurance. It was a joy for us to see students working with the mentors and learning how to become part of an open source community. At the end of the contest, 240 tasks had been completed!
Like every organization taking part, we were able to select two students as Grand Prize Winners. From the students who completed the most tasks successfully, we considered the creativity, thoroughness, and quality of their work. Mikhail Ivchenko from Russia and Ilya Kowalewski from Ukraine were selected as our winners and will soon be visiting Google’s headquarters along with the other GCI winners.
We’re all grateful for the opportunity GCI gave us to work with these enthusiastic young students and get them involved with KDE. We hope to continue seeing their names in the future -- keep it up, everyone!

by Heena Mahour, KDE mentor and co-administrator
Categories: Open Source

GSoC 2015 stats part 1: All about the countries

Tue, 05/05/2015 - 17:00
As we gear up for the start of the 11th Google Summer of Code, we’ve been putting together some interesting numbers and stats for this year’s program.  Every year within minutes of the accepted students being announced, we are asked “how many students from my country were accepted?” and “how many students from my school were accepted?” We’ll be answering these kinds of questions with a few posts over the next few weeks, starting today.
Let’s start with our country-specific stats. Last year when we decided to list all of the countries with accepted students it was a huge hit, so why mess with success? The 73 countries represented by this year’s 1,051 GSoC accepted students are listed alphabetically below.
New Zealand2Cameroon12
Philippines2Czech Republic3
Portugal13Dominican Republic1
Russian Federation38Egypt7
Slovak Republic6Finland5
South Korea5France18
Sri Lanka58Greece9
Taiwan2Hong Kong4
United Arab Emirates3Italy19
United Kingdom13Jamaica1
United States127Japan6

We have two countries being represented by students for the first time this year: Kuwait and United Arab Emirates - welcome to the GSoC family! With these two additions, we now have 103 countries where students have been accepted into the GSoC program since 2005.
As you may have seen in recent posts, there are many students and mentors throughout Africa and all around the world working very hard to spread the word about GSoC to their communities. We are happy to announce that Cameroon quadrupled their number of accepted students in 2015 to 12!
In our upcoming posts, we will delve deeper into the stats by looking at the universities with the most accepted students, degrees sought by students, gender numbers, and mentor stats. If you have other questions that you’d like to ask, please leave a comment on this post and we will try to answer your question in an upcoming post.
By Stephanie Taylor, Open Source Programs
Categories: Open Source

Open Location Code: Addresses for everything, everywhere

Thu, 04/30/2015 - 17:00
Accurate street addresses are taken for granted in much of the world. But in many areas, formal street names and addresses don't exist and the only real alternative is to use addresses of the form "behind the old bus stop". Without a street address, it's difficult to organise deliveries, to receive visitors or to find businesses. And street addresses only work where there are named and numbered streets - without these, there's no easy way to provide someone with a location.image03.pngArea with unknown street names in Indonesia. (Google Maps)Latitude and longitude coordinates can specify any location, but they’re long and cumbersome. What if they were more human-friendly, like a very accurate postcode that refers to just your home? We’re happy to share Open Location Code, a stand-alone open source library for this purpose.Open Location Codes are derived from latitude and longitude coordinates, so they already exist everywhere. They are similar in length to a telephone number -- 849VCWC8+R9, for example -- but can often be shortened to only four or six digits when combined with a locality (CWC8+R9, Mountain View).  Locations close to each other have similar codes. They can be encoded or decoded offline, and the character set was chosen to avoid spelling words in more than 30 different languages. We removed similar looking characters to reduce confusion and errors, and because they aren't case-sensitive, they can be easily exchanged over the phone.
image04.pngimage00.pngWorld's largest carrot,
H3+XG Ohakune, New Zealand.The big gumboot.
GV+8J Taihape, New Zealand.
Developers of websites that need location from users (such as delivery or taxi firms in locations where street addresses are poorly defined) could use these codes to get accurate locations from their users. Other services which map locations that don't have street addresses (such as water sources, mountain refuges, or nesting sites) could use these codes since they don't rely on street information.
image02.pngimage01.pngThe big trout.
2W+GW Gore, New Zealand.Kime Hut, in New Zealand's Tararua Ranges.
We have a sample implementation to find and use codes at You can download the latest release of the library from our GitHub page and join our discussion list to learn more.
by Doug Rinckes, Travel team
Categories: Open Source

Students announced for Google Summer of Code 2015

Mon, 04/27/2015 - 20:47

Congratulations to the 1,051 students accepted for our 2015 Google Summer of Code! It was tough for the 137 mentoring organizations to choose from the huge number of applications we received - 6,409 proposals from 4,425 students - and we want to thank everyone who applied.

Accepted students will now enter the community bonding period where they will get to know their mentors and prepare for the program by reading documentation, hanging out in their IRC channel and familiarizing themselves with their new community before beginning their actual coding in May.

If you are interested in learning more about the 137 organizations that the students will be working with during the summer or reviewing important dates, please visit the program website.

We look forward to an exciting and productive summer of coding.
By Carol Smith, Open Source Programs Office
Categories: Open Source

New projects in GSoC 2015

Thu, 04/23/2015 - 17:00
As the summer draws near, we’re getting ready to announce the students accepted into Google Summer of Code (GSoC) 2015. With guidance from mentors, those students will spend their summer coding for one of the 137 open source projects that are participating this year.
This is the 11th summer we’ve run the program and many of the projects have been part of GSoC in the past, but we also have 30 projects which are making their GSoC debut this year. Welcome to GSoC, we’re looking forward to seeing the students’ contributions to your work!
  • Africa Soil Information Service
  • Bika Open Source LIMS Collective
  • Boston University / XIA
  • CentOS Project
  • CloudCV
  • Department of Biomedical Informatics, Stony Brook University
  • Foundation for Learning Equality
  • GitHub
  • Global Alliance for Genomics & Health
  • Google Kubernetes
  • HPCC Systems
  • Liquid Galaxy Project, Interactive Spaces
  • IP-over-P2P Project
  • JdeRobot - Universidad Rey Juan Carlos
  • jQuery Foundation
  • lowRISC
  • MBDyn, Department of Aerospace Engineering at the Polytechnic University of Milan
  • MinnowBoard Project
  • NumFOCUS
  • OncoBlocks
  • Pencil Code Foundation
  • Portable Native Client
  • Red Hen Lab
  • RIOT
  • Rspamd spam filtering system
  • Saros
  • Sustainable Computing Research Group ( SCoRe )
  • University of Nebraska - Helikar Lab

You can learn more about all of this year’s participating organizations at the program website. Students, check back on Monday, April 27th to see if your application has been accepted.
by Ashleigh Rentz, Open Source Programs Office
Categories: Open Source

Jsonnet: a more elegant language for composing JSON

Mon, 04/20/2015 - 17:00
A few months ago, we quietly released Jsonnet: a simple yet rich configuration language (i.e., a programming language for specifying data). Many systems can be configured with JSON, but writing it by hand is troublesome. Jsonnet is packed with useful data-specification features that expand into JSON for other systems to act upon. Below is a trivial example of such expansion:

// Jsonnet Example
   person1: {
       name: "Alice",
       welcome: "Hello " + + "!",
   person2: self.person1 { name: "Bob" },
  "person1": {
     "name": "Alice",
     "welcome": "Hello Alice!"
  "person2": {
     "name": "Bob",
     "welcome": "Hello Bob!"
Jsonnet doesn’t just generate JSON: Jsonnet is also an extension of JSON. By adding new constructs between the gaps of existing JSON syntax, Jsonnet adds useful features without breaking backwards compatibility. Any valid JSON is also a valid Jsonnet program that simply emits that JSON unchanged, and existing systems that consume JSON (or its cousin YAML) can be easily modified to accept data in the full Jsonnet language. As such, Jsonnet is an example of a templating language, but one specifically designed for JSON data and less error-prone than other techniques.“Jsonnet” is a portmanteau of JSON and sonnet. We chose that name to convey that data expressed in Jsonnet is easier to write and maintain because it is more elegant and concise, like a poem. This is not just due to syntactic niceties like comments and permissive quotes/commas, but because Jsonnet has all the modern multi-paradigm programming language conveniences needed to manage complexity. One key benefit is the ability to use Jsonnet's mixin and import features to write modular configuration template libraries, allowing the creation of domain-specific configuration languages for particular applications.Most configuration languages are created ad-hoc for the needs of a given application, accruing features over time and becoming unwieldy. From day one, Jsonnet was designed as a coherent programming language, benefitting from both academic techniques and our experience implementing production languages. Unlike most configuration languages, Jsonnet has a full operational semantics, ensuring matching behavior from third party implementations as well as mathematical analysis. It is a very small and carefully chosen extension to JSON that can express both object-oriented and declarative styles. More importantly, unlike regular programming languages, Jsonnet is hermetic:  Its evaluation is independent of any implicit environmental factors, ensuring that high level configuration will resolve to the same thing every time.Jsonnet is open source. It’s currently available as a library with C and Python bindings, and also as a command line utility. A real-world example configuration can be found on the website, where 217 lines (9.7kB) of Jsonnet expand into 740 lines (25kB) of configuration for other tools. Learn more about Jsonnet by reading the tutorial and experimenting with our javascript demo!

by Dave Cunningham, New York Technical Infrastructure team
Categories: Open Source

Student ambassadors bring GSoC 2015 to more African students

Thu, 04/16/2015 - 14:00
Student applications for Google Summer of Code (GSoC) 2015 closed on March 27th and this year’s mentoring organizations are now busy reviewing student proposals. While we await the results of that process, we’ve been looking at some of the early statistics for this year’s program.
One thing we’re very excited to see is that we received nearly four times as many student applications from Sub-Saharan Africa compared to last year! The gain primarily came from four countries: Cameroon, Kenya, Nigeria, and Uganda. These countries combined had just 45 students apply in 2014, but that number jumped up to 183 this year. Why was the increase concentrated in these locations? There’s a common thread that seems to be responsible: they are places where students active in the Google Student Ambassador (GSA) program organized local GSoC meet-up events.
After lending a hand to a fellow student organizing a meetup in December, GSA Tekang Check brought 77 students together in March at the University of Buea to learn about GSoC and help students apply. Participants from past years shared their experiences and encouraged attendees to submit proposals for projects they felt passionate about.

GSA John Muchiri welcomed over 100 students from St Paul’s University to a GSoC meet-up. The speakers talked about the characteristics good programmers develop and encouraged students to challenge themselves by applying to the program.
At Jomo Kenyatta University of Agriculture and Technology, GSAs Isaac Jumba and Dickson Marienga introduced students to GSoC as part of the local DevFest event which drew over 150 attendees. The session gave an overview of GSoC and encouraged students to sign up for a regional GSoC enthusiasts mailing list.

GSAs Ilo Calistus, Okwara Godswill, and Mgbemena Chike collaborated on a pair of events at the University of Nigeria in Nsukka. The first introduced students to the basics of programming for Android while the second taught students about using Git. Both events also introduced students to the world of open source and encouraged them to take part in GSoC.

At Ekiti State University, GSAs Sadiq Mary Oiza and Alabea Dare Micheal organized a GSoC meet-up for 35 students. After a discussion about current events at the university, the presenters gave an overview of the GSoC program and encouraged students to create profiles on the program website.

GSA James Uzoma organized a meet-up at the Federal University of Agriculture, Abeokuta where 40 students from 6 colleges enjoyed a series of talks featuring stories from fellow Nigerians who had participated in past years, an explanation of the requirements for participating, and some details about the different open source organizations students could apply to work with.
GSA Kagimu Brian brought together 72 students for a GSoC meet-up at Mbarara University of Science and Technology. Attendees learned about the benefits and experiences that can come from taking part in GSoC, along with an introduction to Git.

Only a limited number of students can be accepted in GSoC each year, but we hope to welcome several of the students who attended these events into this year’s program. Accepted students will be notified via email by 19:00 UTC on April 27th, so keep watching your inbox.

By Ashleigh Rentz, Open Source team
Categories: Open Source

UIforETW: Windows Profiling Made Easier

Tue, 04/14/2015 - 17:00
Microsoft’s Event Tracing for Windows (ETW, aka xperf) is an amazing tool for understanding the performance of Windows computers. ETW offers an incredibly deep view into the entire system and allows investigations of complex problems that would otherwise be intractable. It can even be used to record traces on a customer’s machine for later analysis on a developer’s machine, to investigate performance problems that cannot be reproduced locally.

However, the process of recording ETW trace has always been challenging, so we’re pleased to share a new tool we’ve been developing:  UIforETW. This tool brings point-and-click simplicity to recording ETW traces, works around several trace recording bugs, and is a handy dashboard for managing and annotating traces. And since UIforETW is open source, you can add additional features for your own particular needs.

Tracing can be done to a file or to an in-memory circular buffer. Trace compression, high-speed sampling, heap tracing, and other options can be configured with the click of a button. UIforETW lists the recorded traces and lets users rename and annotate them. When you want to analyze a trace, you can launch Microsoft’s trace viewers from UIforETW, and UIforETW will configure improved viewer defaults for WPA.

UIforETW was written by a Chrome developer, so it has a few Chrome specific features. If the Chrome symbol server is enabled, then UIforETW downloads and strips the Chrome symbols in order to avoid a twenty five minute delay when WPA loads the symbols. UIforETW also preprocesses the traces in order to categorize the Chrome processes by type. These features can be turned off in the Settings dialog if you aren’t working on Chrome. While the Chrome specific features will not be needed by most developers, they demonstrate the potential value from custom processing of traces.

UIforETW is a new project but is already being used for production work. More technical details and information about UIforETW and ETW in general can be found in the author's blog post and discussions can be had at our discussion group. Information about contributing to UIforETW can be found in the CONTRIBUTING file in the GitHub repo.
by Bruce Dawson, Chrome team
Categories: Open Source

FlatBuffers 1.1: a memory-efficient serialization library

Mon, 04/13/2015 - 22:51
After months in development, the FlatBuffers 1.1 update is here. Originally released in June 2014, it’s a highly efficient open source cross-platform serialization library that allows you to read data without parsing/unpacking or allocating additional memory. It supports schema evolution (forwards/backwards compatibility) and optional JSON conversion. We primarily created it for games written in C++ where performance is critical, but it’s also useful more broadly. This update brings:

  • an extensive overhaul to the Java API
  • out-of-the-box support for C# and Go
  • an optional verifier to make FlatBuffers practical in untrusted scenarios
  • .proto parsing for easier migration from Protocol Buffers
  • optional manual assignment of field IDs
  • dictionary functionality through binary search on a key field
  • bug fixes and other improvements thanks to 200+ commits from 28 contributors -- thank you!

Download the latest release from our github page and join our discussion list for more details.
By Wouter van Oortmerssen, Fun Propulsion Labs at Google*
*Fun Propulsion Labs is a team within Google that's dedicated to advancing gaming on Android and other platforms.
Categories: Open Source