Contents

• Overview
  • Hello World – Using Object
  • Hello World – Using Interface
  • Hello World – Modularized
  • Understanding the program
    • Write the inteface
    • Write the implementation

Overview

There are a lot of articles in Introduction of Objective-C and explaining basic concepts. But this article attempts to explain the basics of Objective-C without the influence of any framework  i.e without the influence of the GNUStep or NextStep or Cocoa framekwork. So, I  have used the primitive types and the basic object from Objective-C base framework and complied with GCC compiler. Also I did not want to use Apple’s XCode editor to write an objective-c program, instead I used Emacs and Terminal to write, build and run the code. After all it s again a C-programming language. This makes the language learning more fun. So this article goes little in-depth to explain the semantics of each element in the Objective-C. If you need a jump start in learning the language you can refer to the Google’s style guide to get an overview about the language. Also try reading the FAQs about the language and you will get more insights.

So, before start learning this here are my two cents:

1. Think Objects & Intefaces. Though you write the program in a C like language, do not think procedurally.
2. You might want to write comparitively more number of lines than you think.
3. Have patience in using brackets.
4. You might have to learn few other object-oriented mechanism and implementation other than Inheritance, Polymorphism etc.,

Hello World – Object Version

Here is the hello world progarm.

#import <objc/Object.h>

#import <stdio.h>
/** Write your Interface extending Object **/

@implementation HelloWorld:Object
-(void) hello
{
    printf("Hello World");
}
@end

/** Main program for the program execution entry **/
int main(int argv, char* argc[])
{

/* Create an object */
    id o = [HelloWorld new];

/* Pass the message 'hello' to object in the reference variable 'o' */
    [o hello];
}

You should notice the below things in the above program

1. HelloWorld is extending Object class, which provides the basic features for objects like new, free, alloc etc.,
2. Used #import instead of the regular #include. The advantage in using #import is, the compiler will make sure that it includes the header file only once during compilation irrespective of how many modules is importing ( i.e including ) the same header file repeatedly. So you can avoid boiler-plate code like this.

#ifndef _INC_HEADER1

#define _INC_HEADER1
#include "header1.h"

#endif

3.The method definition of hello is quite understandable. I’m not going to explain much of it now here. The object created from this class is capable of receiving the message named hello and invoke the method hello defined in the class HelloWorld.

Compile

To compile this program in your terminal either in Linux / Mac use this command.

% gcc -arch i386 -o hello -l objc helloworld.m

gcc is the GNU compiler suite, which you will get by default in your mac / linux machines or you can download it.

-o is to mention that you create an executable with name hello

-lobjc is to make the compiler aware that you are trying to compile & link Object-C language.

helloworld.m is the file which contains the objective-c program.

Output

Hello World

HelloWorld – with Interfaces

Lets add some some salt to it. An another version of the same program can be written like this.

#import <objc/Object.h>

#import <stdio.h>

@interface HelloWorld:Object
{
}
-(void) hello;
@end

@implementation HelloWorld
-(void) hello
{
    printf("Hello World");
}

@end

int main(int argv, char* argc[])
{
    id o = [HelloWorld new];

    [o hello];
}

You will note two differences in this version of the program.

1. There is an interface class extending Object class
2. The implementation class doesn’t inherit the class Object

Now, you have to play by rules, the rules of the ObjC compiler.

1. You should name your @interface as same as the @implementation class and you should not inherit any other object for the @implementation class.
2. Every @interface you write, should extend the Object class, so that you will be able to use the messages (or method) like new, alloc,free etc.,

In above program, after declaring the interface you do not link the interface to the HelloWorld class, but the ObjC compiler will look for that any interface with the same name as the implementation class.

If you do not provide an interface class name, the compiler will throw out this error.

helloworld.m:13: warning: cannot find interface declaration for 'HelloWorld'

Hello World – Modularized

Adding more spice to the program. The third variation to the program is below. I create three different files to split and hold the logical group of code into it’s individual file, i.e basically modularizing the code. You should be known of the advantages of modularizing the code. So, in here I create the below files

1. HelloWorld.h – Has the interface definition
2. HelloWorld.m – Has the implementation details
3. main.m – Has code to instantiate and execute the objects

HelloWorld.h

#import <objc/Object.h>

#import <stdio.h>
@interface HelloWorld:Object
{
-(void) hello;
}

HelloWorld.m

#import "helloworld.h"
@implementation HelloWorld
-(void) hello
{
    printf("Hello World");
}

@end

main.m

#import <objc/Object.h>

#import "helloworld.m"
int main(int argv, char* argc[])
{
    id o = [HelloWorld new];
[o hello];

}

This version of the program is what you will be writing in Realtime. Now let us try to understand the parts of the Objective-C language.

Compile

Since you have two module ( ending with .m ) to compile you might need to mention both of them, so that the gcc compiles all the required modules and then links them to create the executable.

gcc -lobjc -arch i386 -o main main.m helloworld.m

If you have more objective-c implementation files i.e .m files, then you can save the time and pain by including all the files with just using *.m

gcc -lobjc -arch i386 -o main *.m

Understanding the program

Let us spend some time to understand the paradigm of the Objective-C program. The objective-c language, which has a strong influence of SmallTalk based “message” passing mechanism and interface-based-programming, makes you think and write the programs in terms of messages and interfaces.

If you look at the above program, you would notice a pattern which is pretty much as same as a C++ program, except the interfaces and the naming conventions used. Basically the program is of 3 sections:

1. Headers – Common for any programming language ( C, C++,Java etc., )
2. Interface & Implementation Classes
3. And a main program – which runs the code.

Note: If you wanted to write a procedural program, then you don’t have to write a ObjC program

And if you are not familiar with the interface based program and if ObjC is going to be the 1st programming language learning interface-based programming, then I strongly recommend to gain some basic knowledge of what does interfaces means and how they are used and useful to the software construction.

Write your interfaces

Every class you wanted to create i.e the real concrete class which does some logic, you ought to tell the objective-c compiler, something about the class.Thats why you create @interface. @interface create a template of how your object is going to look like, what data it can hold and what messages it can receive to process ( also can receive messages that it cannot support, but you can handle it accordingly) and then you write the @implementation class to say what does you object is going to do. So, it is two piece of work you have to do.

And remember that, when you are modelling your classes, it always becomes your @interface class not @implementation class.

The interface should extend a class which is of type Object or it should be from the family of the type Object to provide the basic operations like new, free, alloc etc., Again Object is an both interface and has an implementation, i.e type Object is a concrete class that you can use as below

id o = [Object new];
@interface HelloWorld:Object
{
    /* data */
}

/* messages */
    -(void) hello;
@end

Write your implementation

The implementation class is going to hold the logic what needs to be performed when a defined message by interface is sent to the object. In this case when a hello message is sent to the object, the implementation defines what needs to be done. Interface class starts with @interface <ClassName> and ends with @end.

@implementation HelloWorld
-(void) hello
{
   ....
   ....
   ....
}

@end

Writing unit test cases1 are the part of any development project process. But developers rarely follow process. For us, we wanted to code something and see it to work on what we have fixed and finally move it to production.When it works, we are happy with it. But wait, when it doesn’t work? Then comes a lot of head ache for developer. Ok stories apart, lets get back to work. I’m not going to discuss about how to write unit testcases, but rather discuss how to write some better unit testcases using JUnit and avoid some of the pitfalls that we developers falls. Since JUnit is based on xUnit testing framework, any xUnit based testing framework for the language you use like NUnit, CppUnit, etc.,

public boolean validateZipCode(String zipCode)
{
    Matcher m = Pattern.compile("\d{5}").matcher(zipCode);
    return m.matchers();
}

public void testValidateZipCode()
{
    boolean output = validateZipCode(null);
    assertFalse(output);

    boolean output = validateZipCode("");
    assertFalse(output);

    boolean output = validateZipCode("    ");
    assertFalse(output);
}

public void testValidateZipCode1()
{
    boolean output = validateZipCode(null);
    assertFalse(output);
}

public void testValidateZipCode2()
{
    boolean output = validateZipCode("");
    assertFalse(output);
}

public void testValidateZipCode3()
{
    boolean output = validateZipCode("    ");
    assertFalse(output);
}

class ZipCodeTest extend TestSuite
{

    public void testSuite()
    {

    }

}

class Engine
{

    int state, fuel = 100, timeToRun;

    public void run(int minutes)
    {
            this.timeToRun = minutes;
            this.start();
            this.fuel -= minutes * 1;
            this.stop();
    }

    public void start()
    {
            this.state = 1;
    }

    public void stop()
    {
            this.state = 0;
    }

    public boolean equals(Object o)
    {
            Engine e = (Engine) o;
            return this.state == e.state && this.fuel == e.fuel;
    }

    public int hashCode()
    {
            return this.fuel;
    }

}

public void testEngineStatusAfterRun()
{
    Engine e = new Engine();
    e.run(5);

    /* less recommended */
    assertTrue(0 == e.state);

    /* recommended */
    Engine expected = new Engine();
    testCasse.state = 0;
    testCasse.fuel = 95;
    assertEquals( expected, e);

}

class CarEngineException extends Exception
{
    int engineErrorCode;
    String message;

    public void runEngine() throws CarEngineException
    {

        if(someCondition1)
        {
                List l = someOtherProcess();
                if(l.isEmpty())
                {
                    CarEngineException ex = new CarEngineStartException();
                    ex.setMessage("some message for failure");
                    ex.setEngineErrorCode(1);
                }
                else if(l.size() == 1)
                {
                    CarEngineException ex = new CarEngineStartException();
                    ex.setMessage("some message for failure");
                    ex.setEngineErrorCode(1);
                }
         }
    }
}

public double power(double num, int exp)
{
    ...
}

public double sqr(double num)
{
    return pow(num,2);
}

public double cube(double num)
{
    return pow(num,3);
}

public double exp(double raise)
{
    ...
}

class MathTest
{

    ...

    public void testPow()
    {
        ...
    }

    public void testSqr()
    {
        ...
    }

    public void testCube()
    {
        ...
    }

    public void testExp()
    {
        ...
    }

}

class TestPowMethods
{

    public static Test powMethodSuite()
    {
        TestSuite suite = new TestSuite();
        suite.addTest(new FunctionsTest("testPow"));
        suite.addTest(new FunctionsTest("testSqr"));
        suite.addTest(new FunctionsTest("testCube"));

        return suite;
    }

    public static void main(String[] args)
    {
        /*this will execute just pow() dependent methods */
        TestRunner.run(powMethodSuite());
    }

}

assertEquals("Error code should be 100", 100, e.getErrorCode() );

assertEquals("Error code should be 100. Received = " + e.getErrorCode(), 100, e.getErrorCode() );

Aggregation and Composition are type of Association which explains how two elements are associated to each other in a class model. Sometime it very confusing to choose between Aggregation & Composition.

Association

In Object orientation, Association is an important relationship which explains how one element is related to another by type and instance(s) ( i.e multiplicity ). Almost most of the objects that you would model or work with will associate with something or other.

class Person
{
String firstName;
String lastName;
Integer age;
}

In the above example, the attribute firstName and lastName are associated to the class Person.

It is very easy to understand about the Association and it is straight forward. But the problem arises for most of the programmers during the UML modeling is, when they come across another type of association i.e Composition. Though they are very similar in the action, but they are applied for different purposes. Both are certainly an easy to understand concepts, but understanding them requires few insight / visualization of few real world things and correlation with the concepts.

Merriam Webster
definition for

Aggregation:the collecting of units or parts into a mass or whole.

Composition:product of mixing or combining various elements or ingredients.

Does both sounds similar? No. There is a subtle difference. Lets look at those differences now.

Aggregation

Aggregation is the process of grouping homogenous objects.

Notice the bold words homogenous objects. Yes, aggregation deals with same type of objects. Same type of object means? Let us see this example.

In Microsoft Excel, Aggregation is process of applying a specific function on set of similar object( Numbers, Text etc.,)

So, if you mix numbers along with text, the aggregation will not work. Same applies for Object Oriented Modelling too.

Another example is Book. A book is aggregation of pages, not anything else.


class Book
{
Page[] pages;
}

class DuckPond
{
List ducks;
}


Courtesy by John Morgan

In the above example, the list will hold same Address object.

In Java Generics in the Collections are kind of Aggregation.


List<Driver> driversList = new ArrayList<Driver>();


Composition

Composition on the other hand is again grouping of object but, dis-similar objects. Than Association you will model objects with composition more frequently. Composition reflects the objects in real world.


class Car
{
Wheel[] wheels;
BodyStyle body;
HeadLight[] headlights;
}


The code builds a Car object, where a Car is composed of heterogenous parts like Wheels, Headlights, Body metals etc., Here the appropriate method is Composition. Aggregation wont fit here.

Let us consider the book example. A book is aggregation of pages, but pages are not just made of text. They are made of tex and pictures.


class Page
{
List textblocks;
List imageblocks;
}


Composition of different and appropriate object makes things better

Browser [DOM](http://en.wikipedia.org/wiki/Document_Object_Model “Document Object Model”) is always created once and the same DOM is referred every time when used (like any other object model). It is not destroyed / deleted unless it is explicitly triggered.

But some aspects of browser would make the DOM object reset. For example, during the XHR based requests, more than one page might contain the same script to perform and you are not likely to put them as a common script in the parent. When the same script is loaded by more than one page ( a.html & b.html), your DOM will likely to reset.

YAHOO.namespace("mymindleaks.loadonce");

YAHOO.mymindleaks.loadonce = (function()
{
	var context;
	var _init = function()
	{
		if( !context )
		{
			context = createHTTPRequest("http://www.mymindleaks.com/ping");
		}

		return context;
	};

	return{
		init: _init

	};
})();

YAHOO.mymindleaks.loadonce.init();

When this code is embedded in a HTML file and when it is loaded more than one time in the same HTML session, everytime the page is loaded, the object YAHOO.mymindleaks.loadonce will be created new and the value will be initialized. Hence there will be more than one “ping” to the URL, which is not intented.

In order to make only one ping from the browser per session, you have to restrict the browser not to invoke the function again. This can be done simply by adding a if-condition

YAHOO.namespace("mymindleaks.loadonce");

if( !YAHOO.mymindleaks.loadonce )
{
	YAHOO.mymindleaks.loadonce = (function()
	{
		var context;
		var _init = function()
		{
			if( !context )
			{
				context = createHTTPRequest("http://www.mymindleaks.com/ping");
			}

			return context;
		};

		return{
			init: _init

		};
	})();

	YAHOO.mymindleaks.loadonce.init();
}

by adding a if-condition the browser restricts the invocation of the anonymous function as the object YAHOO.mymindleaks.loadonce is already existing in the DOM.

I had a tamil dictionary for the Computer Words, just thought of sharing it. This one is prepared by Anna University ( Valarmathi mandram ) in 1998.

http://www.mymindleaks.com/wp-content/uploads/2010/07/2421484-Tamil-Technical-Computer-Dictionary.pdf

Continuing with the Computing the Services Part – 1, We shall take a look at what each characteristics of services means in the computer world. Defining characteristics is very important aspect in any design. You have to define your design, to work in the way you describe and you expect to it.

The characteristics can be further grouped into

• Structural characteristics allow you to make sure that you create services which are well maintainable and re-usable
• Operational characteristics allow you to make sure that the services are quick, fail-proof and responsive.

Our HiTech bank needs a enterprise application to be designed, which obviously requires a lot of design. But our HiTech bank will provide basic services like withdrawal and deposits, via various interfaces like Online, ATM and Card Readers.

Granular

The services defined should be granular in nature. Granularity comes when comes the matter of re-usability and maintainability. More granular is the service, more the re-usability and maintainability.Consider the services which does the deposit & withdraw transaction in our HiTech Bank.

Bank.deposit( username, password, PIN, deposit-amount, account# ):
   if PIN = BLANK  //Online mode
    Check if the username, password is valid
    Check if the username, password is valid for account#

  if PIN IS NOT BLANK
    Check if PIN is valid for the account
    Open #account
    Add deposit-amount to the existing amount in #account
    Close #account

Bank.withdraw( username, password, PIN, withdraw-amount, account# ):
    if PIN = BLANK:  //Online mode
        Check if the username, password is valid
        Check if the username, password is valid for account#

    if PIN IS NOT BLANK:
        Check if PIN is valid for the account
        Open account#
        Reduce withdraw-amount to the existing amount in #account
        Close account#

The above code is not granular and not re-usable. The reason is, lets assume that in future the HiTech bank is adding more user interface devices and has different authentication system, say biometrics. Now, you are ought to change the authentication code in your module. Now, you can feel the pain of modifying it.Also, the transaction are tied with the authentication process, which logically shouldn’t be. Because, transaction is a separate Unit of Work. If you transaction fails, it’s not necessary that your authentication also fails.

Fig 1. Decomposing the methods to create more granular methods.

Bank.authenticate( username, password, PIN, account#) :
    if PIN = BLANK :  //Online mode
        Check if the username, password is valid
        Check if the username, password is valid for account#
      if PIN IS NOT BLANK :
        Check if PIN is valid for the account

Bank.deposit( deposit-amount, account# ):
    Open account#
    Add deposit-amount to the existing amount in #account
    Close account#

Bank.withdraw(  withdraw-amount, account# ):
    Open account#
    Reduce withdraw-amount to the existing amount in #account
    Close account#

Bank.doTransaction( transaction, account, amount, username, password, PIN ):
    Bank.authenticate( username , password, PIN)
    if transaction = Deposit
        Bank.deposit( amount, account# )
    if transaction = Withdraw
        Bank.withdraw( amount, account# )

This is the how you make granular services. The advantages of this is you have good maintainability, easy code modification and more re-usability. In future, you change the authentication code to authenticate with another device / interface, no matter what you change , your change is evenly applied across the service.

Interface

An Interface will enable a device or program enabling a program to communicate with another program. In UNIX, one of the cool interface is the “|” pipe symbol. You can combine more than one UNIX command via the “|” ( pipe ). Pipe acts as an interface between two programs.

cat *.java | grep “String.to”

It is one of the most important characteristics to define. When a service is defined, make sure that it has proper interface to communicate to the business services. In our bank ( HiTech Bank) banking situation, you need services to authenticate the user / customer before accessing the account. You should at least define these service, which in turn does the appropriate authentication.

If the HiTech Bank haven’t defined a proper interface to read the card but just to type in the PIN, the customers will not be able to use the ATM machines / Card readers even if the service to authenticate is available.

Fig 2. Bank implementing Bank Interface and other User Interfaces using the bank interface

We shall continue with the remaining characteristics in the next post.

Every civilization had their own representation of numbers in their age. Like what we have now , the Arabic Numerals [1. The Story of Mathematics - Richard Mankiewicz ] [2. Number System - http://www.math.wichita.edu/history/topics/num-sys.html]. This representation is no more in use as universally as the arabic numerals that are taught now. Though different civilizations had different glyphs to represent number, everyone have understood the importance of numbers and found a way to represent them and did known how to handle it.

In Tamil, Number is called as “EN” ( Tamil:???) and “Digit” is called as Illakangal ( Tamil: ??????? )

Numbers in Tamil

Tamil language instructs to write numbers based on how the pronunciation is made rather than how the digits are spelled.

Fig 1. How a number is spelled and pronounced

Below list maps the modern number we use, to the tamil glyphs that was used by the Tamils. It is interesting to find that the list doesn’t contain a tamil representation for equivalent for zero. I’m wondering why the tamil havent created any glyph for “ZERO”. Did they think that it’s not mandatory that one should require ZERO to write down numbers? or did they find ZERO is ‘evil’? or ZERO is not necessarily to write down any number in this world, other than ZERO.

Fig 2. Listing the tamil glyphs for modern numbers we use

ZERO, un-important in Tamil numbers?

Even in our modern world, we don’t use zero when we pronounce the number. We don’t say , “One Hundred Zero Three” for 103. If that is the text, it would literally means “One followed by Hundred Zeros and a Three“. So, we are accustomed to say, “One Hundred and Three“. We can see that we don’t require ZERO when we say a number. It’s only required when we spell the number. But Tamils haven’t or ‘didn’t wanted’ to have two formats to say a number ( pronouncing & spelling ). This could be one reason that I can think of why ZERO is missing in the number set.

INFITT ( International Forum for Information Technology in Tami) aka “??????? (Uttamam)” have made proposal to include ZERO into the tamil number glyph’s list and createa UNICODE symbol for it in the tamil language font.

I tried to translate few numbers from arabic to tamil [3. Tamil Unicode List - http://www.unicode.org/notes/tn21/tamil_numbers.pdf]and here is on how to write numbers in tamil. You can also try few and if possible share it.

Fig 3. Some sample on how to write a number

One thing I could realize is that, in olden days people in any civilization ( not Babylons ) who didn’t had ZEROs in their set, to write / speak about any number.

In my team we were talking about services and then the web services, and when I was talking to a friend of mine about the services stuff, he posted a blank question. “What is a service? and how different is that from a method”. His question is correct, I feel that most of the people who design services in this complex computing world are not still clear what is a service and not sure of how different is a programming language methods from the service and what it is intent to do?

What is a service?

Lets start exploring the service. Let me take you to the understanding of what does a service means in the real world and how is that transformed into the computing world. Consider a simple banking situation, where the customer is willing to get some service to fulfil his / her needs. interaction between a customer and the service provider A person needs to deposit some money into the account of the person. Hence , deposit is a service provided by the bank to make customer safe guard the money into the bank’s vault. Similarly, withdrawal, money transfers etc., are some of the service provided by a service provider i.e bank.

In layman’s term , A service is “an act of assistance”.

But some service oriented company, does exactly same job as this.

source: dealer refresh

So, you place computers in the place of humans. But still, how do you make sure that the computers perform the same task as of humans ( of-course, not the one like above ) and deliver the expected service as good as a human ( is it?? ). Hence this will lead to define some of the characteristics of good service.

Characteristics of a good service.

This table give you an complete idea on how a delivered service should be. Just gathering together.

I will detail out the each of the characteristics in the next article.

[ Updated: Updated the description of the “State” of the service ]

I wanted to write about my migration to new hosting. I write this post to say that why I’m leaving Bluehost and why did I chose Webfaction. Loyal Bluehost hosters dont get furious, this is my personal opinion on why I switched. Now, this blog is powered by Webfaction. Moving a blog to a new hosting provider is  as exiting as moving to a new city.  Today I completely moved my blog from Bluehost to Webfaction. Believing Change is always constant, I keep on looking for some kind of change. Now, it’s time to change my blog’s hosting provider.

After done with the moving to a hosting provider, next I was trying to overhaul my blog with the link structure. Puzzled on where to start from. People enter into my blog via URL. Hence decided to tweak the URL.  So, it’s time to decide upon what link structure I should chose. And before that, is this link structure is really a necessary stuff to tweak up? If you ask with a SEO expert, he/she would pour a rain of tips, problems if you don’t make the links looks SEO optimized. And mostly Google oriented optimizations. But sometimes, I used to think, Is Google going to rely-upon this tiny URL part in the entire web indexing operation. If you look into any of the blog which has a content juice, you wont find a proper URL structure. I will give you a lots of example.

Before that what is an URL, and why everyone in this world is so much bothered about it?

People who use web knows very well about URL. And there are quite lots of topic around how to build a better URL. CMS software provides plug-ins, tools to build good URLs.  So, why is that these folks worried much about building a great looking pretty URL? I don’t want to talk much on what is URL, Wikip can give you enough information about URL. I will just quickly discuss about the part of URL and which one I’m speaking about. Consider this URL,

http://www.mymindleaks.com/blog/archives/object-oriented-programming-–-encapsulation-is-not-just-hiding-data.html

An URL has the following parts.

1. http -> protocol
2. www -> subdomain
3. mymindleaks -> domain name
4. com ->  Top Level Domain ( TLD )
5. blog/archives/object…data.html -> page / filename
6. .html -> file extension
7. And if you find anything after “?” -> CGI params

Check out here to  what I’m talking about in a visual stuff.

Now, in this post, I’m talking about the 5th part, “/blog/archives/object-oriented…data.html“. which is the page / filename part of the URL.

A quick research on URLs and Page rank.

Can anyone fool Google by writing an url as “10-tips-to-make-you-rich” and the entire content of the URL teaches you “10-tips-to-spend-a-lot”??? Will the Google still fetch the URL “10-tips-to-make-you-rich” when someone tries to search for “how to become rich” ?

When I tried checking the PageRank of the few famous blog over internet, via http://www.prchecker.info/check_page_rank.php , I could infer the following.

This results makes you wonder? Even me. Professional bloggers like Darren Rowse’s Problogger, John Chow, who have million of hits, lots of articles on tweaks, blogging, money making have a less PR rating compared to the simple-plain-old but content ful Norvig or Xahlee’s blog. If you look at Norvig’s blog, you might find URL which aren’t descriptive like [ http://norvig.com/paip.html -> Paradigms of AI Programming]. The Xahlee’s blog have unicode chars in his blog and his blog topic is bit diversified ( computers, math, and little bit of decent porn, yeah ).  Google isn’t that dumb folks.

Even my blog has pretty URLs, and I’ve spent relatively quite amount of time in thinking about URL for my blog., but that’s all purely to give the reader a better idea of what a post is all about. To me, a URL is just a tiny part that makes the user understand what is all the content is about without reading through the content. Relying on this probably might give you a fraction of what SEO’s call, the page rank juice.