Commons Codec provides implementations of common encoders and decoders such as Base64, Hex, Phonetic and URLs. Codec was formed as an attempt to focus development effort on one definitive implementation of the Base64 encoder. At the time of Codec's proposal, there were approximately 34 different Java classes that dealt with Base64 encoding spread over the Foundation's CVS repository. Developers in the Jakarta Tomcat project had implemented an original version of the Base64 codec which had been copied by the Commons HttpClient and Apache XML project's XML-RPC subproject. After almost one year, the two forked versions of Base64 had significantly diverged from one another. XML-RPC had applied numerous fixes and patches which were not applied to the Commons HttpClient Base64. Different subprojects had differing implementations at various levels of compliance with the RFC 2045. Out of that confusing duplication of effort sprang this simple attempt to encourage code reuse among various projects. While this package contains a abstract framework for the creation of encoders and decoders, Codec itself is primarily focused on providing functional utilities for working with common encodings.

When writing a library it is very useful to log information. However there are many logging implementations out there, and a library cannot impose the use of a particular one on the overall application that the library is a part of. The Logging package is an ultra-thin bridge between different logging implementations. A library that uses the commons-logging API can be used with any logging implementation at runtime. Commons-logging comes with support for a number of popular logging implementations, and writing adapters for others is a reasonably simple task.
Applications (rather than libraries) may also choose to use commons-logging. While logging-implementation independence is not as important for applications as it is for libraries, using commons-logging does allow the application to change to a different logging implementation without recompiling code.
Note that commons-logging does not attempt to initialise or terminate the underlying logging implementation that is used at runtime; that is the responsibility of the application. However many popular logging implementations do automatically initialise themselves; in this case an application may be able to avoid containing any code that is specific to the logging implementation used.

Apache Harmony is the Java SE project of the Apache Software Foundation. Please help us make this a world class, certified implementation of the Java Platform Standard Edition!

The aim of the project is to produce a large and healthy community of those interested in runtime platforms tasked with creation of:
• A compatible, independent implementation of the Java SE 5 JDK under the Apache License v2
• A community-developed modular runtime (VM and class library) architecture.

We aim to support wide range of different platforms. The main criteria for whether a particular platform is supported or not is the involvement of people in running tests on regular basis, reporting build status, finding and fixing bugs for that platform, and so on.

The Hyper-Text Transfer Protocol (HTTP) is perhaps the most significant protocol used on the Internet today. Web services, network-enabled appliances and the growth of network computing continue to expand the role of the HTTP protocol beyond user-driven web browsers, while increasing the number of applications that require HTTP support. Although the java.net package provides basic functionality for accessing resources via HTTP, it doesn't provide the full flexibility or functionality needed by many applications. The Jakarta Commons HttpClient component seeks to fill this void by providing an efficient, up-to-date, and feature-rich package implementing the client side of the most recent HTTP standards and recommendations. See the Features page for more details on standards compliance and capabilities. Designed for extension while providing robust support for the base HTTP protocol, the HttpClient component may be of interest to anyone building HTTP-aware client applications such as web browsers, web service clients, or systems that leverage or extend the HTTP protocol for distributed communication. There are many projects that use HttpClient to provide the core HTTP functionality. Some of these are open source with project pages you can find on the web while others are closed source that you would never see or hear about.

The Hyper-Text Transfer Protocol (HTTP) is perhaps the most significant protocol used on the Internet today. Web services, network-enabled appliances and the growth of network computing continue to expand the role of the HTTP protocol beyond user-driven web browsers, while increasing the number of applications that require HTTP support. Designed for extension while providing robust support for the base HTTP protocol, the HttpComponents may be of interest to anyone building HTTP-aware client and server applications such as web browsers, web spiders, HTTP proxies, web service transport libraries, or systems that leverage or extend the HTTP protocol for distributed communication.

The overall goal of this project is to make an implementation of the Bluetooth. wireless standards specifications for Linux. The code is licensed under the GNU General Public License (GPL) and is now included in the Linux 2.4 and Linux 2.6 kernel series.

The Bouncy Castle Crypto APIs for Java consist of the following:
• A lightweight cryptography API for Java and C#.
• A provider for the Java Cryptography Extension and the Java Cryptography Architecture.
• A clean room implementation of the JCE 1.2.1.
• A library for reading and writing encoded ASN.1 objects.
• A light weight client-side TLS API.
• Generators for Version 1 and Version 3 X.509 certificates, Version 2 CRLs, and PKCS12 files.
• Generators for Version 2 X.509 attribute certificates.
• Generators/Processors for S/MIME and CMS (PKCS7/RFC 3852).
• Generators/Processors for OCSP (RFC 2560).
• Generators/Processors for TSP (RFC 3161).
• Generators/Processors for OpenPGP (RFC 2440).
• A signed jar version suitable for JDK 1.4-1.6 and the Sun JCE.

The lightweight API works with everything from the J2ME to the JDK 1.6 and there is also an API in C# providing equivalent functionality for most of the above.

Google Apps and its APIs open up a wide variety of new opportunities to integrate and extend Google's communication and collaboration services. Domain adminstrators can use the APIs to migrate from and integrate with existing IT infrastructure. Application developers and systems integrators can use the APIs to extend, customize, and integrate Google's growing offering of services.

Integrate Google Apps with existing systems:
• Programmatically synchronize with a user directory
• Take full control over authentication of users and leverage a single sign-on system
• Seamlessly replace an existing calendar application without missing a meeting
• Meet regulatory compliance, data retention, and message content policy requirements

Extend and customize Google Apps:
• Create a dynamic start page gadget to provide easy access to essential information
• Publish calendar event information into a custom display
• Create a data driven application that persists to a spreadsheet
• Bring real time presence, messaging, and voice into client applications

Google Calendar offers many ways to create and share content other than the web interface that we all know and love. Developers can leverage the Google data protocol to build applications that access all the functionality of Google Calendar. You can add Google's familiar look and feel to your site by embedding Google Calendars and published events. Or put your mark on the Google interface by creating Calendar Gadgets that users can add to their own Google Calendars!

Calendar Data API

Google Calendar allows client applications to view and update calendar events in the form of Google Data API feeds. Your client application can use the Google Calendar Data API to create new events, edit or delete existing events, and query for events that match particular criteria. You might use the API to: create a web front end to let people view their Google Calendar information from within your site; publicize upcoming events by programmatically adding them to Google Calendar; build an application to sync between Google Calendar and mobile devices; or create mashups with other APIs like Google Maps.

Calendar Tools

Here are some cool tools available from Google Calendar.

Embeddable calendars

Generate an interactive HTML version of a Google Calendar and embed it in any webpage with the Embeddable Calendar Helper Tool.

The Google data APIs provide a simple standard protocol for reading and writing data on the web. These APIs use either of two standard XML-based syndication formats: Atom or RSS. They also have a feed-publishing system that consists of the Atom publishing protocol plus some extensions (using Atom's standard extension model) for handling queries.

The Google Maps API lets you embed Google Maps in your own web pages with JavaScript. The API provides a number of utilities for manipulating maps (just like on the http://maps.google.com web page) and adding content to the map through a variety of services, allowing you to create robust maps applications on your website.

The Google Spreadsheets Data API allows client applications to view and update Spreadsheets content in the form of Google Data API ("GData") feeds. Your client application can request a list of a user's spreadsheets, edit or delete content in an existing Spreadsheets worksheet, and query the content in an existing Spreadsheets worksheet.

Here are some of the things you can do with the Spreadsheets Data API:

• Use a spreadsheet as a database and access data for another application via the Spreadsheets Data API.
• Use an external graphing library with the Spreadsheets Data API to add nice looking graphs to your site.
• Implement auto-filtering and other spreadsheet functionality in an application you build for your users.

ICU is a mature, widely used set of C/C++ and Java libraries providing Unicode and Globalization support for software applications. ICU is widely portable and gives applications the same results on all platforms and between C/C++ and Java software.
ICU is released under a nonrestrictive open source license that is suitable for use with both commercial software and with other open source or free software.

Here are a few highlights of the services provided by ICU:
• Code Page Conversion: Convert text data to or from Unicode and nearly any other character set or encoding. ICU's conversion tables are based on charset data collected by IBM over the course of many decades, and is the most complete available anywhere.
• Collation: Compare strings according to the conventions and standards of a particular language, region or country. ICU's collation is based on the Unicode Collation Algorithm plus locale-specific comparison rules from the Common Locale Data Repository, a comprehensive source for this sort of data.
• Formatting: Format numbers, dates, times and currency amounts according the conventions of a chosen locale. This includes translating month and day names into the selected language, choosing appropriate abbreviations, ordering fields correctly, etc. Again, ICU uses data from the Common Locale Data Repository.
• Unicode Support: ICU closely tracks the Unicode standard, providing easy access to all of the many Unicode character properties, Unicode Normalization, Case Folding and other fundamental operations as specified by the Unicode Standard.
• Regular Expression: ICU's regular expressions fully support Unicode while providing very competitive performance.
• Bidi: support for handling text containing a mixture of left to right (English) and right to left (Arabic or Hebrew) data.
• Text Boundaries: Locate the positions of words, sentences, paragraphs within a range of text, or identify locations that would be suitable for line wrapping when displaying the text.

JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. It is based on a subset of the JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others. These properties make JSON an ideal data-interchange language.

JSON is built on two structures:
• A collection of name/value pairs. In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
• An ordered list of values. In most languages, this is realized as an array, vector, list, or sequence.

These are universal data structures. Virtually all modern programming languages support them in one form or another. It makes sense that a data format that is interchangable with programming languages also be based on these structures.

kXML 2 (revision 2.1.8) is a small XML pull parser, specially designed for constrained environments such as Applets, Personal Java, or MIDP devices.

The mobile-control project provides Java-based M2M solutions that combines the open standards-based technologies for remote control and management of Java-capable mobile devices.

OpenGL version 2.1, released on August 2, 2006, is the seventh revision since the original version 1.0. Despite incrementing the major version number (to indicate support for high-level programmable shaders), version 2.1 is upward compatible with earlier versions, meaning that any program that runs with a 2.0, 1.5, 1.4, 1.3, 1.2, 1.1, or 1.0 GL implementation will also run unchanged with a 2.1 GL implementation. OpenGL 2.1 adds backwards compatible enhancements to OpenGL's advanced programmable pipeline including: Pixel Buffer Objects for fast texture and pixel copies between frame buffer and buffer objects in GPU memory; texture images specified in standard sRGB color space for enhanced application color management flexibility; and numerous additions to increase the flexibility of shader programming including non-square matrix support, support for arrays as first-class objects, a fragment position query in shaders using Point Sprites and an invariant attribute for variables to enhance shader code reliability.

SQLite - a library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine.

WebKit is an open source web browser engine. WebKit is also the name of the Mac OS X system framework version of the engine that's used by Safari, Dashboard, Mail, and many other OS X applications. WebKit's HTML and JavaScript code began as a branch of the KHTML and KJS libraries from KDE.

XmlPull v1 API is a simple to use XML pull parsing API that was designed for simplicity and very good performance both in constrained environment such as defined by J2ME and on server side when used in J2EE application servers. XML pull parsing allows incremental (sometimes called streaming) parsing of XML where application is in control - the parsing can be interrupted at any given moment and resumed when application is ready to consume more input.
Java version of XmlPull v1 API provides:

• simple interface- parser consists of one interface, one exception and one factory to create parser
• implementation independent- factory class is modeled after JAXP and allows easily to switch to different XmlPull V1 API implementation without even modifying source code
• ease of use- there is only one key method next()that is used to retrieve next event and there are only five events:

  START DOCUMENT

  document start - parser has not yet read any input

  START_TAG

  parser is on start tag

  TEXT

  parser is on element content

  END_TAG

  parser is on end tag

  END_DOCUMENT

  document finished and no more parsing is allowed

• versatility- it is generic interface for XML parser and allows for multiple implementations and extensibility through features and properties
• performance- the interface is designed to allow implementing very fast XML parsers
• minimal requirements- designed to be compatible with J2ME (Java 2 Micro Edition) to work and on small devices and to allow create XmlPull compliant parsers of very small memory footprint.