This is a quick and dirty way to display Google Maps in Android. Its really not that hard and after learning how to do this you can easily start thinking about how you want to architect your Android App using the different bundles that come with google (Maps are only one of them!!).

Fire up Eclipse / Create your Project

Easily set up your own project here => I am using GANEYMEDE eclipse, which is the international version of the popular Eclipse IDE. If you don’t have the Android SDK you can download it from here and you can download Eclipse from here.Also make sure you have the latest version of Java => download it from here.

Your first step is to create the project within Eclipse (I will not get into how to install Android onto your computer) so refer to the screenshot.

GET YOUR MAPS API KEY

With the Android SDK release v1.0, you need to apply for a free Google Maps API key before you can integrate Google Maps into your Android application. Please follow the simple steps below on how to obtain your key. You may also refer to Googles detailed documentation here. You can also refer to Google’s detailed documentation on the process here.

Since you are testing the application on the emulator locate the SDK debug certificate located in the default folder of "C:\Documents and Settings\\Local Settings\Application Data\Android". The filename of the debug keystore is debug.keystore. For deploying to a real Android device, substitute the debug.keystore file with your own keystore file.

To make things simple just add (debug.keystore) to a folder in C:\ (for example, create a folder called "C:\Android").

Using the debug keystore, you need to extract its MD5 fingerprint using the Keytool.exe application included with your JDK installation. This fingerprint is needed to apply for the free Google Maps key. You can usually find the Keytool.exe from the "C:\Program Files\Java\\bin" folder.

Issue the following command to extract the MD5 fingerprint.

keytool.exe -list -alias androiddebugkey -keystore "C:\android\debug.keystore" -storepass android -keypass android


Modify your android manifest.xml file

The manifest file describes the components of the application — the activities, services, broadcast receivers, and content providers that the application is composed of. It names the classes that implement each of the components and publishes their capabilities (for example, which Intent messages they can handle). These declarations let the Android system know what the components are and under what conditions they can be launched.

Displaying your map

Next to display the Google Maps in your Android application, modify the main.xml file located in the res/layout folder. You shall use the element to display the Google Maps in your activity. In addition, let’s use the element to position the map within the activity:

Make sure that you have applied your android api key

Modify the MapActivity class

Lastly all you need to do is modify the MapActivity class in your #src folder. (Maps.Activity.java)

package com.ahadbokhari.GoogleMaps;
import com.google.android.maps.MapActivity;
import com.google.android.maps.MapView;
import android.os.Bundle;

public class MapsActivity extends MapActivity
{
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    protected boolean isRouteDisplayed() {
        return false;
    }
}

The above steps are all you need to actually display the maps in your emulatore. Press F11 in Eclipse to deploy the application onto an Android emulator. If you are experiencing problems then look over these three troubleshooting steps below:

Make sure that you add the package in your AndroidManifest.xml file.

Make sure you have internet permission (if you see nothing but grids in the emulator.) in the AndroidManifest.xml File.

Any web developer will know how important a database and its relationship can be to their web application. With that being said i would like to introduce you to Active Record.  Active Record is a Ruby library that allows your Ruby programs to transmit data and command to and from various data stores, which are usually relational databases.  You can also say that Active Record allows Ruby to work with databases.

Brief History behind Active Record

Active Record is a design pattern originally published by Martin Fowler in his book Patterns of Enterprise Application Architecture.  David Heinemeier Hansson (the creator of the Rails framework) took the concepts laid out by Mr. Fowler and implemented them as a Ruby library called Active Record.

Active record has been released with the Rails framework to the public and is also available as a part of the core bundle with its own Ruby Gem.

Active Record and the ORM Pattern

At the core of Active Record is object relational mapping or “ORM.”  These relational databases can be represented well by object based code; if we look at an example of a dummy accounts table in a typical database it would look like this:

Accounts table
     ID field (integer; auto-incremented; primary key)
     Username field (text type field)
     Password field (text type field)

If we look at the Active Record Account class (or model) it would look something like this:

Class Account ActiveRecord::Base
#some code here
end

If we look through our Rails code, we could possible create instances of different account objects like below:

# creates a new account object in memory and a new account record in our database
newacc = Account.new
newacc.Username = "Ahad"
newacc.Password = "pass*$#"
newacc.save
# creates an Account object in memory from data in Account table with ID of 1
# (equivalent to the ANSI SQL statement of "select * from accounts where ID = 1")
findacc = Account.find(1)
# deletes records from database that have username of "Ahad"
Account.delete("username = 'Ahad'")

Active Record Differs from other ORM Libraries

Active record out of the box makes a number of configuration assumptions, without requiring any outside configuration files or mapping details.  The previous example takes advantage of Active Record Assumptions, so we are not required to to configure or set up any specific instructions.  This is unlike many ORM libraries such as Java’s Hibernate.

MVC Concepts and Active Record

Active Record is most famous as being an important part of the Ruby on Rails framework, and is being copied by many other frameworks such as Code Igniter.    What MVC does it that it breaks code into logical groupings and programs into logical functional groupings.  With Rails, the model section is generally your Active Record classes and other data-descriptive or datacommunication code. The view section remains primarily for the user interface, which tends to be a heavy dose of HTML in most Rails applications.

CRUD Database Transactions and Active Record

Ususally there are four tasks one can perform when working with databases, and as a group are referred ot as CRUD. 

1. (C): Creating 
2. (R): Retrieving
3. (U): Updating
4. (D): Deleting

newacc = Account.new(:username = "Ahad")
newacc.save # creates the new record in the account table
temp = Account.find(1)
# => selects the record associated with id of 1 from the account table
temp.username = 'Ahad' # => assigns a value to the username attribute of the object
temp.save # does the actual update statement applying the changes we just stated.
Account.destroy_all(1) # deletes the record in the account table with id of 1

There are many more options to that we can consider here, but the above is the most generic or the most common.

How the Active Record Library applies to Ruby code

What you have to remember is when working with Active Record is that its all Ruby code.  Anything you do with Ruby objects (inheritance, overriding methods, etc etc) can also be done with Active Record objects. The whole idea is to represent database records and objects, but they really are two separate things; Ruby onjects and database records.

Active Record:  The smart choice

There are many reasons why Active Record is the smart choice.  One is its easy to install, simple to write and read, and also a full feature object based code.  If you look below at the benefits of Acitve Record, there is no doubt that this library is worth learning about.

• Simplified configuration and default assumptions (Convention over Configuration).
• Associations among objects.
• Automated mapping b/w tables and classes and b/w columns and attributes.
• Data Validations.
• Callbacks
• Inheritance hierarchies.
• Direct manipulation of data as well as schema objects.
• Database abstraction through adapters.
• Logging support.
• Migration support.
• Active Record integrated in other emerging frameworks like Merb.

There is alot of hype sorrounding Ruby and Ruby on Rails.  As a fanboy of Ruby and gearing myself up to start developing Ruby on Rails apps I am always trying to inform myself of the future of this awesome programming language.

SAN FRANCISCO — With Java now a very mature language with millions of developers, the Ruby language is among the fastest growing programming languages, and the number of Ruby developers is expected to quadruple over the next five years.In a panel discussion at the Sun’s CommunityOne day preview to JavaOne here on May 5, Mark Driver, an analyst at Gartner, said, “There are under one million professional Ruby developers now and we’re projecting there will be four million plus by 2013.” Driver later told eWEEK that Gartner’s research shows “strong interest” in Ruby and that the percentage of developers that will be creating commercial systems versus those that are hobbyists will be even greater for Ruby than for other languages. “Ruby will be more interesting to commercial developers,” he said.

The panel discussion featured a variety of participants, including some core contributors to the JRuby project and a trio of Ruby developers. In addition, while broaching the issue of Ruby’s growth, the session also at times compared Ruby to other languages such as PHP and Java itself. JRuby is an implementation of Ruby that runs on the JVM (Java Virtual Machine).

Charles Nutter, a Sun engineer who is a core committer to JRuby, said one reason developers are beginning to look at Ruby is that “Ruby is the flavor of the week, and there are a lot of ways to solve the problems of the Web.” 

According to the TIOBE Programming Community Index, it is one of the fastest growing languages, but has seen a decline between 2007-2008.

Position Dec 2008	Position Dec 2007	Delta in Position	Programming Language	Ratings Dec 2008	Delta  Dec 2007	Status
1	1		Java	19.367%	-0.68%	A
2	2		C	16.163%	+2.99%	A
3	5		C++	10.893%	+3.02%	A
4	4		PHP	9.479%	+1.09%	A
5	3		(Visual) Basic	9.478%	-0.74%	A
6	8		C#	4.643%	+0.65%	A
7	6		Python	4.567%	-0.13%	A
8	7		Perl	3.603%	-0.78%	A
9	10		JavaScript	3.062%	+0.33%	A
10	11		Delphi	3.055%	+0.38%	A
11	9		Ruby	2.308%	-0.78%	A
12	12		D	1.185%	-0.45%	A
13	13		PL/SQL	1.140%	-0.25%	A
14	14		SAS	0.843%	-0.55%	A
15	19		Pascal	0.689%	-0.10%	B
16	15		COBOL	0.631%	-0.26%	B
17	16		ABAP	0.603%	-0.27%	B
18	21		Logo	0.569%	-0.18%	B
19	17		Lisp/Scheme	0.515%	-0.33%	B
20	20		Lua	0.494%	-0.28%	B

Lets look at some of the features that Ruby extends to us:

• Interpreted:  Ruby is an interpreted language. Therefore, whenever you make a change to the source code, you need not compile the code and then run it to see the effect of the change. As a result of this feature, the code-compile-run cycle becomes the code-run cycle.
• Purely Object-Oriented: Ruby is purely object-oriented. That means that everything in Ruby is an object which includes primitive data-types and numbers. In addition, it supports all the features required by an Object-Oriented Language.
• Functional: Ruby supports functional programming using blocks.
• Duck Typing: It is also known as Dynamic Typing. Ruby decides about the type of variable while the program is running by looking at the value contained in the variable at that instant. In other words, if an object looks like a duck, sounds like a duck, then it is a duck!
• Automatic Memory Management: You would know it as Garbage Collection. As in any Very High-Level Language (VHLL), Ruby provides Garbage Collection out-of-the-box, thus you need not worry about physical memory leaks.
• Threading: The current stable version of Ruby provides ‘almost’ platform independent threading using green threads (threads used at the user-space level are known as green threads.) I said ‘almost’ because Ruby threads are simulated in the VM rather than running as native OS threads.
• Reflection: Ruby provides a program with the ability to ‘look at itself’ while running. This ability is known by different terms, such as reflection, introspection, and so on. Using reflection, a program can modify certain aspects of itself during execution, or create a completely new object at runtime based on the requirements at that time.

A An insightful post by the King of php himself can be found here: THE NO FRAMEWORK PHP MVC FRAMEWORK. Confusing? hahah – well Andy Jeffries ( A PHP, RUBY ON RAILS AND MYSQL Developer) sums it up really well here:  DESIGN PATTERNS VS AGILE DEVELOPMENT

I posted this in a forum in the morning today, please read the reply i got:

Keep an open mind …….

A good framework:

1. better separates presentation from logic
2. has a clear documented structure
3. has features

He uses a view, controller, and model but he doesn’t use a “front controller”. URL’s are mapped directly to views. That’s not necessarily bad, (that’s the asp.net way) but:

- without a messy .htaccess file, you miss out on nice flexible hackable urls
- you miss out on pre processing like showing a cached page without loading the entire view file and all it’s includes. 

I believe this person who commented on my post in the forums has a POINT WORTH NOTING…