First of all, if you want to start developing Android applications you’re going to first have to get used to the Java programing language because this is the means by which you’ll code your applications. Of course, if you pretty savvy with C++ or some other object oriented language then simply having some good Java tutorials bookmarked (i like this one) and learning it on the way will not be a problem if you think you’re up to challenges that lie ahead.

Now, what is an Android system? It’s practically a complete development environment with a complete software stack which contains the operating system (based on the Linux 2.6 kernel), a middle-layer application framework, a set of C/C++ libraries used by various components of the system to which you have access through the application framework mentioned above, and some core applications that you can also have access to, programmatically (I’ll explain below how why this is possible).

Having the Linux 2.6 Kernel at the core of the operating systems makes the platform pretty safe and well established when considering the Linux Kernel process management, memory management, networking stack, and driver model have undergone a long and arduous process of R&D for years.

        The most important thing you need to know is that each application runs in its own safe-box: it has a unique user ID assigned by the OS, a unique process and therefore a unique virtual machine. No application can access the files or the memory of another one without being allowed to do so by Android’s kernel system.

Application Components:

The second most important thing is the way applications are structured. Each application can be comprised of four distinct parts called Application Components: the Activities, Services, Content Providers and Broadcast Receivers components. What is remarkable is that from your application you can access components that belong to a different application and this is not achieved by loading the code of that component into your process’ address space; no, it’s simply executed within its own kernel assigned process that has its uniquely assigned user ID. Because the Android system allows every application to start another application’s component you can practically use components from already developed applications into your own as if they are an integral part of your program. Pretty neat!

Because each application is loaded by its own process into its own address space, and because each application can start (use) any others’ component this means that there is no central station, no entry point of the whole system or as Android’s Documentation puts it “Android applications don’t have a single entry point (there’s no main() function, …..)“.

        What are the application components? Activities are simply a singe screen or window that contains a user interface. A certain application can contain lots of activities designed to achieve a specific goal. They all are part of the application even though they are treated as separate when you program their functionality.

Services are simply background processes which can run for the whole execution time of the application. You can think of them as the core/heart of you application because they can coordinate the activities for the other components, they can trigger specific actions at certain times, they can access the network, etc.

Broadcast receivers are simply listeners for system broadcasts or application broadcasts. Your own application can generate broadcasts that can be catched by Broadcast receivers. These components can have a wide variety of uses one being that they can be used as triggers in your application’s workflow logic when certain system events or other application generated events take place.

Android Architecture

And finally, Content Providers. They are data storage providers: databases, file system data, web storage, etc., these can all be accessed by means of a Content Provider. What’s interesting is that different applications can share (read, modify) data contained in the same Content Provider object which is practically a shared set of application data; one interesting example is the contacts (ContactsContract.Data) Content Provider which contains user contact information (such as a phone number) and its associated metadata (such as whether it is a work or home number, email, etc) and can be accessed and modified by applications that have the appropriate privileges (meaning the ones that have been programmed to have these privileges, and subsequently have been installed by the user of the device).

Activating Application Components:

The Activities, Services and Broadcast Receivers components can be activated directly by announcing the kernel your intent to use an activity that is part of your own application or someone else’s, to start a service, or to start a broadcast. You simply have to pass a Intent object to the Android system through a specific method (startActivity() or startActivityForResult() for Activities, startService() or bindService() for Services, and sendBroadcast(), sendOrderedBroadcast(), or sendStickyBroadcast() for Broadcasting).

What is more interesting is that besides, of course, being able to specify the name of the class of the component which you wish to start, the Android system lets you act more implicit by allowing you to use another type of intent : Intent Actions : these represent types of actions which you can let the OS handle for you. For example you can let the Android system know that your application is in need for a “send” action of an e-mail, so if the OS finds multiple components that are registered with this action it provides the user with a list to chose from. You can even create your own application components and register them with your own actions. Now that’s complete modularity! Genius!

The Manifest File:

The manifest file is practically the application configuration file which the Android System reads in order to find out what components comprise your application. Here you declare all your activities, services, broadcasts, and content providers.

You can even create filters for your application so that only the devices that have the required hardware implementation and the specific software libraries will be able to run it. You can filter for the screen size and density, user input mechanisms, hardware capabilities like the camera, the light sensor, Bluetooth, or the fidelity of the touchscreen, the version of the Android system, etc. You can even create multiple language texts, different UIs for different devices so that your application can automatically load the correct ones with no need to modify the source code. All these can be achieved in the AndroidManifest.xml file.

More here and here.

        We’re going to build a simple Safari extension that will insert a bolded, italicized, Hello World text into the web-page of the current tab after it is loaded.

We’re going to use Safari 5.0 or later in order to have access to Extension Builder, that is, the means by which we’ll build our extension. Extensions were introduced in Safari 5.0, and were disabled by default, so in Safari 5.0 you must enable extensions in the Develop menu before you can show Extension Builder. Extensions are enabled by default in Safari 5.0.1 and later.

[Before we start coding]:
The Safari Extensions Development Guide states that before you can build and install an extension, you need to install a developer certificate. You obtain a certificate by first signing up for the Safari Developer Program at http://developer.apple.com/programs/safari/. You must first create an account and register all your personal information (phone, address, country code, etc – there’s no need of course to enter genuine information if you care for you privacy on the Internet – bogus data will suffice) .

You’ll obtain an Individual ID that will be usable for a period of 12 months. You then have to access http://developer.apple.com/membercenter/index.action and install your certificate by double-clicking the Developer Certificate Utility icon in order to Request and manage your Apple-issued Certificates for Mac and Safari. This launches the Certificate Import Wizard on a Windows machine. You then have to click Create Certificates, then Add Certificate and follow the instructions. Pretty arduous operation compared to what you have to do to get things working in Chrome or Firefox but hey, what are you going to do if you need the thing badly ?! (NOTE: Windows XP Professional and Windows Server 2003 will have to download the following Administration Tools Pack in order to be able to follow the above steps)

After all this you’ll be prompted to download your certificate (safari_identity.cer). You’ll have to double-click the downloaded *.cer file to install it.

[Activating Extension Builder]:
In order to use Extension Builder we’re going to first activate it; we do this by enabling the Safari developer tools when we click “Show Develop menu in menu bar” checkbox in the Advanced pane of Safari Preferences, as shown below. You can access Safari Preferences by clicking the top-right gear button that says “Display a menu of general Safari settings“.

How to activate Develop menu in Safari

We then go to the Develop menu and click Show Extension Builder; In the displayed dialog we hit the + button on the left-bottom and click New Extension, chose the path and the folder name and then insert the required fields of your extension:

Extension Info, Details, Versions, Website Access, Global Page, and Global Storage Settings

The required fields for the above are :

• 1. Display Name: the visible name of your extension
• 2. Bundle Identifier: this is a string in reverse DNS format : your type of website (com, gov, edu, org, and so on), your company name, and the extension name, separated by dots -> ex: com.lexdesign.hello.
• 3. Display Version: the displayed version number for your extension.
• 4. Bundle Version, that is, the internal version number used by the OS. One or more digits separated by periods (ex: 1 or 4.1.2). This is the version number Safari uses when checking for updates.

Chrome, Extension Scripts, and Settings

The optional fields above can contain the following :

• The Extension Chrome section can include am Extension Bar to be included below the bookmarks bar and above the tab bar, which is uniquely reserved for your extension, Context Menu Items, and Toolbar Items, that is, buttons added to the main Safari toolbar (not your specific extension bar).
• The Injected Extension Content section can include Start Scripts, that is, scripts executed before the webpage is loaded, End Scripts which execute when the body tag’s onload event occurs, and Style Sheets: CSS coding used to style the HTML.

Of course there are a lot of other fields. If you want to get the grips with all of them you can check Apple’s Safari Extensions Development Guide -> Using Extension Builder.

Now that we’ve bootstrapped the basic Safari Extension Starting Kit we will start to code the extension that will insert a bolded, italicized, Hello World text into the web-page of the current tab after it is loaded. This application can have various interesting uses: it could be used to insert specialized controls into specific websites that lack certain idiosyncratic features that the user may demand. Let’s begin!

[Injecting the text]:
inject.js is going to be added as an End Script in the Injected Extension Content section of Extension Builder. Being an end script means that the *.js file will be executed after the body tag’s onload event occurs. We’ll also use jQuery for easy manipulation of the DOM. We’ll insert jQuery as an End Script also.

You can get the latest, Minified (compressed) jQuery from http://docs.jquery.com/Downloading_jQuery.

Here is the inject.js file that will insert our Hello World text :

// <inject.js> insert a Hellow World text into the body of the document

function PageShowHandler(event)
{
	injectText();
}

function injectText()
{
    // get the document body
	var pageBody = jQuery('body', document);
	console.log('entered injectText');
	pageBody.prepend('<h1>Hello World</h1>');
}

// wait 100 ms in order for jquery-1.5.1.min.js to be injected also
// if you don't want to wait just change the order of loading of jquery-1.5.1.min.js
//   and inject.js in Extension Builder-> Injected Extension Content -> End Scripts
setTimeout(PageShowHandler, 100);

Please notice that we use the jQuery .prepend( content, [ content ] ) function that inserts content, specified by the parameter, to the beginning of each element in the set of matched elements.

Also, instead of directly executing the PageShowHandler function to insert our text into the body of the document, we user a timer and waited 100ms in order for jQuery to load. So, if you want to instantly use PageShowHandler, without a time, you should change the order of injection of the two javascript files in Extension Builder -> Injected Extension Content -> End Scripts as below:

The order of injection matters; specify the jQuery file first

In the code above we simply used the timer in order to prove that the order of injection matters, of course.

Now, if jQuery is loaded first that means our inject.js file can do its job without using the setTimeout timer function.

// <inject.js> insert a Hellow World text into the body of the document

function PageShowHandler(event)
{
	injectText();
}

function injectText()
{
    // get the document body
	var pageBody = jQuery('body', document);
	console.log('entered injectText');
	pageBody.prepend('<h1>Hello World</h1>');
}

PageShowHandler();

Now you just have to click the top-right Install button from the Extension Builder dialog and that’s all. Here’s the extension in action here :

        You want to move bits inside a byte? Unfortunately, there aren’t any standard functions that deal with these sort of issues so we will have to use some smart and easy hacks.

First of all we need to use the tilde operator (~). Tilde is a bitwise not operator; this practically means that applying it to a certain operand’s binary value converts all the 1s to 0s and viceversa (~b0001 0010 = b1110 1101).

So what’s the use of tilde in our little program. We’re going to use it to create a mask that will delete (make 0) the bit of a certain location, that is, the bit we’re trying to move to another position, but we’ll also delete the bit from the destination position.

For example we have the byte 0xc3, and we need to move the bit from position 1 to position 5. Tilde will create a mask that will be used to delete the bit in position 1 (all the mask’s bits are 1s besides the bit at the position we’re trying to delete from which is of value 0) and position 5 (see line 14 and 15).

The mask achieves the delete of the bit by being AND-ed with our byte. Then we will OR the byte that we deleted the bits from (oldvalue) with another mask that contains the bit – of which value we read at line 12 with 0×01 & ((*our)>>indexold) – we will be writing at position 5. This new mask is of course made of all zeros besides the bit at position 5 which is of value valuetochange(=1 in our case) :

    //  example 1 (move bit from position 1 to position 5)
	//  1100 0011
    //    ^    ^     BYTE        MASK        DEL BIT
    //               bit to be changed position has value 1
	//               1100 0011 & 1111 1101 = 1100 0001
    //               1100 0001 & 1101 1111 = 1100 0001 

    //               DEL BIT     MASK        NEW BYTE
	//               1100 0001 | 0010 0000 = 1110 0001

So practically we begin by registering the value of the bit we want to move in the valuetochange variable. We then delete the bits from both the current position of the bit we want to change the position of and its future position. Finally, we write the value from valuetochange into out byte. This is all achieved by:

	//
	valuetochange = 0x01 & ((*our)>>indexold);         // get the value of the bit to be moved

	oldvalue = (*our) & (~(1<<(indexold)));            // del the bit from position indexold
	oldvalue = oldvalue & (~(1<<(indexnew)));          // del the bit from position indexnew

	newvalue = oldvalue | (valuetochange<<(indexnew)); // write bit in new position (indexnew)
	//

Here’s all the code. I’ve compiled it using Visual Studio 2010, but earlier version should suffice for this little project.

#include <stdio.h>
#include <malloc.h>

typedef unsigned __int8 byte;

byte move(byte* our, int indexold, int indexnew)
{
	byte oldvalue;
	byte newvalue;
	byte valuetochange;

	valuetochange = 0x01 & ((*our)>>indexold);         // get the value of the bit to be moved
	printf("value to change : %d\n", valuetochange);
	oldvalue = (*our) & (~(1<<(indexold)));            // del the bit from position indexold
	oldvalue = oldvalue & (~(1<<(indexnew)));          // del the bit from position indexnew
	printf("deleted: %x\n", oldvalue);

	newvalue = oldvalue | (valuetochange<<(indexnew)); // write bit in new position (indexnew)

	return newvalue;
}

int main()
{
	byte* example_byte;
	byte* new_byte;

	example_byte = (byte*)malloc(sizeof(byte));
	new_byte     = (byte*)malloc(sizeof(byte));

	*example_byte = 0xc3;  //  hex 0xc3 = binary 1100 0011
	printf("\n");

	//*****************************************************
	// example 1 (move bit from position 1 to position 5)
	// example_byte  1100 0011
    //                 ^    ^
    //               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 1
	//               1100 0011 & 1111 1101 = 1100 0001 delete bit from oldindex (1)
	//               1100 0001 & 1101 1111 = 1100 0001 delete bit from newindex (5)
	// new_byte      1100 0001 | 0010 0000 = 1110 0001
	*new_byte     = move(example_byte, 1, 5);

	printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011)
	printf("new byte : %x\n", *new_byte);     // 0xe1 (1110 0001)
	printf("\n");

	//*****************************************************
	// example 2 (move bit from position 6 to position 3)
	// example_byte  1100 0011
    //                ^   ^
    //               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 1
	//               1100 0011 & 1011 1111 = 1000 0011 delete bit from oldindex (6)
	//               1000 0011 & 1111 0111 = 1000 0011 delete bit ftom newindex (3)
	// new_byte      1000 0011 | 0000 1000 = 1000 1011
	*new_byte     = move(example_byte, 6, 3);

	printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011)
	printf("new byte : %x\n", *new_byte);     // 0x8b (1000 1011)
	printf("\n");

	//*****************************************************
	// example 3 (move bit from position 2 to position 6)
	// example_byte  1100 0011
    //                ^    ^
    //               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 0
	//               1100 0011 & 1111 1011 = 1100 0011 delete bit from oldindex (2)
	//               1100 0011 & 1011 1111 = 1000 0011 delete bit from oldindex (6)
	// new_byte      1000 0011 | 0000 0000 = 1000 0011
	*new_byte     = move(example_byte, 2, 6);

	printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011)
	printf("new byte : %x\n", *new_byte);     // 0x83 (1000 0011)
	printf("\n");

	//*****************************************************
	// example 4 (move bit from position 2 to position 4)
	// example_byte  1100 0011
    //                  ^  ^
    //               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 0
	//               1100 0011 & 1111 1011 = 1100 0011 delete bit from oldindex (2)
	//               1100 0011 & 1110 1111 = 1100 0011 delete bit from oldindex (4)
	// new_byte      1100 0011 | 0000 0000 = 1100 0011
	*new_byte     = move(example_byte, 2, 4);

	printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011)
	printf("new byte : %x  ", *new_byte);     // 0xc3 (1100 0011)
	printf("\n");

	free(new_byte);
	free(example_byte);
	return 0;
}

        The four aitia… That is what Aristotle used as tools of mind in order to fully understand all that is understandable about anything in the universe. For example, you want to know what a hammer is? Well, you’ll just have to ask yourself what is the material cause of this object, or what is it made of; that’s an easy answer: it’s made of wood and iron, maybe cured steel or another high rigidity/resistance metal. After this, you’ll have to ask yourself what is the formal cause of this object called hammer, or what is its architecture, its design, how do all its elements hang on to each other, and what are its most inner workings; for a hammer this shouldn’t be a hard question to answer: the wooden rigid stick, which is tailor made for grabbing with one or two hands, is firmly attached to the metallic compact solid mass which represents the hammer head that comes in many forms and sizes depending on what the hammer was designed to do. And here we are at the third question we might ask about this object, and that is what is its efficient cause, who or what natural or artificial industrial process created this object; that’s an easy answer, right?! Yes, a interesting answer for an interesting question, but not as interesting as the last aitia…

What is the final cause of this object? What’s it made for? Well, even though it was designed for a specific purpose like driving nails, forging metal, fitting parts, and breaking up objects, its reason d’etre could be as various as human nature. Who hasn’t heard about Hell’s Angels favorite weapon, the ball pean hammer?! It’s as sexy and dangerous as it can be useful in the house. This reason d’etre, the purpose, the meaning of things stays at the heart of Dennett’s undertaking. Even though we start with hammers and simple things we will finally dodge the most sacred of mysteries… the origin of man, the meaning of life. How will Dennett manage to derive meaning, purpose from nature’s red in tooth and claw, that’s an answer you’ll find by reading the book. Here, we will skim through the ideas of the thinkers that lived before Darwin which laid down the most beautiful but least understood – by friend or foe – scientific theory that ever existed. Beautiful, but what dreadful implications to our human existence it had!

Hell's Angels Ball-Pean Hammer

For reasons easy to understand, much of the answers about the origin and the meaning of life have been bedeviled by naive assumptions and too much irrational wishful thinking. The why questions have been replaced by how questions with the hope that maybe the answer to the latter one would somehow yield a spark of intellectual brilliance that would solve the conundrums of the first… but what a coward way to avoid answering the main problem this treacherous and avoiding road would prove to be!

How did the thinkers before Darwin explain the complexity of nature? John Locke goes at the heart of what many of today’s uneducated users of science and technology still think it’s common sense. Consider for example his following phrase: “So if we will suppose nothing first, or eternal: Matter can never begin to be: If we suppose bare Mater, without Motion, eternal: Motion can never begin to be: If we suppose only Matter and Motion first, or eternal: Thought can never begin to be. For it is impossible to conceive that Matter either with or without Motion could have originally in and from itself Sense, Perception, and Knowledge, as is evident from hence, that then Sense, Perception, and Knowledge, must be a property eternally inseparable from Matter and every particle of it.”

The simple error in logic of the above statement muddled the meme complex of explanations that tried to explain the reason for man’s existence and for the causes of life and complexity. The fact of the matter is that to assume that something complex must derive from something more complex than the thing we’ve started to explain leads of course to a God that has a creator, this assuming we’re not going to throw away the logic in the middle of the argument; that is, the God of God has a God and so on ’till eternity. What is that? Plain bullshit, if you ask me !

So, we needn’t use this kind of recursivity because the scientific evidence proves that nature works the other way around: complex things evolve from things that are not so complex. It’s more like a construction project coordinated by blind and purposeless forces in which cranes build by nature assemble less complex natural systems into more complex ones that have greater degrees of freedom. We don’t have to postulate sky-hooks, that is, god given metaphysical helping hands that defy scientific explanation, because there is a lot that we can explain without taking this road. As Darwin put it, “from so simple a beginning endless forms most beautiful and most wonderful have been, and are being, evolved”.

DARWIN’S DANGEROUS IDEA – Check Reviews on Amazon.com

DARWIN’S DANGEROUS IDEA – Check Reviews on Amazon.co.uk

Much of Dennett’s book is directed at explaining the above logic, but don’t worry; things start to get more fiery in the end once we start to reverse engineer the most complex of cranes: the memes and their most intricate and time consuming effects on the human mind : the quest for meaning, purpose and the perfect ethical algorithm. This i think, is the most interesting part of the book. Dennett deconstructs the erroneous assumption/intuition that makes us think there is a real meaning, a real purpose in life, a perfect ethical course of action that anyone can take. The reality is that there is no real meaning just like there is no real self, (see here), there is no real purpose in life just because there are no sky-hooks; there are cranes that serve distinct natural systems that have distinct interests which will more than likely conflict with each other. Just like Richard Dawkins put it, in this battle “blind physical forces and genetic replication, some people are going to get hurt, other people are going to get lucky, and you won’t find any rhyme or reason in it, nor any justice. The universe that we observe has precisely the properties we should expect if there is, at bottom, no design, no purpose, no evil, no good, nothing but pitiless indifference.”

Do you want to go deep down the rabbit whole? Then read this book !