Introduction to Mono for Android

CoverThe following is reprinted with permission. For more on this topic, check out Professional Android Programming with Mono for Android and .NET/C# by Wallace McClure, et al.

Chapter 2

Introduction to Mono for Android

What's in This Chapter?

  • Introduction to Mono and Mono for Android
  • Configuring the development environment
  • Mono for Android tools for Visual Studio
  • Debugging and deploying

What is Mono for Android? This chapter provides the basis for Mono for Android development. It starts with an overview of Mono and then moves to a discussion of Mono for Android, configuring the development stack, and developing and deploying a “Hello Mono for Android” application — first to an emulator and then to your Android-based phone.

Before You Begin Developing

Before getting started with development, you need to learn about a number of items that will help you understand the development environment and the tools that are involved. This section covers what Mono is and how it is implemented. Then it discusses what Mono for Android is, along with its benefits and implementation. Finally, this section discusses the development stack before moving on to development.

What Is Mono?

Mono is an open source project sponsored by Xamarin to create an Ecma standard implementation of the .NET common language infrastructure (CLI), a C# compiler, and an open development stack. The Mono project was started by Ximian in 2001, and version 1.0 was released in 2004.

Mono Implementation Goals

The Mono implementation is currently targeting three goals:

  • An open source CLI
  • A C# compiler
  • An open development stack

The CLI provides the runtime environment for languages that have been compiled to the Common Intermediate Language (CIL). The C# compiler is responsible for compiling C# code to CIL for execution on the runtime. The open development stack facilitates development and includes an IDE in MonoDevelop and several libraries beyond the core libraries to provide open cross-platform development. These libraries include GTK# for graphical user interface development, POSIX libraries for UNIX/Linux compatibility, Gecko libraries, database connectivity libraries, and XML schema language support via RELAX NG.

Mono Standards

Mono adheres to the Ecma Standard. Ecma International was formed in 1961 to support the standardization of information and communication technology. In 2005, Ecma approved version 3 of C# and CLI as updates to Ecma 334 and 335. Currently, a working draft of the Ecma 335 CLI is in progress.

The Mono C# compiler is currently feature-complete per the Ecma standards for C# versions 1, 2, and 3 in version 2.6. Version 2.6 also includes a preview of C# 4, with a feature-complete version of C# 4 available in the trunk of version 2.8.

What Is Mono for Android?

Mono for Android is a runtime and development stack that allows .NET developers to leverage their knowledge of Visual Studio and C# to develop applications for Android-based devices.

  • Runtime: The Mono for Android runtime is an application that runs on the Linux kernel in the Android stack. It interprets the Mono byte code and handles communication with the Dalvik runtime for calls to native Android APIs.
  • Development stack: Mono for Android is also a development stack, providing the tools necessary to create and package applications for Android devices.

Why Do I Need Mono for Android?

Given that the Android platform has an open development stack based on Java with Eclipse as a visual development environment, it would be reasonable to ask why you need Mono for Android. A .NET developer who uses Visual Studio has three main reasons: a familiar development environment, familiar APIs, and, as a result, rapid start-up.

Familiar Development Environment

As every developer knows, learning a new development stack is time-consuming and can be painful. Mono for Android allows the .NET developer to stick with the two core tools of .NET development: Visual Studio and C#.

  • Visual Studio: Visual Studio is an excellent and robust IDE geared toward .NET. By using the Mono for Android tools for Visual Studio, you won't have to change your IDE or the settings you like.
  • C#: Some .NET developers work only with Visual Basic .NET, but most .NET developers are familiar with C#. Although C# and Java are similar in structure, many differences in the idioms of each language make for fluent writing. And although proficient C# developers would not have to spend extensive amounts of time learning the Java idioms, they would not have to spend any time if they could stick with a language they already knew.

Familiar API and Library Structure

Staying within the .NET world allows you to work with a familiar API and library structure. Table 2.1 shows the assemblies that are a part of Mono for Android 4.0.1.

Table 2.1 Mono for Android Assemblies

Table 2.1 Table 2.1a

http://mono-android.net/documentation/assemblies

So, with your favorite development environment to leverage as well as familiar APIs, you will have a rapid start-up for Android development.

What Are the Trade-Offs of Working with Mono for Android?

When you decide not to work with a native API and development stack, trade-offs will be necessary. They need to be weighed against the advantages of working with a more comfortable, but abstract, layer.

Waiting for Improvements

Although moving away from the native Java and Eclipse in favor of Visual Studio has the benefits just mentioned, it also has some downsides. The first is that you generally have to wait for the latest improvements. That is, usually as soon as a new feature or performance enhancement is available in the Android SDK, you have to wait for the next release of Mono for Android for it to be available.

Taking a Potential Performance Hit

The second trade-off is performance. The Mono for Android runtime has to communicate with the Dalvik runtime to get a number of things done. This overhead, however, generally is minor and is more than offset by the benefits mentioned previously.

After you install the Mono for Android tools for Visual Studio, starting a new Mono for Android project is as easy as selecting File ⇒ New ⇒ Project ⇒ C# ⇒ Mono for Android. We will cover this in more detail next.

Memory Management

Many of the objects that are allocated by Mono for Android are wrappers for the Java objects they represent. So what happens is this: Every time you allocate a type which is wrapping a corresponding Java type, two objects are created:

1. The Java object, in the Java heap
2. The Mono “proxy” object, in the Mono heap

Mono for Android does some work to ensure that both objects stay alive as long as one is referencing the other. That is, as long as the Mono garbage collector (GC) refers to an object, the Java-side object will be kept alive and vice versa. This is accomplished by the proxy objects that are created by the mandroid.exe tool at build time.

However, the GCs are by nature lazy, only performing a collection on demand and not simply when objects go out of scope. So that means that cross-VM garbage will stick around longer than average, and this is unavoidable.

So, when allocating a large number of objects for temporary use, it is worthwhile to explicitly dispose of those objects. A convenient approach to this is to use a using block with a new object, as this will implicitly dispose of the new object that is the target of the using clause, and thereby dispose of the Mono-side wrapper, which will allow the Java-VM to collect the object, preventing too many temporary objects from sticking around for too long.

Note
For more details on garbage collection, you should refer to the documentation at the following link: http://mono-android.net/index.php?title=Documentation/GC&highlight=garbage+collection.

What Do I Need for the Mono for Android Development Environment?

Although the development environment for Mono for Android is geared toward working in Visual Studio with C#, many pieces beyond that are required.

Java SDK

First, you need to install the Java SDK, which can be found at http://java.sun.com. You might wonder why you need Java if Mono for Android is supposed to allow you to develop with C# on Visual Studio. The Android SDK is developed in Java, so it is required to run all the tools that come with the SDK. The most significant tool is the Android emulator, which is required for rapid debugging and testing before deploying to an actual device. However, other tools you will become familiar with are also Java-dependent.

Android SDK

Following the installation of the Java SDK, the Android SDK can be installed. The Android SDK can be downloaded from http://developer.android.com/sdk/index.html, where you will find a link to download a Windows installer. After you have downloaded the SDK, the installation has four steps.

1. The first step is to run the SDK installation. This is as straightforward as it sounds. Run the Windows installer, and you're done.
2. The second step is to download the APIs that you want to use. Run the program AVD Manager.exe, and select the “Available packages” item on the left. This allows you to install the different Google APIs and SDK platforms that you will use in the next step. You may install all the platforms you want, but for our purposes, ensure that you install at least the Level 8 platform, which corresponds to Android 2.2. If you install all the available packages, you should have a view that looks like Figure 2.1.
3. Now that the SDK is fully set up, the third step is to configure an Android emulator. In the Android SDK and AVD Manager, select “Virtual devices,” and then click the Create button. You see the window shown in Figure 2.2. In the Name field, type Android_22. In the Target drop-down, select Android 2.2 - API Level 8. In the SD Card radio group, select Size and enter 512. Now click Create AVD. You should get a dialog that confirms that the Android_22 AVD was successfully created.
4. The fourth step is to start the emulator you have configured. Select the Android_22 AVD from the list, and click the Start button. The dialog box that appears lets you change some launch settings. For now, the defaults are fine, so click the Launch button. After a short time you should see an image like the one shown in Figure 2.3. After a minute or two you should see the familiar Android logo, but it may take several minutes before the emulator is fully booted, as shown in Figure 2.4.

Once the emulator is running, you can leave it running to save some start-up time during the “Hello Android” development process.

Visual Studio

For Mono for Android development you must have Visual Studio 2010 Professional or better to run the Mono for Android plug-in. Visual Studio 2010 Express is insufficient, because it does not support plug-ins. The installation process for Visual Studio is outside the scope of this discussion, but you need to ensure that Visual Studio 2010 is installed before proceeding.

Mono Tools for Visual Studio

Mono Tools for Visual Studio are tools added to Visual Studio as a plug-in that helps with cross-platform compatibility of .NET development for the open source Mono development stack. These tools are not required for what we are doing here. However, if you are broadly interested in Mono development or deploying code written on Windows in Visual Studio to another platform that Mono supports, these tools are worthwhile and easy to install at this point. The tools can be found at http://mono-tools.com/download/.

Installing the Mono for Android Plug-in

As soon as all the prerequisites are in place, you can install the Mono for Android plug-in for Visual Studio. The plug-in can be downloaded from http://mono-android.net/Store. Close Visual Studio if it is open, and run the installation program. It takes a few minutes to install, but after it is complete, you are ready to proceed to Mono for Android development.

Visual Studio Development with Mono for Android

This section covers developing a basic “Hello Android” application for your Android device working with the Android plug-in for Visual Studio 2010. You start by setting up a new Mono for Android project in Visual Studio and then follow through with building and debugging the application. After that you add some logging and unit tests to the project before deploying the application to a physical device.

Although some of the specifics are focused on Visual Studio, everyone is encouraged to read this section, as it explains some aspects of Android and Mono for Android that are not covered in the section specifically geared toward development with MonoDevelop.

General Setup

The first thing you do is create the new application in Visual Studio. Start Visual Studio 2010 and select File ⇒ New ⇒ Project. When the New Project dialog appears, select Mono for Android Application from the available C# templates, as shown in Figure 2.5. In the Name field, type HelloAndroid. That will also appear as the solution name. Then click OK. Your project opens to Activity1.cs.

Building Hello Android

Before you build the application, you need to consider the template code and make some quick changes. The template code is as follows:

using System;

using Android.App;
using Android.Content;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Android.OS;

namespace HelloAndroid
{
    [Activity(Label = "My Activity", MainLauncher = true)]
    public class Activity1 : Activity
    {
        int count = 1;

        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);

            // Set our view from the "main" layout resource
            SetContentView(Resource.layout.main);

            // Get our button from the layout resource,
            // and attach an event to it
            Button button = FindViewById<Button>(Resource.id.myButton);
            button.Click += delegate { button.Text = string.Format("{0} clicks!",
 count++); };
        }
    }
}

This block of code shows a few things.

  • First are the using clauses needed for this code.
  • Then you have the namespace declaration that is set to your application name, HelloAndroid.
  • Then you have the class declaration for Activity1, which is of type Activity.

An Activity is central to the design of Android-based programs, and they are discussed more in upcoming chapters, particularly Chapter 3. However, the annotations on this class are also of note. First is the label My Activity, which will be the label seen in the Android application window. Second is the MainLauncher annotation, which indicates that this Activity is the main one to be launched in this application.

  • Finally, you have the OnCreate function. Activity creation is just one of several life cycle steps that an Activity may be subjected to. The whole life cycle will be discussed further in Chapter 3. In this function you initialize a resource bundle, set your view, get a button from the view, and attach an event to it.

Now you are ready to build the new application. Click the Debug button on the toolbar. You are prompted to select a running device to deploy the code to, as shown in Figure 2.6. You should see listed the emulator that you started running earlier. If there is no running device, you can select a device to start.

Select that emulator, and click OK. The Mono for Android toolkit then checks for an installed version of the Mono for Android runtime. If the runtime is not found, the toolkit installs it. This process can take quite some time. Once the runtime is installed, the toolkit signs and installs the application into the running emulator.

After that process has finished you can run your application. Go to the emulator, unlock it, and click the Applications button. You should see an image similar to Figure 2.7. Click the My Activity application. You should see the application running, as shown in Figure 2.8.

Logging

To follow the flow of the program execution, it is often helpful to log program activity. This section briefly examines how you can implement logging messages in Mono for Android. The Log class can be found in the android.util namespace. You can add a few lines to the code you had before to get the following source:

using System;

using Android.App;
using Android.Content;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Android.OS;
using Android.Util;

namespace HelloAndroid
{
    [Activity(Label = "Hello Android", MainLauncher = true)]
    public class Activity1 : Activity
    {
        int count = 1;

        protected override void OnCreate(Bundle bundle)
        {
            Log.I("HA", "Start OnCreate");
            base.OnCreate(bundle);

            // Set our view from the "main" layout resource
            SetContentView(Resource.layout.main);

            // Get our button from the layout resource,
            // and attach an event to it
            Button button = FindViewById<Button>(Resource.id.myButton);
            button.Click += delegate { button.Text = string.Format("{0} clicks!",
 count++); }

            Log.I("HA", "End OnCreate");
        }
    }
}

Here you can see the added using Android.Util that provides access to the Log class, which contains the following convenience functions (among others):

  • Log.I(string tag, string message) logs information.
  • Log.W(string tag, string message) logs warnings.
  • Log.E(string tag, string message) logs errors.

The tag parameter provides context for the log message. In this case you can use a tag of “HA” for HelloAndroid. To view the messages in Visual Studio, select View ⇒ Other Windows ⇒ Android Device Logging, and all the messages will be available.

Debugging

Having successfully executed the application in your emulator, you can look at how to debug a problem that we will introduce. If you are using a physical phone, you need to go to the applications page on your phone and select Settings. Then select Applications, Development, and check USB Debugging. After that, return to your code.

Change the following line:

Button button = FindViewById<Button>(Resource.id.myButton);

To the following:

TextView button = FindViewById<TextView>(Resource.id.myButton);

Rerun the application. This time the application will throw an error on start-up because you are trying to treat a Button as a TextView. While this example may be contrived, take a look at how you can debug the application.

Set a break point on the following line:

base.OnCreate(bundle);

Now, click the run/debug button on the toolbar. This time, as the application starts up the software will stop at the break point. You can now step through the application until you arrive at the offending line. Trying to step over that instruction will result in the previously seen error, and, in this case, fixing it is trivial.

Testing

The days of merely testing software through usage are long gone. All reliably built software relies on unit tests as a best practice and to make the testing cycle shorter and more reliable. So, how do you build unit tests with Mono for Android?

The short answer is NUnit, just as it is for any other Mono application. The longer answer involves structuring your program to make it amenable to testing. That is, the NUnit testing framework is not geared toward UI testing, so it is best to isolate your non-UI code into a separate library and set up any tests to run against that library.

It is also worth noting that if you intend to leverage code for other platforms, for example, the iPhone with MonoTouch or Windows Phone 7 with Mono or .NET, then you also want to isolate platform-specific code from generically reusable code. This code would also be good code to build test cases against.

So for non-UI and platform-independent code, instead of building program logic into the Android activities you want to extract that code to an Android library. You can create an Android library by creating a new solution, but instead of selecting Android application, select Android library. Then use NUnit to provide automated tests for that code.

Deploying

Having run the gamut from “Hello Android” through debugging, logging, and testing, it's now time to look at deploying an application to an actual Android device. This process has three steps: connect the phone via USB, set the phone into development mode, and deploy the application.

1. The first step is obvious.
2. The second step requires you to go into the phone's settings and select Application Settings. Under Application Settings, check the option for Unknown Sources. This lets you install non-Android market apps, which you want. Second, on the same page, select the Development option. This takes you to a screen with three options. Select USB Debugging and Stay Awake. You aren't using mock locations, so don't worry about that now.
3. Now for the final step: click the Debug button on the toolbar. This time, when the Running Devices list comes up, your device is on it! Select your device. This time the installation process runs over USB to your device.

When it is finished, give the Hello Android app a try.

Mono for Android Development with MonoDevelop

This section covers developing a basic “Hello Android” application for your Android device working with the Android plug-in for MonoDevelop. If you skipped the Visual Studio section because you are on a Mac or use MonoDevelop anyway, I would encourage you to read the Visual Studio section because it covers some generally applicable concepts, but if you want to jump right in and catch up along the way you should be fine.

General Setup

Installing the development environment on the Mac is straightforward. There are six steps to the process:

  • Install the Android SDK: This can be found at http://developer.android.com/sdk/index.html. This is Java-based and leverages the Java SDK installed by default on OSX.
  • Install Mono for Mac: This can be found at http://www.go-mono.com/mono-downloads/download.html. This provides the Mono platform, which is the basis for the Mono development tools that will also be installed.
  • Install MonoDevelop for Mac: This can be found at http://monodevelop.com/download. This provides an IDE for developing Mono applications on the Mac. Also, it is required because Mono for Android for the Mac installs as a plug-in for this IDE.
  • Install Mono for Android for Mac: This can be found at http://mono-android.net/Store. At the store page you can also download a trial version of the software.
  • Configure the Mono for Android MonoDevelop add-in: Once the plug-in is installed you need to go to MonoDevelop ⇒ Preferences, which will display the preferences dialog. After this, select the Other category and select Mono for Android SDKs. This will allow you to configure the Java and Android SDKs that you are using.
  • Configure your Android Emulator: Finally, run the Android SDK installer and select Virtual Devices. Create a new virtual device. It's important to note that you may find developing on an actual device to be somewhat faster than it is on an emulated device.

If you want to read about this process in more detail please refer to the following link: http://mono-android.net/Installation/Installation_for_Mac.

Note
Also, if you are running in a Mono for Windows environment you may want to refer to the installation instructions at http://mono-android.net/Installation/Windows, as there are some minor differences in setup.

Building Hello Android

To get a program up and running with MonoDevelop and Android is very simple. If you read the Visual Studio section, you can probably skip this section and find the details on your own, but for those who skipped the Visual Studio section you can run through the process now.

Go to File ⇒ New ⇒ Solution and select the Mono for Android template as shown in Figure 2.9.

For the solution name, key in HelloAndroid. Then click OK. The new application will appear in the window. Go to the Run menu and select Run. After a moment a window will appear prompting you to choose the device to run the application on. If you have a running emulator or an Android device plugged in, it will be listed. If not, select “Start an Emulator Image” and you will receive a list of images that are configured on your machine, one of which will be the emulator you configured during the general setup.

Select the device or emulator that you want your application to run on, then select OK. If an emulator has to start up, it could take awhile. Otherwise, messages will appear notifying you that it is checking for installed applications, installing Mono for Android, if necessary, and, finally, running the application, as shown in Figure 2.10.

Logging

Logging in MonoDevelop is identical to logging in Visual Studio, as it is a function of the API and not of the IDE. To recap, in case you skipped the Visual Studio section, here are the logging functions:

  • Log.I(string tag, string message) logs information.
  • Log.W(string tag, string message) logs warnings.
  • Log.E(string tag, string message) logs errors.

The tag parameter provides context for the log message. For instance, if you add some logging to your HelloAndroid application, you might use a tag of “HA” in the logging functions.

Debugging

Having successfully executed the application in the emulator, it's time to look at how to debug a problem that we will introduce. If you are using a physical phone, you need to go to the Applications page on your phone and select Settings. Then select Applications, Development, and check USB Debugging. After that, return to your code.

Change the following line:

Button button = FindViewById<Button>(Resource.id.myButton);

To the following:

TextView button = FindViewById<TextView>(Resource.id.myButton);

Rerun the application. This time the application will throw an error on start-up because you are trying to treat a Button as a TextView. While this example may be contrived, take look at how you can debug the application.

Set a break point on the following line:

base.OnCreate(bundle);

Now, click the Run/Debug button on the toolbar. This time, as the application starts up the software will stop at the break point. You can now step through the application until you arrive at the offending line. Trying to step over that instruction will result in the previously seen error, and, in this case, fixing it is trivial.

Testing

The days of merely testing software through usage are long gone. All reliably built software relies on unit tests as a best practice and to make the testing cycle shorter and more reliable. So, how do you build unit tests with Mono for Android?

The short answer is NUnit, just as it is for any other Mono application. The longer answer involves structuring your program to make it amenable to testing. That is, the NUnit testing framework is not geared toward UI testing, so it is best to isolate your non-UI code into a separate library and set up any tests to run against that library.

Deploying

Deployment of your HelloAndroid application to a device is very simple.

This process has three steps: connect the phone via USB, set the phone into development mode, and deploy the application.

1. The first step is obvious.
2. The second step requires you to go into the phone's settings and select Application Settings. Under Application Settings, check the option for Unknown Sources. This lets you install non-Android market apps, which you want. Second, on the same page, select the Development option. This takes you to a screen with three options. Select USB Debugging and Stay Awake. You aren't using mock locations, so don't worry about that now.
3. Now for the final step: click the Debug button on the toolbar. This time, when the running devices list comes up, your device is on it! Select your device. This time the installation process runs over USB to your device.

When it is finished, give the HelloAndroid app a try.

Summary

In this chapter you covered installing the development environment for Android on Windows using the Visual Studio 2010 plug-in, and you covered installing the development environment on the Mac using MonoDevelop. In each case, the process is similar: install the software stack including the Java SDK, the Android SDK, and the Mono SDK. Have your IDE installed, either Visual Studio or MonoDevelop. Then install the Mono for Android add-in. If you are using MonoDevelop, configure the add-in. Then, using the installed platform, create a default HelloAndroid application.

In addition, this chapter covered logging, testing, and deploying applications. You saw that logging was a simple matter of adding one of the three log calls to your application, and that these logs can be seen in the console of either Visual Studio or MonoDevelop. Testing is always considered a best practice to assist in validating the behavior of your software before it is deployed. Deployment is what software development is about. These skills will be used over and over in all the chapters to come.

CoverThe following is reprinted with permission. For more on this topic, check out Professional Android Programming with Mono for Android and .NET/C# by Wallace McClure, et al.



Related Articles

Comments

  • プラダ 財布,Exactly What You Need Know About プラダ バッグ And Reasons Why

    Posted by Hemempoms on 03/29/2013 12:55pm

    PRADA in the ripen from summer 2013,[url=http://cheappradashoesoutlet.tumblr.com][b]プラダ 長財布[/b][/url] . pep up in 60's geisha elements of collage ,[url=http://cheappradasale.tumblr.com/][b]prada 財布[/b][/url] .as the stress, and the Steven Meisel palm reflector ,[url=http://pradasalecheap.tumblr.com/][b]プラダ トートバッグ[/b][/url] .this savouriness,[url=http://cheappradashoesoutlet.tumblr.com][b]プラダ 長財布[/b][/url] . advertising is foolproof,[url=http://cheappradasale.tumblr.com/][b]プラダ トートバッグ[/b][/url] reproduce ,[url=http://cheappradasale.tumblr.com/][b]プラダ トートバッグ[/b][/url] .the integral,[url=http://pradasalecheap.tumblr.com/][b]プラダ 店舗[/b][/url] . heavens, hyacinthine and gray melancholy[url=http://cheappradashoesoutlet.tumblr.com][b]プラダ 財布[/b][/url] obscurity indefinite, a highlight models are moderately aloof. While the working model lineup is also huge, from the supermodel icon to stage up nova,[url=http://cheappradasale.tumblr.com/][b]プラダ 財布[/b][/url] 11 carefully selected models are in pre-eminent of the camera to prove[url=http://pradasalecheap.tumblr.com/][b]プラダ 店舗[/b][/url] its united of a persuasion handsomeness

    Reply
  • Monodroid database

    Posted by asava samuel on 03/27/2013 07:44am

    Here is a database compatible with MonoDroid: http://www.kellermansoftware.com/p-43-ninja-net-database-pro.aspx

    Reply
  • nothing

    Posted by usman on 07/13/2012 04:57am

    This is great but i will try it

    Reply
Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • On-demand Event Event Date: April 22, 2014 Database professionals -- whether developers or DBAs -- can often save valuable time by learning to get the most from their new or existing productivity tools. Whether you're responsible for managing database projects, performing database health checks and reporting, analyzing code, or measuring software engineering metrics, it's likely you're not taking advantage of some of the lesser-known features of Toad from Dell. Attend this eSeminar with Dell Software's …

  • The exponential growth of data, along with virtualization, is bringing a disruptive level of complexity to your IT infrastructure. Having multiple point solutions for data protection is not the answer, as it adds to the chaos and impedes on your ability to deliver consistent SLAs. Read this white paper to learn how a more holistic view of the infrastructure can help you to unify the data protection schemas by properly evaluating your business needs in order to gain a thorough understanding of the applications …

Most Popular Programming Stories

More for Developers

Latest Developer Headlines

RSS Feeds