IT Lesson

What’s the difference between reality and theory? In theory, there is no difference. But reality often imposes unanticipated constraints on developers. These may come in the form of bandwidth restrictions, memory limits, timeouts, or other requirements of the systems that interact with your application.

My team recently built an application that helps us analyze the scheduling and usage of conference rooms at Google. We use the new Calendar API v3 on Google App Engine to read the rooms’ schedules, which we combine with actual occupancy data to calculate utilization and other metrics.

As you might imagine, Google has a lot of conference rooms (I believe the last official count was “more than twelve.”) And many of the rooms seem to be booked fairly solid. That means we need to read a lot of data from Calendar. So much, in fact, that our queries time out if we try to read an entire calendar at once. But the API team anticipated “Google scale” use and designed a mechanism that allows us to retrieve data in batches.

The idea is simple. When you create a request, you specify the page size: the maximum number of results you’d like Calendar to return in one batch. Calendar returns the data you requested, along with an opaque page token, which you can think of as a bookmark. To retrieve the next batch of data, you ask the API for the next page token and include the new token in your next request. The page token keeps track of the results you’ve already seen, so Calendar can send the next batch each time. You repeat this process until you’ve exhausted all the results.

Here’s how we did this in Java:

public void getRoomEvents(String roomEmail) throws IOException {
    // Create a request to list this room’s events (see code, below)
    Calendar.Events.List listRequest = getListRequest(roomEmail);
    do {
      // Retrieve one page of events
      Events events = executeListRequest(listRequest);
      List eventList = events.getItems();

      // Process each event
      for (Event event : eventList) {
        processEvent(event);
      }

      // Update the page token
      listRequest.setPageToken(events.getNextPageToken());

    // Stop when all results have been retrieved
    } while (listRequest.getPageToken() != null);
  }

  // Create a request to list the events for a room
  private Calendar.Events.List getListRequest(String roomEmail)
        throws IOException {
    return calendarClient.events().list(roomEmail)
        .setMaxResults(1000) // Limit each response to 1000 events
        .setPageToken(null)  // Start with the first page of results
        // Return an individual event for each instance occurrence of a
        // recurring event
        .setSingleEvents(true); 
  }

We call getRoomEvents() for each room, using the room’s email address to identify it to Calendar. (You can retrieve events from your own calendar by substituting your own email address.) Then getListRequest() creates a request that we will send to Calendar. The request asks for a list of up to 1000 events from the room’s calendar.

The remainder of getRoomEvents() is a loop that executes the request, processes the results, and updates the page token in preparation for the next request. The loop continues, retrieving and processing each subsequent page of results, until the entire list has been returned. The call to getNextPageToken() indicates the end of the results by returning a null value.

By paginating our requests we avoid timeouts and reduce memory requirements. As an added benefit, each request completes fairly quickly, which means it’s also quick to retry if an error should occur. And finally, a multithreaded application may be able to process one or more pages of results while it retrieves the next, speeding execution. These advantages have led developers at Google to adopt pagination as a best practice. Look for it in our APIs when you need to exchange large amounts of data, and consider adding it to your own services.

If you have questions about our services or APIs, or if you want to see what other developers are doing with Google Calendar, check the discussions and documentation in the Google Apps Calendar API forum.

Adam Liss profile Adam is an engineer who believes that "technical" shouldnt necessarily mean "difficult." He enjoys building infrastructure and tools that make Googlers more productive. Before joining Google in 2010, he built network-security appliances and one of the first wireless application delivery platforms.

<script src="https://apis.google.com/js/platform.js"></script>
<div class="g-additnow" data-applicationid="your-app-id"></div>

Hiranmoy Saha Google+ Hiranmoy Saha is a Software Engineer working on the Google Apps Ecosystem.

Link to article (By Jack J. Phillips, Ph.D.)
"More than 500 impact studies have been conducted or reviewed. Some studies show positive results; others are not so positive?often yielding negative returns on investment. Along the way, we have observed repeat patterns of issues that inhibit or enhance results. In every impact study, the major barriers, obstacles and inhibitors to the transfer of learning are always collected, revealing the impediments to success for a particular program. Even when the program is successful, issues are identified that prevent more impressive results."
Below is a list of the ten (10) top reasons why learning and development has often failed (from the most significant to least significant).

1. Lack of Alignment With Business Needs
2. Failure to Recognize Non-Learning Solutions
3. Failure to Prepare the Environment for Transfer of Learning
4. Lack of Management Reinforcement and Support
5. Inadequate Objectives
6. The Solution Is Too Expensive
7. Regarding Learning as an Event
8. Participants Are Not Held Accountable
9. Lack of Commitment and Involvement From Executives
10. Failure to Provide Feedback and Use Information About Results"

(Conclusion) These 10 issues may be familiar, as they represent critical issues that must be addressed if learning is to live up to expectations and generate appropriate returns for the investment...Results-based learning is a process that must be practiced if learning is to be successful and respected in organizations."

This article is very useful and should be a must for any organization or educational institution thinking about changing or acquiring a new learning solution.

Adam PC- Ipad challenger from India

by Anrab Ghosh, Gaea news network

KHARAGPUR, INDIA (GaeaTimes.com)- Apple is hogging the limelight once again after the launch of its much touted internet tablet iPad but it has a challenger from India. A tablet PC built by an IIT Kharagpur student named Rohan Shravan can give Apple’s cute device a run for its money, provided it gets properly marketed and promoted. He has made an indigenously built Tablet PC named Adam. He has a company named Notion Ink which is going to market the product in the near future. It scores over the Apple iPad with its better battery life and features. The USP of the Adam PC is of course its affordable price tag. The device was unveiled at the Mobile World Congress in Barcelona and the CES in recent times. In both the places it became a show stealer.

The Adam PC addresses the shortcomings that are there in the Apple iPad. The device was in the making for three years and now the inventor is happy with the final product. It has been built to suit the needs of various types of users. The Adam Tablet was slated for a June release. However, some minor issues may delay its release. The company reportedly is working on the Flash support. If this can be incorporated it can offer steep competition to the iPad which presently lacks flash support. The slate can deal with 1080p HD video playback which gives it an edge over most present generation netbooks.

The Adam PC will be released in some variants. All of them are supposed to be cheaper than Apple iPad.

http://gadgetophilia.com/adam-pc-indias-ipad-challenger/