Yesterday, I ventured down to Google's campus for the celebration of the fifth anniversary of the launching of Google Code. It was a relatively eye-opening experience, as they pointed out a lot of things about their hosting system that I hadn't known previously. For example, while the site launched with four projects and two APIs, it's now hosting over 905 projects and 60 APIs. And that's just Google's stuff. End users have uploaded over 300,000 of their own projects to the site, and 26,000 of those were updated in the last month. 

Java is the most popular language used in Google Code projects, with PHP and Python both close behind. What is interesting here is that C++ and C# are dead even at 4% of the overall  projects. There are over 4000 Android applications in Google Code, and over 1000 Eclipse projects. The band, Radiohead, used the service to host its music so that fans could remix their songs, and the source code to the Apollo 11 guidance computer is hosted there as well.

But those are just numbers. What was really interesting to me was the way the Google folks took credit for simplifying online project hosting. And you know what, they're right: they did push open source hosting sites to simplify by offering a streamlined alternative.

How did Google streamline Google Code? For one thing, issue tracking was refined to the same simple interface you'd get when posting a comment to a Web site. Rather than ask bug submitters to post up huge amounts of information and click tons of radio buttons, as is the case in Bugzilla, the Google Code issue tracker submission window is nothing more than a title bar, and a big blank text box in which to describe the issue. 

Elsewhere, Google made it easy to host your project on their site, and took approval and compliance processes out of the system entirely. Sourceforge notably required a lot of hoop jumping back in 2005, and Google decided to ditch these requirements and just allow anyone to host projects there.

Google also took the controversial tactic of restricting license usage on Google Code. They whittled the choices down to the bare minimum, and as a result, over half of the code hosted there is either GPLv2 or GPLv3. A quarter of the projects are under the Apache License, and the rest are a mix of Eclipse, MIT, and a handful of others. As Google engineer, Ben Collins-Sussman put it, if you can't get what you want out of the licenses they chose, you're doing it wrong. He also said that many developers think of legal documents like code: if they compile, you're good to go. This is super wrong, and can get you in trouble. So Google has used Google Code to halt open source license proliferation and dilution.

For the fifth anniversary, Google implemented a Paxos algorithm in the backend of Google Code, so now updates will be instant and reliably replicated. 

If I may be indulged with a moment to brag: I would like to hereby take full and total credit for breaking the Google Phone story back in 2007. Today, Google unveiled its real phone: the Nexus One. As I reported back in October of 2007, this is a real Google-branded phone, made by Google and distributed by the phone carriers. Of course, I got some things wrong in that initial story. I don't now expect that Google will be getting into the wireless carrier game. Also, the Nexus One is notably not based on the X86 architecture, but that's OK. I expect my source from this original story simply got this device confused with specifications for the Google Netbook. 

Thanks for indulging me. You should all feel very cool and hip for reading our humble blog and newspaper. After all, we saw this one coming.

What do all these new phones mean for developers? Well, they mean that mobile application development just got a lot easier. Essentially, there are now only three platforms: Apple, Research In Motion and Android. All those other also-rans are going to slowly vanish from view, or concentrate on non-smart phones. The second wonderful thing about these three platforms is that they all have browsers. Why bother building a native app from three forks of the same code, when you can have a Web app with no code branches?

Finally, with a Google-made phone, we also get Google-made development tools. And I think we can all agree that Google understands developers, perhaps even a little more than RIM and Apple do. 

While Apple is a developer-friendly entity, it's AppStore policies are a source of frequent complaint. Those complaints aren't from users, but from developers who want to distribute their applications therein.

RIM understands its developers, but they are also something of a walled-garden, and that whole single-point-of-failure thing is a big headache sometimes.

So we are left with Google and Nokia. Nokia's ideas are present in the new n900, but it's still a big bag of mobile thingies that aren't quite integrated yet.

That leaves Google. Of GWT, Closure, AppEngine fame.

The European Commission may have accepted Microsoft's concessions to settle its latest antitrust action against the company, but I'm convinced that it will continue to scrutinize the company's behavior.

Microsoft would be wise to avoid further sanctions by thinking ahead. For instance, it should use the EC browser ballot in every edition of Windows worldwide. It should also continue to embrace interoperability.

Whether or not Microsoft is a truly a changed company remains a matter up for dispute. If past is prologue, Microsoft will continue to leverage Windows' dominance wherever possible. But I have come to believe that it now realizes that its customers want to run heterogeneous systems.

Microsoft has talked about "pragmatic interoperability" over the past two years, and has done more to share information about its protocols than ever. That's because it helps it meet its business objectives. The same goes for its newfound interest in open-source software, and Windows Azure's openness.

Last month, it acquired SourceGear's Teamprise solution to allow Visual Studio Team System to be used across platforms as a unified application life-cycle management solution for developers. Some of its biggest customers wanted Eclipse support out of the box, and it was a dealbreaker for them.

Microsoft would have preferred to not acquire Teamprise, instead relying upon its partner ecosystem, but its customers felt antsy about relying on a small vendor's solution. So, after about a year of trying to placate it customers, Microsoft bought Teamprise straight out.

All the evidence that I see points to Microsoft adapting to a changing competitive environment, and interoperability is part of its business strategy. But I also wonder whether it past sins will hinder its competitiveness.

For instance, Google's Chrome OS ties the browser into the operating system, rapidly bringing users to the browser (and Google's Web services). Microsoft cannot follow suit. But I also believe that the EC's antitrust actions against Microsoft led to the rapid innovation that is happening in the browser space.

I hope that the EC recognizes that the industry is changing, and keeps its powder dry for only instances where Microsoft is clearly abusing its Windows monopoly. Otherwise, its competitors could easily cry wolf and slow down its pace of innovation.

On Monday, Google released the first milestone of Google Web Toolkit 2.0. There's a lot of changes in there, and rather than dissect them myself, I'll just post a link to where you can download the actual code. Below are the big changes in this release, as written by Amit Manjhi in this posting, on behalf of the Google Web Toolkit team:

Things that are changing with GWT 2.0 that might otherwise be
confusing without explanation
* Terminology changes: We're going to start using the term
"development mode" rather than the old term "hosted mode." The term
"hosted mode" was sometimes confusing to people, so we'll be using the
more descriptive term from now on. For similar reasons, we'll be using
the term "production mode" rather than "web mode" when referring to
compiled script.

* Changes to the distribution: Note that there's only one download,
and it's no longer platform-specific. You download the same zip file
for every development platform. This is made possible by the new
plugin approach used to implement development mode (see below). The
distribution file does not include the browser plugins themselves;
those are downloaded separately the first time you use development
mode in a browser that doesn't have the plugin installed.

Functionality that will be coming in GWT 2.0
* In-Browser Development Mode: Prior to 2.0, GWT hosted mode provided
a special-purpose "hosted browser" to debug your GWT code. In 2.0, the
web page being debugged is viewed within a regular-old browser.
Development mode is supported through the use of a native-code plugin
for each browser. In other words, you can use development mode
directly from Safari, Firefox, IE, and Chrome.

* Code Splitting: Developer-guided code splitting allows you to chunk
your GWT code into multiple fragments for faster startup. Imagine
having to download a whole movie before being able to watch it. Well,
that's what you have to do with most Ajax apps these days -- download
the whole thing before using it. With code splitting, you can arrange
to load just the minimum script needed to get the application running
and the user interacting, while the rest of the app is downloaded as
needed.

* Declarative User Interface: GWT's UiBinder now allows you to create
user interfaces mostly declaratively. Previously, widgets had to be
created and assembled programmatically, requiring lots of code. Now,
you can use XML to declare your UI, making the code more readable,
easier to maintain, and faster to develop. The Mail sample has been
updated to use the new declarative UI.

* Bundling of resources (ClientBundle): GWT has shipped with
ImageBundles since GWT v1.4, giving developers automatic spriting of
images. ClientBundle generalizes this technique, bringing the power of
combining and optimizing resources into one download to things like
text files, CSS, and XML. This means fewer network round trips, which
in turn can decrease application latency -- especially on mobile
applications.

* Using HtmlUnit for running GWT tests: GWT 2.0 no longer uses SWT or
the old mozilla code (on linux) to run GWT tests. Instead, it uses
HtmlUnit as the built-in browser. HtmlUnit is 100% Java. This means
there is a single GWT distribution for linux, mac, and windows, and
debugging GWT Tests in development mode can be done entirely in a Java
debugger.

Known issues
*  If you are planning to run the webAppCreator, i18nCreator, or the
junitCreator scripts on Mac or Linux, please set their executable bits
by doing a 'chmod +x *Creator'
* Our HtmlUnit integration is still not complete. Additionally,
HtmlUnit does not do layout. So tests can fail either because they
exercise layout or they hit bugs due to incomplete integration. If you
want such tests to be ignored on HtmlUnit, please annotate the test
methods with @DoNotRunWith({Platform.Htmlunit})
* The Google Eclipse Plugin will only allow you to add GWT release
directories that include a file with a name like gwt-dev-windows.jar.
You can fool it by sym linking or copying gwt-dev.jar to the
appropriate name.

Breaking changes
* The way arguments are passed to the GWT testing infrastructure has
been revamped. There is now a consistent syntax to support arbitrary
"runstyles", including user-written with no changes to GWT.  Though
this does not affect common launch configs, some of the less common
ones will need to be updated. For example, '-selenium FF3' has become
'-runStyle selenium:FF3'

As always, remember that GWT milestone builds like this are use-at-
your-own-risk and we don't recommend it for production use. Please
report any bugs you encounter to the GWT issue tracker (http://
code.google.com/p/google-web-toolkit/issues/list) after doing a quick
search to see if your issue has already been reported.

Google Books is an interesting place to spend a summer afternoon. Though those days may be dwindling from our fingers like grains of sand, we can still indulge in that best of summer pastimes: reading. There are over one million books there now. A few interesting sections of this library could consume all the days of the year, were one to endeavor to read them all.

• Linux is a popular topic.
• Mathematics features a number of children's books, in addition to the deeply cerebral.
• There's a healthy helping of Java, too. JavaScript creeps into that search, however, which is good because there seems to be only one Javascript book, according to Google.
• There's some good science fiction in there too.

This morning, a "bug" in Google was posted all over the Internet. You can imagine why this particular bug exists, and some folks at Hacker News are nosing around the theory that it's a result of Google using IEEE floating point arithmetic. That is, of course, just a theory. It should be noted that Microsoft's Bing also has this problem, though at a higher threshold. Wolfram Alpha, as you would expect, seems not to have an issue, though it does eventually dive into scientific notation for the psychotically large numbers you throw at it. 

I'd imagine this is a result of some developmental choice made at Google 10 years ago, and in reality, it's not a very damaging bug. But still, fun stuff!

Google has gone all out to commemorate the 40th anniversary of the moon landing. That's not surprising, considering the deals Google has swung with NASA for corporate jet parking at Moffett Field, next door to Google HQ. Google continues to find cool things to put on the Web that are related to the moon landing. First, a few years back, Google put the moon into its Maps site.

This year, it would seem they've gotten their hands on the code behind the Apollo 11's computer systems. It's been uploaded into Google Code, and it is an ongoing project, encompassing a few things. First, of course, you'll need an emulator for the Apollo Guidance Computer. Then you'll want the code, which is pointed to from this Google Blog Entry. Currently, they're working on the Command Module code (Comanche054) and Lunar Module code (Luminary099). Eventually they'll have syntax highlighting as well.

The fellows who built these systems were professionals, indeed. Only a few non-instructional comments are in this code. No infighting or "#<---kludge" type stuff here. Though at one point, there is a "# NUMERO MYSTERIOSO" that appears in the lunar lander code. At least someone on every team has a sense of humor.

I get a warm fuzzy when I think that their hard work is being remembered and preserved. Of course, I have a soft spot for digital archeology. It's a fascinating field.

 It took me a while to figure it out, but now that I have digested the news Google dropped at Google I/O, earlier this week, I am convinced that we've all been given a glimpse of Google's Macintosh. Google Wave is billed as "Email if it were created today," but I think there's a lot more going on there.

Certainly, e-mail must die. It is an ancient and broken system. But Google's solution introduces a number of new ideas around the concepts of communications and the use of software to facilitate collaboration.

Certainly, collaborative text and document editing is a killer app. It's a great way to get distributed teams working together, and it's been slowly permeating into the collective consciousness over the past few years thanks to Etherpad and other similar sites.

But that's not the crux of what's cool here. I think the neat new special sauce is Google's approach to what it's calling robots. Instead of having oodles of widgets and application triggers, Google bundles up software in Wave as if it were people. If you want to send Mike a message, you drag his picture to the top of the message panel. If you want to have that message translated into French as you type, you drag the icon for the French translation bot into that same panel, and boom! It's as simple as that. Imagine if those Lotus Notes database actions your company creates no longer just sit there in a list window. No, to run a job on a database, you just e-mail it to someone and CC the functions in that e-mail.

That's not quite how it works in Wave, since the idea of CC'ing anything is foreign to this new Google world. We'll all be catching Waves in the future, and with the help of open-source implementations of the Wave server, along with the ability to code up darn near anything and present it as a robot, I'm pretty sure this is going to be a powerful new tool for businesses. In 10 years, I could see large companies abandoning client-side applications in favor of Wave Robots and headless servers.

Imagine a boss signing off on expense reports. Today, you e-mail the boss the reports, he changes some things, sends it back to the accountants, who fix it, then e-mail it back, creating three different versions of the spreadsheet. The Google Wave way to do it is to send the spreadsheet out to all invested parties, then wait while everyone edits the single copy online, in their browser. Throw in a robot called "The Button," and an approve button appears under the spreadsheet. When the boss clicks that button, REST requests are sent off to all of the payment systems that are needed to start the expense checks being cut.

It'll take a while, but I believe the robots concept is akin to the creation of the desktop paradigm for personal computing. It's easily understandable by someone who is not technical, and it embodies GUI practices that developers have been trying to get us all to standardize on for years.

Of course, now Google has to execute on this brilliant vision. I used Google Docs last night and was trying to share some files around with the apprentice group working on new content for the Web culture game, ForumWarz (NSFW), and let me tell you, Google Docs is NOT Google Wave. Sharing a document with 20 or so people is not easy, and I ended up having to fish through old e-mails to find a header that had everyone's e-mail addresses in it to copy/paste that into the Docs sharing window. Not exactly Wave-like.

Watch the keynote speech and decide for yourself if this is Google's Macintosh, or its PC Jr.

Google's I/O developers conference kicked off today in San Francisco. Outside, a giant Google Maps pointer proclaimed that this is the place to be. And for developers interested in Google Web Toolkit, Google App Engine and the retinue of Google APIs, this was definitely the place. In an era when other developer conferences are shrinking, this one was alive with sweaty geekitude and overflowing with wide-eyed developers, sitting on floors and packing the halls.

Though still smaller in personage than developer conferences from Sun, Oracle and Microsoft, Google made up for it by indulging in proclivities that, until recently, only Microsoft had offered. I remember the pomp and swagger of JavaOne back in 2000: Sun rented out rooms at the then Argent Hotel and filled them with Legos, video games and energy bars. They gave away shot glasses and party beads. Not so anymore.

Since those years past, Microsoft began to emulate the bahavior. Though I've never been to a TechEd, I've heard stories of the food and beverages, and lavish parties. Google, it would seem, is now performing the same feats of developer-aimed obsequiousness.

To that end, the company gave all of its attendees today Android G2 phones. They gave one to me as well, though they singled us press out and made us sign waivers declaring we were taking it for preview and reporting use only: It's not the finished product yet.

And while I sit here, gleefully playing with the device, as are oodles of developers at the show, one question looms in my mind: What does the included playlist of songs say about how Google thinks about developers?

Take a look over the short stack of included songs to see what you think:

Kevin Michael -- Ain't Got You 

The lyrics state, simply, that without you, babe, I ain't got nothin'. Double negative aside, it's a lilting love song, declaring a deeply moving emotion: Without its third-party and independent developers, Google ain't got nothing.  

Marcus Miller -- Blast!

A party-type bounce-fest, complete with slap bass, sitar and tabla. A mix of ethnic and electric sounds to produce a worldly blend, obviously intended to highlight the diversity of Google's developer base.

Kid Sister -- Control

Trashy club music, complete with commands for ladies to bend over. Evidently, Google is sexually aroused by its developers. Still, mad props for the cool use of 8-bit distortion sounds as the back-beat. Very C64/Atari.

The Helio Sequence -- Lately 

The Emo song of the bunch. A soulful song of lost love, primarily sung in a voice that is morosely sarcastic. Almost as if Google were apologizing for something. Wrist-slitting music, as is evidenced by the album cover depicting a charcoal image of hands releasing bats into the night.

Kinski -- Punching Goodbye Out Front 

Distortion-filled complexities. Helmet meets a few Pro Tools filters. From the album Down Below It's Chaos, clearly a reference to riding high on the Google application stack. That means consuming API's.

R.A.S. -- SUV 

Evidently, R.A.S. stands for Really Addictive Sound. Might be a hopeful reference to addictive programming tools, but more likely, a reference to technology's love of acronyms.  

The Break And Repair Method -- You Won't Be Able To Be Sad

Weepy acoustic guitar stuff. Clearly a reference to building software: Yes, it sucks to throw it all out and start over, but when it's going again, you won't miss it.

Feel free to take your own inferences from these songs. Due to RIAA and congressional silliness, I can't offer links to these songs, but y'all can in the links... 

And in the tradition of expanding he body of coverage so offered on Google's router plans:

“It's been known for a while that [Google's] custom mesh network has been breaking down. YouTube is largely to blame.”

So says one of my super secret sources. Make of it what you will, I'm not going to festoon it with speculation.

Edward Miller, a stand up fellow, pointed out that Google has been advertising for some interesting jobs recently, as well. He was also kind enough to point out that there are two more recent job postings as well. 

Networking, Hardware Testing Engineer - Mountain View

Networking Software Engineer, Protocols - Mountain View

Networking Software Engineer, Protocols - Mountain View

In those job postings, I really liked this requirement: “Interface with contract manufacturers and production test technicians to resolve issues.”

This one too: “Troubleshoot new board-level computer hardware and electro-mechanical systems and help to evaluate mechanical, electrical, and thermal performance of components and systems.”

Here's another fun one: “Design and develop multiple L2 and L3 networking protocols running on embedded network devices.” Not often you get the chance to design and develop a new network protocol.

All of this is perfectly explained away by Google's already known manufacturing of switches. I wonder if those really cool switches from Juniper were originally built for Google's requests. I bet Juniper knew Google was having switch issues, and it wasn't making switches at the time, so why not put some into research and production? There were tons of reasons to get into switches. I've just got an active imagination.

Again, all of this can easily be written off as the normal requirements for a healthy, growing company. There's no oblique evidence here. Still, we dig deeper to bring you the truth!