MatrixAdapt | Logiciel de gestion d'Entreprise, Création et référencement des sites web

• Measure in milliseconds redux: Meet Speed Tracer - Kelly Norton is back for round two to demonstrate what milliseconds of latency means to end-users, as well as how to identify the sources of latency within your app using Speed Tracer.
  
  
• Faster apps faster: Optimizing apps with the GWT Compiler - Have you ever wondered how you can speed up your GWT compiles? If so, follow along with Ray Cromwell as he delves into this topic, as well as other tips and tricks that you can use to streamline development with GWT.
  
  
• Architecting for performance with GWT - Last year we announced Google Wave, a cutting edge web app that introduces a new way of collaborating and communicating. This year Wave team lead Adam Shuck, and GWT UI guru Joel Webber share with everyone the optimizations both teams use when building GWT-based web apps.
  
  
• GWT Linkers target HTML5 Web Workers, Chrome Extensions, and more - GWT has some extremely interesting technology under the hood, and Matt Mastracci, CTO of dotspots, knows this as well as anyone else. For this year's I/O he provides an overview of GWT linkers, as well as how they created a one that turns a GWT module into an HTML5 Web Worker, and one that generates an HTML App Cache manifest automatically.
  
  
• GWT's UI overhaul: UiBinder, ClientBundle, and Layout Panels - GWT 2.0 shipped with some major UI enhancements that make it very easy to speed up your app, decrease load time, and control layout. In this session, Ray Ryan and Joel Webber show you how these new features interact with one another, and how you can use them to create the most optimal web app.
  
  
• GWT + HTML5 can do what?! If you missed the YouTube video of Quake II running in the browser, this session not only replays it, but goes into great detail as to how the three Googlers actually made it happen using HTML5 features such as WebGL and WebSockets.
  
  
• GWT testing best practices - In 2009, Ray Ryan gave a talk on how to architect a GWT app using the MVP design pattern. This year, Wave's Daniel Danilatos follows-up on Ray's talk, with a detailed overview of how to remove the pain of testing GWT apps using the MVP architecture.
  
  
• Architecting GWT applications for production at Google - If you haven't noticed, it's required that at least one of Ray's talks has the word "Architecting" in it. The good news is that his talks live up to their titles, and this session is no exception. Not only does Ray evolve the concepts discussed in his 2009, "Best Practices for Architecting GWT Apps", he dives into some of the upcoming GWT 2.1 features, and invites Ben Alex, from VMware, on stage to talk about the integration between Spring Roo and GWT.
  

• Appstats - RPC instrumentation and optimizations for App Engine - Guido van Rossum went into detail on how to use Appstats, a new tool for App Engine developers which provides deep insight into why requests are slow and what they’re doing under the covers.
  
  
• Run corporate applications on Google App Engine? Yes we do - Ben Fried (Google’s CIO) and his team joined us to give an update on their progress of moving Google’s corporate applications to App Engine, the problems they ran into, and the success they had. They also announced that two of their apps are now being open sourced for anyone to use.
  
  
• Batch data processing with App Engine - Mike Aizatsky introduced Mapper, a new tool which allows App Engine developers which makes it simple to write code that is run over large datasets such as a Blobstore file or Datastore entities.
  
  
• Data migration in App Engine - Matthew Blain gave a complete introduction to the brand new Bulk Loader which shipped as part of App Engine’s 1.3.4 SDK. The session also provided a look into how to use the Bulk Loader with Java applications and ways to import complex data models from a number of different sources.
  
  
• What's hot in Java for App Engine - The same duo from last year’s introduction of the Java SDK, Don Schwarz and Toby Reyelts, were back again this year to give an update on the progress of the Java SDK. Performance optimizations, compatibility, and new APIs are all covered giving a peak under the hood for Java developers.
  
  
• Building high-throughput data pipelines with Google App Engine - Brett Slatkin reviewed the Task Queue and introduced a number of strategies used to improve the performance of applications doing very high volumes of task queue work. This session is based on lessons learned by Brett while building PubSubHubbub on App Engine.
  
  
• Testing techniques for Google App Engine - Max Ross argued the virtues of proper software testing and then went to detail on how to test your App Engine code properly and how to use App Engine to test all the rest of your code.
  
  
• Next gen queries - Alfred Fuller closed out the conference with a great overview of recent improvements to the Datastore query planner and the new types of queries that are possible, as well as a look at a few features on the horizon.

• Tues June 1: App Engine, GWT
• Wed June 2: Enterprise, Android
• Thurs June 3: Google Chrome, Social Web
• Fri June 4: Tech Talks, Fireside Chats
• Mon June 7: Geo, Google APIs, Google Wave
  

1. Experience starting a company
2. Domain experience and an understanding of the market
3. Balance and different experience than your own
4. Passion about the company vision

• Leo Dirac - Transhumanism Morality
  Why only geeks and hippies can save the world.


• Michael Driscoll - Hacking Big Data with the Force of Open Source
  The world is streaming billions of data points per minute. This is Big Data ? capital B, capital D. But capturing data isn't enough. We need tools to make sense of it, to help us better understand -- and predict -- what we click and consume. We want to make hypotheses about the world. And to test hypotheses, we need statistics. We need R.


• Pamela Fox - My Dad, the Computer Scientist: Growing up Geek


• Tim Ferriss - The Case for Just Enough: Minimalism Metrics
  Looking at how removing options and elements gets better conversions, etc., looking at screenshots of start-ups I'm working with and real numbers. Some humor (I hope) and fun, both philosophical and tactical.


• Nitin Borwankar - Law of Gravity for Scaling
  Why did Twitter have scaling problems? I spent 6 months thinking deeply about this and derived a simple formula that a high school student would understand. It demonstrates where the center of gravity is moving in the "Next Web" and why this aggregation of CPU's is even bigger than Google's. And oh yes, it explains how to build a service that scales to 100 million CPU's.


• Kevin Marks - Why are we bigoted about Social networks?


• Andrew Hatton - Coding against Cholera
  I'll examine what IT life is like on the front line with Oxfam, a humanitarian agency, and how good code can make a real difference to people's lives in all sorts of ways..some of them surprising..


• Robin Sloan - How to Predict the Future
  OK, back in 2004 I made a video called "EPIC 2014," predicting the future of media (and Google). It turned out to be 100% CORRECT. No, just kidding. But it made a lot of people think, which is really the point of talking about the future. Turns out there's a whole professional discipline of future forecasting. And there are certain ways you can think about the future that will give you better odds of being right than others.


• Kathy Sierra - Become Awesome

• Android gets its own IDE: Android Studio, based on IntelliJ IDEA Community Edition.
• Google Play Services 3.1 brings game services, location APIs, Google Cloud Messaging enhancements, and Cross-Platform Single Sign On.
• An updated Google Play Developer Console adds a very cool app translation service, revenue graphs, alpha and beta testing and staged rollouts, optimization tips, and referral tracking.
• We showed off a whole new look for Google Maps and Maps APIs, featuring new base map tiles, a new default marker, a new info window style, and a style refresh for controls.
• In Google Cloud Platform news, we announced that Google Compute Engine is now open to everyone and has sub-hour billing, we’ve added a PHP runtime to App Engine, and we introduced Google Cloud Datastore.
• We showed new Google Wallet features: the Instant Buy Android API, which makes buying in native Android apps fast and easy, and the Wallet Objects API, which lets you connect your loyalty programs, offers and more to Google Wallet.

• New Eclipse tools for Android
• Text= Parameter for Google Web Fonts
• Opening Google Places API for all developers
• Update of Google Prediction API
• New charts and features from Google Chart Tools
• ChromeVox screen reader for Chrome and Chrome OS
• Google Plugin for Eclipse v2.4
• New additions to the Fusion Tables API
• Google Storage open for all
• Promoting and measuring your app with the Guide to the App Galaxy
• Go programming language coming to Google App Engine
• Google App Engine 1.5
• Launch of the Google Tasks API
• Google Books API now in Code Labs

• You could "follow" a developer and see how he codes? I would love to follow Brendan Eich, the creator of JavaScript, as he hacks on TraceMonkey!
• You could do a live code review with someone, and both edit the code in place, a la SubEthaEdit or Google Docs?
• Have a chat session that associates itself with the code files, so you can go back and see the conversations around a bit of code?
• You were told that someone else is editing in the same file so you can quickly commit the code so they have to do the merge :P
• You could search and subscribe to others commands, which will then be automatically updated for you
• And much much more, as you can see on our Roadmap

Cross-posted from the Google Checkout Blog

By Amit Fulay, Product Manager and Mikhail Seregine, Software Engineer

Cross-posted from the Google Apps Developer Blog

Google Tasks helps many of us to remember all those things that keep us busy. Towards the end of last year we asked our users what they wanted to see improved with Google Tasks and an overwhelming request was for the ability to access tasks from anywhere — be it on the move, on the desktop, or through their favorite Web apps.

Today, we’re checking off a big to-do from our list and are inviting you to try out the new Google Tasks API. Using the Google Tasks API, developers can — for the very first time — create rich applications which integrate directly with Google Tasks.

The Google Tasks API provides developers with a powerful set of API endpoints for retrieving and modifying Google Tasks content and metadata. It offers a simple, RESTful interface and supports all basic operations required to query, manage and sync a user’s tasks and task lists. The API uses JSON for data representation and works with multiple authentication mechanisms including OAuth 2.0.

POST /tasks/v1/lists/<list-ID>/tasks
Content-Type: application/json
...
{ title: "Publish blog post" }

Task task = new Task();
task.setTitle("Publish
    blog post");
client.tasks.insert(
    "list-ID",
    task).execute();

• Producteev is a task management platform that lets teams and individuals access their to-dos from a lot of different locations (web, mobile, email, calendars...). You will now have all your Producteev's tasks available in Google Tasks and vice versa!
• Mavenlink's project collaboration suite allows you to communicate, share files, track time, invoice, and make or receive payments in one place. With its Google Tasks integration, your Mavenlink project tasks & Google Tasks always stay in sync.
• Manymoon is the top installed social task and project management app in the Google Apps Marketplace and makes it simple to get work done online with co-workers, partners, and customers. Manymoon's users can now create and view tasks with Gmail and Google Calendar through Google Tasks.
• Zoho offers a suite of online business, collaboration and productivity applications for small businesses. So far they have integrated Zoho CRM & Zoho Projects with the Tasks API.

Want to weigh in on this topic? Discuss on Buzz

Posted by Fabian Schlup & Nicolas Garnier Google Tasks API Team

• The ability to stream data and tune your predictive models
• A forthcoming gallery of user-developed, pre-built models to add smarts even faster.

• Recommend a new movie to a customer.
• Identify most important customers.
• Automatically tag posts with relevant flags.

• Streaming training data: Continually incorporate feedback for fast-adapting systems (e.g. user-chosen tags vs predicted ones, final purchases vs expected).
• General availability: Anyone can now sign up to use the API. Paid users also receive a 99.9% SLA with increased quota.
• New JavaScript library: Now deploy the Prediction API in your JavaScript – in addition to our updated Python and Java libraries.

• Subscribe to others’ models: improve your apps with others’ predictive data tools.
• Sell access to your models (e.g. sentiment analysis on social media).
• Import customized models through the open-standard PMML encoding.

One of the most exciting aspects of Google's Android platform is the rapid release pace, so support for cutting-edge technologies can be included in the platform early on. As engineers, we're excited about such features, because we like to tinker and test the limits of new technologies. But the real challenge is using these new capabilities to integrate easy-to-use features for end-users, so that everyone can be excited. The introduction of the Near-Field Communication (NFC) API in Android 2.3, accompanying the release of an NFC hardware feature in Google's Nexus S, gave us the opportunity to do just that.

NFC is meant to send and receive small amounts of data. This data can be read from passive (non-powered) devices (e.g. credit cards or interactive posters), or active devices (e.g. payment kiosks). NFC can also be used to communicate between two NFC-equipped devices thanks to a protocol introduced by Google which defines a way for two active devices to exchange NFC messages that follow the NFC Data Exchange Format (NDEF) specification. This protocol (NDEF Push Protocol (NPP)) is implemented in Android 2.3.3 and beyond.

The NPP is very simple: it allows us to send an NDEF message to another device, which will then process the message as if it had been read from a passive tag. Thus, to understand how to use NPP, we need only to understand the NDEF message. An NDEF message is a collection of NDEF records. An NDEF record is a short header describing the contents of the record’s data payload, and then the data payload.

This new NFC/NPP capability enables the exchange of a few hundred bytes of information in a well-defined format between devices, using proximity as a method for instigation and authentication. In other words, we can now share a small amount of data between two devices without going through the normal steps of pairing or association that are required by more conventional (and higher-bandwidth) avenues like Bluetooth or WiFi—the fact that the two phones are in close proximity is enough evidence to convince the NFC software that the devices are eligible to receive information from each other.

The NFC API for Android handles all of the details of receiving and parsing NFC messages. It then decides what to do with the message by investigating the intent filters registered for applications on the device. In some cases the messages may have characteristics that can lead to finer-grained dispatching. In the case of an NDEF message, you can register for NFC messages at varying levels of detail: from as vague as any NDEF message to as detailed as an NDEF message containing a URI matching a given pattern. A pleasant result of this approach is that the operating system can have "catch-all" applications for messages that have unknown details.

Let’s consider a possible application of the NFC technology in the context of the doubleTwist app. If you’re listening to a song and you want to share the details of the song with your friend, how can NFC help with this? Well, we can use NFC to bundle up a small bit of information about the song in a well-defined format, which the other phone can then parse and use to display information about the song. We will pass the metadata in a single NDEF Record containing a JSON object.

To ensure that our message is routed to doubleTwist on the receiving phone, we rely on Android's ability to dispatch messages based on the data type of the payload, signaled by setting the the type name field to TNF_MIME_MEDIA. This indicates that the type field of the NDEF record should be a MIME type as specified by RFC2046. To take advantage of this capability, we create our own custom MIME type to use in the type field. Since the NDEF message must be composed of bytes, we’ll also need to convert the strings into byte arrays. The code for all of this looks like this:

//Assume that musicService is an interface to our music
  //playback service
  JSONObject songMetadata = new JSONObject();
  String title = musicService.getCurrentTrackTitle();
  String artist = musicService.getCurrentTrackArtist();
  String album = musicService.getCurrentTrackAlbum();
  songMetadata.put(“title”, title);
  songMetadata.put(“artist”, artist);
  songMetadata.put(“album”, album);

  String mimeType = "application/x-doubletwist-taptoshare";
  byte[] mimeBytes = mimeType.getBytes(Charset.forName("UTF-8"));
  String data = songMetadata.toString();
  byte[] dataBytes = data.getBytes(Charset.forName("UTF-8"));
  byte[] id = new byte[0]; //We don’t use the id field
  r = NdefRecord(NdefRecord.TNF_MIME_MEDIA, mimeBytes, id, dataBytes);
  NdefMessage m = new NdefMessage(new NdefRecord[]{r});

Similarly, our application registers an Intent filter to define the Activity that will handle NFC messages that match this mime type. So, when another phone running doubleTwist receives our message, doubleTwist will have priority in processing the message. To do this, we add an <intent-filter> element to AndroidManifest.xml's entry for the activity that should launch to handle this NDEF message:

<activity name="SongInfoShare">
    <intent-filter>
        <action android:name="android.nfc.action.NDEF_DISCOVERED" />
        <data android:mimeType="application/x-doubletwist-taptoshare" />
        <category android:name="android.intent.category.DEFAULT"/>
    </intent-filter>
</activity>

The SongInfoShare activity will be started whenever the NFC radio receives our special message from another NFC-capable phone. In the onCreate method for this activity, we can check the action for the intent that started to activity to verify that it’s the NDEF_DISCOVERED action, and then use the normal intent helper methods to get the NFC message data from the Intent. Here’s what the code will look like for our info-sharing example:

public class SongInfoShare extends Activity {
  …
  public void onCreate(Bundle b) {
     if(android.nfc.ACTION_NDEF_DISCOVERED.equals(getIntent().getAction()) {      
        Parcelable[] msgs = 
            b.getParcelableArray(NfcAdapter.EXTRA_NDEF_MESSAGES);
   if(msgs != null && msgs.length > 0) {
               NdefMessage m = (NdefMessage)msgs[0];
               NdefRecord[] r = m.getRecords();
               JSONObject sharedInfo = null;
               if(r != null && r.length > 0) {
               try {
                   String payload = new String(r[0].getPayload());
                   sharedInfo = new JSONObject(payload);
               } catch (JSONException e) {
                   Log.d(TAG, "Couldn't get JSON: ",e);
               }
          }

   //At this point, we can use the contents of 
   //sharedInfo to set up the contents of the activity.

So, now we’re able to easily pass along song information to a friend by simply bringing the NFC radios close together. No cutting, pasting, tapping, or searching for options in menus!

So, what happens if our friend isn’t running doubleTwist? Well, the stock Android NFC handler app can help us. It will display any text or link records contained in the NDEF message it receives. So, for example, we can also share a pre-formatted link that will do a Google search for the song information. To achieve this, we can modify the end of our first code example as follows:

r1 = NdefRecord(NdefRecord.TNF_MIME_MEDIA, mimeBytes, id, dataBytes);
String query = UrlEncoder.encode("\""+artist+"/" /""+title"\"", "UTF-8");
String searchLink = "http://www.google.com/?q="+query;
byte[] searchBytes = data.getBytes(Charset.forName("UTF-8"));
NdefRecord r2 = new NdefRecord(
      NdefRecord.TNF_ABSOLUTE_URL, searchBytes, id, searchBytes);
NdefMessage m = new NdefMessage(new NdefRecord[]{r1, r2});

Now, in the case where the receiving user doesn’t have doubleTwist installed, they will at least be presented with a link that they can click on to begin a Google search for more information about the song.

The first version of Google’s NDEF Push Protocol API has allowed us to bring some novel enhancements to our app using one of the newest available handset technologies. We are looking forward to further development of device-to-device NFC APIs that will allow even richer inter-device communication using just a tap!