Teyana Taylor - "Google Me"

Going to JavaOne? Sign up for Twitter.

If you already twitter, feel free to skip to the next section. If you've never heard of Twitter, read on and keep your finger on the pulse of JavaOne.

With Twitter, you can broadcast short status updates to your followers and receive updates from people who you follow. It's like having one big instant messaging conversation with all of your friends.

You can access Twitter via SMS. During JavaOne, you can easily keep tabs on your fellow attendees as well as let them know what you're up to, all from just about any cell phone (standard text messaging rates apply).

For example, if you follow me, and I text "free beer at Guice BoF!" to Twitter, Twitter will forward the message on to your phone.

Note: In addition to following someone, you must also enable "device updates" for that person in order to receive their updates via text and instant message.

If you don't have unlimited text messaging, you can always access Twitter via the web or one of the zillion 3rd party Twitter applications.

#javaone

The Twitter world utilizes an ad hoc tagging system called hashtags. It's simple. Tag your JavaOne-related messages by appending "#javaone" to them, and I'll be able to see your update even if I'm not following you yet.

Simply text "track javaone" to Twitter in order to receive any message containing the word javaone from anyone on Twitter, or search for "#javaone" on Summize, a real time Twitter search engine.

Follow Me

I plan to twitter throughout JavaOne. In addition to following me, also check out these Java twitterers:

• JavaOne - The conference itself
• Dan Diephouse - Mule
• Ted Leung - Jython
• Sam Pullara - Yahoo, ex BEA, Gauntlet founder
• Dick Wall - The Java Posse
• Robert Cooper - Author of GWT in Practice
• Roberto Chinnici - Java EE 6 spec. lead
• Dave Johnson - Blogging Roller
• Dion Almaer - Google code evangelist and founder of Ajaxian.com
• Geert Bevin - RIFE, Terracotta
• Mary Smaragdis - Sun marketing director
• Gregor Hohpe - Google, enterprise messaging patterns
• Van Riper - Silicon Valley JUG
• Bob McWhirter - JBoss
• Patrick Chanezon - Google API evangelist
• Mike Cannon-Brookes - Atlassian founder
• Charles Miller - Confluence lead
• Cameron Purdy - Tangosol founder
• Rob Misek - Coherence sales dude
• Mike Loukides - Java editor for O'Reilly
• Alexandru Popescu - InfoQ co-founder
• Kjetil Paulsen - JavaZone
• Stuart Halloway - Relevance, Inc.
• Mark Reinhold - Chief Engineer, Java SE
• James Strachan - Groovy, ActiveMQ, Latrz, etc.
• Kevin Bourrillion - Guice, Google Collections
• Neal Gafter - javac, closures
• Dhanji Prasanna - Warp, author of Manning's Dependency Injection
• Jesse Wilson - Glazed Lists, Guice
• Alex Miller - Terracotta
• Eugene Kuleshov - ASM, Terracotta
• Emmanuel Bernard - Hibernate
• Jason Carreira - WebWork
• Guillaume Laforge - Groovy, Grails
• Sun Developer Network @ JavaOne
• Frank Wierzbicki - Jython
• Charles Nutter - JRuby
• Michael Galpin - eBay
• Jesse Kuhnert - Tapestry
• Jevgeni Kabanov - JavaRebel
• Sam Charrington - Appistry

If you'll be twittering from JavaOne and I didn't mention you above, link to your profile from the comments so others can find you.

Finally, please spread the word about this post and twittering at JavaOne in general. The more people who Twitter from JavaOne, the more fun we'll have!

The Twubble with Twitter

Dion Almaer interviewed me about Twubble for the Google Developer Podcast:

If you use Twitter, Twubble can look at your existing friends' friends and recommend new people for you to follow. It's a stupid simple idea, but I think the execution and fun factor have won people over.

I wrote Twubble in a couple nights of hacking in bed after the kid went to sleep. I used the latest Google Web Toolkit milestone which supports Java 5 (flawlessly from my experience). I was writing Javascript code (server and client side) for years before I ever got into Java, but I have to say, you'd be crazy to write AJAX apps any other way than GWT nowadays.

Statically Typed Foreword

Robbie asked me to write a foreword for his upcoming Guice book. Having never written a foreword before, I Googled, "how to write a foreword," which brought me to two helpful posts from Muse Ink: Foreword Thinking and Foreword March.

Here's what I came up with:

I created Guice in the midst of one of the biggest projects of my career. When you have hundreds of engineers touching millions of lines of code, you come to appreciate the benefits of static type checking. Static types aren't just about compiler errors. In fact, I rarely see Java compiler errors nowadays. Thanks to all that great, formalized Java type information, my IDE helps me write correct code in the first place.

Writing your application in a nearly 100 percent type safe manner, like Guice enables and Robbie advocates in this book, opens the door to a new level of maintainability. You can effortlessly navigate unfamiliar code, jumping from interfaces to their implementation and from methods to their callers. As you master your Java tools, you realize that deceptively simple atomic refactorings combine to form molecular tools, which you can reliably apply to companywide swaths of code, accomplishing refactorings you'd never even consider trying by hand. In the long run, it's much cheaper to ward off bit rot through heavy reuse and constant refactoring than by nuking the world with a rewrite every couple years.

Having experienced Guice's benefits on a number of projects, we at Google knew we couldn't keep it to ourselves and decided to make it open source. Readying Guice for the outside world felt like it took an order of magnitude more work than writing that first internal version, but community contributors like Robbie who fuel the forums, help polish rough edges, and generate excellent documentation like this book pay back that effort tenfold. You'll find that Robbie's brevity and conversational tone suit Guice well. I like my books like I like my APIs: with high power-to-weight ratios.

I focused on static typing because I've gotten a lot of questions about it lately. There's a lot of misinformation out there. For example, some people incorrectly conflate static typing with compiler errors, and, based on that false foundation, they claim that unit testing is an adequate substitute for static typing.

Static typing and unit tests are orthogonal. Static typing doesn't replace unit tests. Unit tests don't replace static typing. In fact, static typing can make maintaining unit tests much easier, especially when paired with the right mocking framework. I certainly believe that scripting languages have their place; beware anyone who tells you that static typing doesn't.

Thanks for the Jolt!

Guice took home the Jolt, a.k.a. the geek Oscar, at an award ceremony hosted by Bob Cringely during SDWest:

The Jolt Awards recognize those products, books, and websites that have "jolted" the industry in the past year. Winners are selected by a panel of judges consisting of industry insiders, columnists, and technology leaders.

I started reading Dr. Dobb's Journal back when I was 12. I regularly bought it off the newsstand at Oxford books in Atlanta and was lucky to understand one article in the entire magazine. I learned much of what I know by reading instead of going to college, so DDJ has been an invaluable resource for me. I remember greatly admiring the Jolt winners each year. I hardly imagined myself among them, especially so soon.

The judges picked three productivity winners and one overall Jolt winner from a pool of six finalists in each category. Guice had some stiff competition; other finalists in the Libraries, Frameworks and Components category included the Eclipse Modeling Project, JasperReports, Qt Jambi, the Spring Framework, and the Zend Framework. Congratulations to the productivity winners: Eclipse, Zend and JasperReports.

Kevin and I had the pleasure of accepting the award on stage, but the truth is, Guice 1.0 is heavily indebted to a lot of people. I can't name you all, but I would like to thank:

• My wife Krista and daughter Dagny for their support
• The Jolt judges for recognizing our hard work
• Kevin Thompson, our manager at the time who gave me the latitude to work on Guice full time
• My mentors Josh Bloch and Neal Gafter
• Cedric and Hani for their treatment of Guice in Next Generation Testing
• The early adopters and contributers who helped steer Guice to 1.0, in random order: Jesse Wilson, Zorzella, Laura Werner, Peter Epstein, Don Brown (Struts 2), Cliff Biffle, Arthur Gleckler
• Brian Slesinsky, for his apt analogies, Eric Burke, for his cartoons, and all the other bloggers who helped popularize Guice
• Robbie for writing a Guice book
• Dhanji for writing a Guice book, and integrating Guice with Hibernate and JPA in Warp Persist
• My parents for instilling a strong sense of type safety at an early age (Thanks for the reminder, kebernet.)

And finally, I'd like to thank Google for its unparalleled commitment to open source. If you haven't tried Guice yet, now is the time.

The trouble with Twitter is...

When it's down, the first thing you want to do is Twitter about it being down. I originally wanted to tell Duncan Davidson how much I love his site design. I'm sure it's been that way for awhile, but I normally only see his RSS feed.

I'm also thinking about picking up the second edition of the Dragon Book. I want to learn more about language design and compilers. I know the Dragon Book has it's shortcomings, but I love that the new edition covers JIT compiling and garbage collection, and I'm really just looking for a foundation, not a definitive reference. I can catch up on the latest and greatest via the ACM.

I guess it would have been hard to fit that into 140 characters anyway.

Update: After reading the Amazon customer reviews, I bought Programming Language Pragmatics instead.

In the hot seat

I sat down for an interview with Carl Quinn during Javapolis, and the video is now up on parleys.com. You can also find an audio-only podcast version on the Java Posse's web site. In it, we talk frankly about:

• The history of and philosophy behind Guice, what problems it solves, how we implemented it, the secret sauce in Guice's stellar performance, and how Guice compares to other approaches.
• How we in the Java community need to take a step back and rethink API and framework design after Java 5 and 6. Reflection heavy and convention based Java 1.4 designs won't fly for much longer. Readability doesn't necesarily mean fewer characters. Java 5 made static type safety a reality and introduced explicit meta data. Java 6 lowered the barriers to compile time code generation, but good documentation of these new features is still much needed.
• The future of Guice and dependency injection in general. I'd like to see dependency injection on mobile devices and deeply integrated into Java SE. One day, many of the problems we're solving in a separate framework will be addressed seamlessly by the core platform, and we'll be free of integration headaches and able to focus on higher level abstractions all around.
• Google Collections, an excellent open source project led by Guice co-lead Kevin Bourrillion. Check it out if you haven't already. Kevin and the rest of the team try to hold the Google Collections to the same standards as the core Java SE Collections, and it shows.
• Weak vs. soft references, which you should use, and specifically when not to use soft references.

Thanks again goes to Carl and Stephan and the rest of the BeJUG team. Javapolis was one of the most fun, inspiring, community-oriented conferences I've been to in a long time. Getting back and forth between your hotel and the conference was a little tricky at times, but the venue itself absolutely rocked.