Diverse Google-APIs werden dichtgemacht, Translate gehört dazu

In den kommen drei Jahren sollen laut http://googlecode.blogspot.com/2011/05/spring-cleaning-for-some-of-our-apis.html eine Reihe von APIs dichtgemacht werden:

Das alles fand ich nicht so tragisch, aber Translate ist heftig in der Diskussion, und Google wird das wohl noch einmal überdenken müssen. Die Google-Antwort (bisher) darauf:

This was a tough decision for us to make; we’re sorry to hear that it’s been a tough one for you to read. Thank you all for your comments, and for reminding us of the passion and energy that you bring to building great products that use our APIs. We launch a lot of APIs, many of them experimental or in Labs. This round of spring cleaning is designed to let us do a better job by focusing more effort on fewer APIs, so that you can continue to count on them. Deprecating the Translate API was the hardest choice for us to make — we’re excited about the global web, and about helping developers and webmasters anywhere reach audiences everywhere. We continue to invest in our Translate offerings, including the Google Translate web element. But the Translate API was subject to extensive abuse — the vast majority of usage was in clear violation of our terms. The painful part of turning off this API is that we recognize it affects some legitimate usage as well, and we’re sorry about that; we hope that our other offerings will cover many of those legitimate use cases.
We are listening, and we really appreciate your thoughtful responses to this post.

Nicht weiter gepflegt werden weiterhin:

Dafür kommen neue APIs dazu:

In 4 Tagen nach der Ankündigung beschäftigen sich über 150 Kommentare mit den Endscheidungen. Ein Kommentar dazu bringt es vielleicht auf den Punkt: “Your new APIs are either pure bullshit or specially aimed to promote your own affiliates.”

Eine Übersicht aller Google-APIs gibt http://code.google.com/intl/de-DE/more/.

Guice 3 mit @PostConstruct = Mycila

Von Spring habe ich mich schon länger verabschiedet und bin für meine clientseitigen Programme auf Guice gewechselt. Bis auf die Tatsache das es keinen automatischen Autoscan gibt, hat mir nichts wirklich gefehlt. Guice unterstützt auch standardmäßig nicht die Common Annotions, aber bei Guice 2 hatte ich http://code.google.com/p/guiceyfruit/ im Einsatz, da das jedoch auf intern Datenstrukturen von Guice 2 zurückgriff, konnte ich nicht auf die neue Version Guice 3 migrieren. Also schmiss ich GuiceFruit raus und suchte eine Alternative. Die gibt es mit dem Projekt http://code.google.com/p/mycila/:


Google Guice contributions:

  • ServiceLoader plugin (enables injection into loaded services)
  • JSR250 supports improved from GuicyFruit
  • Custom Injector with more useful methods which consider the whole Injector hierarchy
  • CachedScope to cache your binding for a specific duration

Neben Mycila Guice gibt es auch noch andere tolle Dinge:

  • Mycila Event
  • Mycila JMX

Google App Engine 1.4.3 veröffentlicht

Siehe http://googleappengine.blogspot.com/2011/03/announcing-app-engine-143-release_30.html. Änderungen in Java:


  • Concurrent Requests: Until now, Java applications relied on starting additional instances to dynamically scale up for higher traffic levels. Now with support for concurrent requests, each application instance may serve multiple user requests at the same time. To start, ensure your application’s code is threadsafe, then enable concurrent requests by adding the <threadsafe> flag to your appengine-web.xml.
  • Java Remote API and Deferred API support: The Remote API andDeferred API libraries have been supported in Python for awhile, and now they can be used with Java, too! The Remote API allows you to perform operations on your application’s datastore from your local machine. This is particularly useful for work that is not well-suited to App Engine’s request/response model. The Deferred API allows users to more easily write and execute ad hoc tasks. Our docs contain more information and examples on how to use the Remote API and Deferred API in Java App Engine.
New and changed APIs
  • Files API: The new Files API in Python and Java allow you to pragmatically read and write data using Blobstore. This API can be used to generate reports, export data, or do anything that your heart desires that requires large, binary objects.


File-IO finde ich spannend, noch toller wäre es gewesen, wenn sich Google an NIO2 halten würde.

Guice 3.0 ist raus

Nach laaaanger Wartezeit ist DI-Framework Guice 3.0 veröffentlicht worden. Von http://code.google.com/p/google-guice/wiki/Guice30 die Neuerungen:

  • JSR 330 support
  • New Persist extension
  • ToConstructor Bindings
  • Better OSGi support (and generally improved support for multiple classloaders)
  • New methods in Binder: requireExplicitBindings & disableCircularProxies
  • Much simpler stack traces when AOP is involved
  • Exact duplicate bindings are ignored (instead of an exception being thrown)
  • Repackaged cglib, asm & guava classes are now hidden from IDE auto-imports
  • Source can be built with Maven
  • General extension & SPI improvements:
  • Scope improvements:
    • Scopes.isSingleton
    • toInstance bindings are considered eager singletons in the Scope SPI
    • Singleton providers that return null are now scoped properly.
    • Fail when circularly dependent singletons cannot be proxied (previously two instances may have been created)
  • Provider Method (@Provides) improvements:
    • Logger dependencies now use named instead of anonymous loggers
    • Exceptions produce a simpler stack
  • Private Modules improvements:
    • If a single PrivateModule is passed to Modules.override, private elements can be overridden.
    • If many modules are passed to Modules.override, exposed keys can be overridden.
  • Multibinder & MapBinder extension improvements:
    • permitDuplicates — allows MapBinder to inject a Map<K, Set<V>> and a Map<K, Set<Provider<V>> and Multibinder to silently ignore duplicate entries
    • Expose dependencies in Stage.TOOL, and return a dependency on Injector (instead of null) when working with Elements.
    • Co-exist nicely with Modules.override
    • Work properly with marker (parameterless) annotations
    • Expose details through the new extensions SPI
  • Servlet extension improvements:
    • Added with(instance) for servlet bindings.
    • Support multiple injectors using ServletModule in the same JVM.
    • Support thread-continuations (allow background threads to process an HttpRequest)
    • Support manually seeding a @RequestScope
    • Expose details through new extensions SPI
    • Fix request forwarding
    • Performance improvements for the filter & servlet pipelines
    • Expose the servlet context (ServletModule.getServletContext)
    • Fixed so a single ServletModule instance can be used twice (in, say Element.getElements & creating an Injector)
    • Fix to work with context paths
  • AssistedInject extension improvements
    • New FactoryModuleBuilder for building assisted factories
    • Injection is done through child injectors and can participate in AOP
    • Performance improvements
    • Multiple different implementations can be created from a single factory
    • Incorrect implementations or factories are detected in Stage.TOOL, and more error-checking with better error messages
    • Work better with parameterized types
    • Expose details through new extensions SPI
  • ThrowingProviders extension improvements
    • Added a new CheckedProviders interface that allows more than one exception to be thrown.
    • Added @CheckedProvides allowing @Provides-like syntax for CheckedProviders.
    • Dependencies are checked at Injector-creation time and during Stage.TOOL, so they can fail early
    • Bindings created by ThrowingProviderBinder now return proper dependencies instead of Injector.
  • Struts2
    • The Struts2 extension now works again! (It worked in Guice 1.0 and was somewhat broken in Guice 2.0)
  • Added to Injector: getAllBindings, getExistingBinding, getScopeBindings, getTypeConverterBindings.
  • Added to Key: hasAttributes, ofType, withoutAttributes
  • Various bug fixes / improvements:
    • Prevent child injectors from rebinding a parent just-in-time binding.
    • Non-intercepted methods in a class with other intercepted methods no longer go through cglib (reducing total stack frames).
    • Allow Guice to work on generated classes.
    • Fix calling Provider.get() of an unrelated Provider in a scoping method.
    • MoreTypes.getRawTypes returns the proper types for arrays (instead of Object.class)
    • JIT bindings left in a parent injector when child injectors fail creating a JIT binding are now removed
    • Overriding an @Inject method (if the subclass also annotates the method with @Inject) no longer injects the method twice
    • You can now bind byte constants (using ConstantBindingBuilder.to(byte))
    • Better exceptions when trying to intercept final classes, using keys already bound in child or private module, and many other cases.
    • ConvertedConstantBinding now exposes the TypeConverterBinding used to convert the constant.