It can often get quite amusing watching qualophiles’ self-confidence, mutual assurance and agreement when they talk about something they define as inherently private and un-accessible to third person analysis (i.e. qualia), so they say, but they somehow agree on what they’re talking about even though as far as I’ve been able to understand they don’t even scarcely believe there could be any theory that could bridge the gap between the inefable what-it-is-likeness (WIIL) of personal experience and the third-person, scientific, objective descriptions of reality. How are we to explain this what-it-is-likeness (WILL) if we can’t subject it to what science has been and will always be? Third-person analysis. So, here it is: Qualia, one of the last remaining statues for us to rise on the pedestals of science, but we must stop, qualophiles say, because, … Because what? “Because the what-it-is-likeness of Qualia!“. And believe me that’s the whole argument that they posess if we are to succintly resume their rigurous, inner-gut analysis. I’ll try to expose the absurdity of their stance by making some analogies while telling the story of how architects and designers build 3D models of reaility with the help of 3D design/rendering software.

The 1s and 0s that make the large variety of 3D modeling software on the market today are all we need in order to bring to virtual-reality whatever model of our world we desire. Those 1s and 0s, which are by the way as physical as the neurons in your brain though not of the same assortment (see below), are further arranged into sub-modules that are further integrated into other different parts and subsystems of the computer onto which the software they are part of is running on, so their arrangement is obviously far from aleatory. One needs to adopt the intentional stance in order to understand the intricacies, detailes and roles that these specific particular modules play in this large and complex software.

You can imagine any model of the world you want and bring it to virtual reality. Let’s for example take the city of Rome. Every monument, restaurant, hospital, police department can be accounted for in a detailed model of the city that we can design with the help of one of these 3D modeling programs. Every park and mall, even the people and their biomechanics are so well represented that we could ealily mistake the computer model for the real thing. Here we are looking at the monitor screen from our Godlike-point-of-view. Every point, every line, every plane, every object and it’s physics from that model is 100% traceable to the 1s and 0s, that is, to the voltages on the silica chips that make up your physical computer. You have a 100% description of the city of Rome in your computer in the sense that there is no object in that model that you can’t say all there is to say about it because they’re all accounted for in the 0s and 1s saved on the hard-drive and then loaded in the RAM and video-RAM of your state of the art video graphics card. Let’s call that perspective, the perspective of knowing all there is to know about the 3D-model, the third-person perspective. What’s interesting is that all of these 3D modeling programs have the option to add a cameras to watever world model you are currently developing. Cameras present a scene from a particular point-of-view (POV). Camera objects simulate still-image, motion picture, or video cameras in the real world and have the same usage here. The benefit of cameras is that you can position them anywhere within a scene to offer a custom view. You can imagine that camera not only as a point of view but also as a area point of view (all the light reflected from the objects in your particular world model enter the lens of the camera), but for our particular mental exercise this doesn’t matter. What you need to know is that our virtual camera can perfectly simulate real world cameras and all the optical science of the lens is intergrated in the program making the model similar to what you would experience by looking through a real camera in real life.

The point-of-view (POV) of the camera is obvisouly completely traceable and mathematicaly deducible from the 3D geometry of the current model you are simulating and from the physical characteristics of the lens built into the camera through which light reflected of the objects in the model are projected onto. Of course, the software does all that calculation and drawing for you. But if you had the ambition you could practicaly do that for yourself by taking the 3D-model data from the saved computer file containing your particular model and calculate on sheets of paper how objects from it would look and behave from a particular camera-point-of-view (CPOV), and more to that, you could literaly draw those objects by using the widely known techniques of descriptive geometry (the same as the ones used by the software). But what point would that make when we already have computers that achieve this arduous task for us?

So, we can basically take a virtual trip to whatever part of Rome we want by just jumping inside a CPOV provided to us by the software. We can see, experience what it is like to be in Rome by adopting whatever POV which will be calculated and drawed to us by this complex but 100% describable and understandable computer program. The software would be no mystery to us if we were sufficiently trained programmers, architects and mathematicians. The WILL of experiencing Rome will never be a mystery to us also. Of course, as said above, we can achieve the same thing by making strenous calculations and draw on sheets of paper exactly the same POV drawed to us by the computer so we will experience a similar WILL as the one we experienced when we let the 3D design software do the job for us. Whatever our choice one thing stands to pure reason: We achieved to experience the what-it-is-likeness (WILL) of Rome by deducing it from objective third-person data that we can all share by accessing the program file that contains the 3D-model so there is nothing special about it (This is true only if we do the calculations and drawing ourselfes, otherwise the software does that for us but the whole point is that the experience of the WILL can be achieved and built by/for us using third-person data). The WILL only seems to be some other kind of thing because of it’s circumstantial relatedness with the idiosyncrasies of the POV. No need to concoct metaphysical meanings because of this relatedness. The WIIL is all accounted for, we know all about it: how it comes to existence, how it is 100% physical but non-reducible because of its intentionality, and how the circumstantial relation to its POV makes it seem as if its something separate from it but that’s an illusion. The WILL is the intentional interpretation of the mathematical description of the physical objects’ properties and relationships to each other which the POV represents. The WIIL and the POV represent the same thing but each are different interpretations if it: one is a reducible, mathematical description of all the objects in the POV, the other one is the non-reducible, intentional interpretation of all data contained in the POV taken as a whole.

The what-it-is-likeness (WILL) of points-of-view (POVs) in our model of Rome are unique in the sense that they each have idiosyncrasies in the arrangement of points, lines, planes, colors and light reflectance that make up the objects in the model, idiosyncrasies caused by the perspective that we randomly chose to be a point or a certain area (lens of the camera) on the map of our model onto which the light reflected by some of the objects from that model are projected onto. The WILL is 100% mathematically, geometrically described and accounted for by the calculations and drawings done in order to design that POV that we experience the WILL through. To make it more clearly lets describe the relatioship between the WILL and the POV a little more! The WILL is not something separate from the POV in one important sense and here sits the crux of my argumentation: The POV which was infered and created from the objective 3D-model, third-person perspective of the city is the WILL in the sense that all we need to know if we are to describe the WILL is the mathematical description of the POV and that is all. For someone to experience objects contained in the city model through a specific CPOV that is how WILL come into existence. The sole act of accesing that POV is the WILL. The question “And then what happens?” has no meaning here because nothing happens next. As I’ve said above you can think of POVs as reducible in the sense that they can be accounted for mathematically by knowing each coordinate of every point in its description, and you can think at WILL as a non-reducible, intentional representation of the objects described by the POV taken as a whole. How the whole world is taken as a whole through the lens of the camera-point-of-view (CPOV) by whatever remains on the other side of the lens is the WILL and nothing more is there to be said; the story is complete.“Can you describe this WILL?” Of course, by providing you with all the coordinates of all the points and planes and surface properties that describe that POV through which this wholeness of experience of light reflected from objects in the model comes to reality. How did i get those points and planes and their properties? Again, I got them from the 3D-model of the city. Everybody in my office has access to that file i can provide it to you. Qualia disqualified? You bet!

Something on privateness now. The WILL is only private in the sense that only something that experiences a certain POV can experience it’s WILL but that’s all. Can this POV be shared with others? Of course. After we create that CPOV in the computer program we can save it to a file and send it via email to whatever part of the globe you want for someone else to experience the WILL of that POV. So the possibilty of sharing it with others make it a not very good candidate for privateness. POVs are only unique, but hardly private so let’s not confuse the terms. The same, reason should say, goes for the qualia of color, smells, etc. So, I doubt there is any difference with these types of experiences. What it is like to see a color is just experiencing the complete model of a part of the world from a certain POV. Why can’t that POV be deduced and infered from the widely agreed-upon, sufficient, scientific data eludes me so far as i can see, so that’s why the qualophiles haven’t proved anything yet. I doubt they’ll ever will. If we knew almost everything there is to know about the particles and forces that make up our world we could be able to build models of whatever brains we’d like that could experience all there is to be possibly designable as an experience.

Daniel Dennett’s RoboMarry shouldn’t have a hard job at building color into herself without access to the already build in color-modules that are part of her 100% sillica made brain. And that’s our next story.

RoboMarry has a busy afternoon

In one of his more recent books, Daniel Dennett answered critics whom do not share his position on the possibility that Jackson’s color-bereft Mary, recently eliberated from the black&white, grey-shaded room which she inhabited in the course of her lifetime, could not be fooled into believing that a blue-colored banana shown to her by her masters is in fact yellow. Even though Mary did not experience any colors in here lifetime she somehow managed to put herself into the dispositional states of yellowness and blueness with the help of scientific data she gathered and made sense of in her black&white room. Mary would not be at all fooled by the cheap trick her masters tried on her but Dan’s critics said Mary wouldn’t be able to pull this task off. So Dennett devised another but more inginious intuition pump: Locked RoboMary. From now on my story will differ a bit from Dennett’s in order to make my point clearer (You can check the original story in Sweet Dreams).

Let’s replace Mary with RoboMary: a robot just as adroit in cognitive skills as any other human being but much more rapid in thinking and with a greater bandwith for information aquiring than any of us could ever imagine would be possible in the future even by today’s standards of technological advancement.Even it she’s a standard Mark20 model RoboMary was stripped of her HD Color Cameras and was equiped with bulk black&white CCDs that have the same performances and resolution but cannot compute colors. Also, RoboMary had been resticted access to her color-experience modules that are part of her sillica-made brain by some set of plugins installed into her by her masters before she was activated. So, RoboMary had never experienced, and could neither experience colors through her black&white cameras because they can’t render color, nor ever be able to put herself into the state of experiencing red because she was denyied access to the color registers that were accessible by her color-experience modules now blocked by the plugins. So Locked-RoboMary, trapped in her black&white room, with her black&white CCDs, without her color responsible parts of her mechanized brain apparently could never be able to experience colors. Or would she?

Even though her electronic color-experience modules were blocked by the plugins installed at birth into her brain-kernel, the design plans for that part of her electronic brain can be accesed by her if she is trained enough to hack into the servers of the corporation that happens to hold the patents for Mark20 robots. Being trapped in a black&white room in one of the hundreth buildings of that corporation makes it all much easy because she has non-stop general-level network access to databases full of general design data
files of products just like her. More to that she can converse with other Mark20 robots. And, low and be-hold, RoboMary managed to hack into one of her robotic friends’ computer some months ago by installing a version of a tojan horse that she managed to program in her spare time; the fun part is that her friend which is now part of the developing team for Mark21 models thanks to her months of training and million-dollar software installed into her has higher level network access to the complete design files for Marc20 robots. That’s how RoboMary managed to understand the whole hardware and software that makes up her brain and her, now-missing, HD Color Cameras. She completely understand the functionality of whatever parts make her color-experiencing modules. She understands the physics of colors, has vast knowledge of vission in humans and how is that wired into their brains. Having access to Moogle, which is now the greatest and most used search engine on the Internet3 network, she can easily access all information having to do with vission and vission systems. Nothing about vission and the world of physics, biology, artificial-intelligence and bio-technology is un-known to her.

So, on Sunday afternoon, having some hours off because her training has ended prematurely due to failure of the all the design&development database server farms in the building she happened to be installed, RoboMary put herself on the task of building into herself the experience of colors which were described by her robotic friends as very aweqord and unusual tools used to study the surface properties of objects. She was now ready to do this because she gathered all the data which was needed in order achieve this task. All she lacked up until now was the computing power from the supercomputer located in her building and which she now had access to because its processors are not as stressed in this afternoon “thanks” to the cessation in normal operation of the database server department; she could now use that those extra flops for herself in order to see what’s so special about these colors.

Being locked inside her room RoboMary had no coloured object she could study. Nothnig coloured ever touched her senses so she had to make use of the ingenuity which always made her the adroitful robot she proved to be. Having access to the higher level network though the trojan she installed in her robotic friend’s computer she could replicate and simpulate a complete digital model of her brain (and the original HD Color Cameras that ussualy equip Marc20 robots) inside the currently laid-off supercomputer located in her building; that would be no problem to her because she managed to steal all the Marc20 design files; all she needed now was a few hours in order to built the model into the system and to make a few thousand simulations of that model using as input the few terabytes of video-data gathered from all the security cameras spread inside the corporation building complex she was living in (all those stollen video recordings were in color but that was no use to her because the LCD screen inside her room was black&white also) plus the gigabytes of scientific information on vission systems, optics, and colors. But how was she going to put herself into the state of experiencing colors if there is no color tingling her senses? All was black& white around her.

Well, if you remember the story of how architects create specific camera-points-of-view (CPOVs) inside their 3D modeling software in order to experience a certain point-of-view (POV) of whatever model of reality or of their imagination they are designing, maybe building color experience inside oneself without ever having experienced colors may not seem that unbelievable after all. Remember that RoboMary knows everything about the physical world there is too be known. Couldn’t she simulate (that is by a third-person perspective of course) what the brain state of a Marc20 robot would be upon experiencing colors using a computer model of this type of robot and subjecting it to a completely digital replica of a LCD monitor screen onto which the stollen colorised security videos would be projected onto? The CAD/CAM software for integration of optical and electronic mechanics in 2050 is highly advanced so this wouln’d be at all an impossible task; it’s would be quite ordinary in fact. Having access to the brain states of the simulated Marc20 brain while its mind experiences colors RoboMary could easily make some print-screens of those states and put herself into that specific POV that would allow her to experience what-it-is-likenes of colors. Also, having a complete list of all the belongings of the corporation, their GPS position, their colors, that means she could easily deduce from their position in the stollen videos how a specific object’s color is named so that she could easily build into herself the color-verbal associations that every other Marc20 robot and human being has already built in. So, when the “playful” scientists release RoboMary from here color bereft room and give her a blue banana they will be the ones amazed by the lack of non-astonishment in her behavior; RoboMary will completely call their spoof. Many will deny that the above story could ever be true or, more interestingly, some will retort that what RoboMary did was cheating. But why is that so? Is it failure of imagination perfaps?

Consider what Torin Alter has to say about Dennett’s Locked RoboMary intution pump:”Why does putting herself in state B enable RoboMary to know what it’s like to see red? B is a dispositional and (let us assume) non-phenomenal state; there is nothing it’s like to be in B. Nevertheless, B involves color phenomenology in that it contains the relevant phenomenal information. Therein lies the problem for Dennett’s argument. By putting herself in a state that involves color phenomenology, RoboMary cheats. Pre-release Mary should be no less puzzled about B than she is about seeing red. If she lacks phenomenal information about seeing red, then she lacks the phenomenal information that B contains. If there are open epistemic possibilities about the nature of phenomenal redness that she cannot eliminate, then there are open epistemic possibilities about the content of B that she cannot eliminate. RoboMary comes by her phenomenal knowledge of color experience not by a priori deduction from physical information but rather by putting herself in a nonphenomenal dispositional state that contains the relevant phenomenal information. (The case for Qualia, p252-253)”

So Torin Alter’s argumentation goes like this: “Why should architects that adopt certain camera-points-of-view (CPOV) in their 3D model of Rome come to experience the what-it-is-likenes (WIIL) of Rome? There is nothing like to be experiencing something from a poinf-of-view (POV). CPOVs are from-this-world, non-penomenal (not-metaphysical) descriptions of reality so how can they account for the WIIL of Rome, right? By accessing the description of the CPOV and experiencing the “sudden” and intentional wholeness of this whole richness in description architects cheat because they’ve already acessed the POV. There is more to the what-it-is-likeness of the POV than its mathematical description.” That’s nonsene of course! The arguments don’t line up and are obviusly self-contradictory. It’s like saying the specialeness of POVs are not their mathematical description but the fact that they have something special and out of this world but that is just an illusion because WIILs are intentional representations of the richeness in detail of the descriptions of POVs and that is all there is to it as I’ve stated above. So what Alter’s actually saying is that if up to now color-bereft RoboMary would manage to achierve this task of putting herself into the experience of seeing colors only by using third-person scientific data that would mean qualia is just some messed-up term that describes from-this-world phenomena and that would make the mistery go away! How else would Mary build into herself the colors she now enjoys only with third -person data if the “color quales” we’ren’t completely accoutable and traceable using the physics studied by third-person objective data? So, RoboMary’s gotta cheat, Alter says, otherwise colors. qualea wouldn’t be out of this world. Alter’s got an agenda all right but i doubt is finding the truth if he keeps postulating thigs out of this world which will, by definition, defy scientific explanation. Let’s not confuse failures in imagination with truths about reality.

And still more, some may say what’s true for architecture and 3D modeling is untrue when talking of special phenomenla like colors, pains, etc. But then again, why would that be a possibility worth takinng into cnsideration? What qualia is , this what-it-is-likeness is not something meaphysical, undescribable by third-party science; it is in fact it’s just the intentional interpretation of the apparent immediatnes in understanding of the richenes (which is 100% accountable) of whatever particular point of view we are experiencing at the moment. The richness of the POV and its acknowledgement is the what-it-is-likeness; there is nothing metaphysical about it. By using only third-party, objective data RoboMary built into hereself the experience of color so how could she be cheating? How could she put herself into experiecing inefable, private phenomenal qualities of colors by only using scientific data? Would that be because colors are fro mthis world, not so inefabile , private qualities after all? Qualophiles may retort by further stating that the POV’s escription doesn’t explain the speciallnes of the WILL but that is just an illusion because the WILL is the apparently sudden intentional (see above) interpretation of the richness in information contained by the description of the POV. The what-it-is-likeness can only be taken as a whole. There’s no mistery to it.

Just like an arcihtect enjoys the custom camera-point-of-view of whatever properties he wants it to have produced by the 3D modeling software he uses the same way Marc20 robots are given imediate representations of color experiences through the HD color cameras they posses and are able to acknowledge that richness of information through theit color-experiencing modules. In the case of RoboMary that couldn”t be possible because she was bereft of the HA color cameras and her color-experience modules. But she managed to get around this problem, just like architects that can calculkate and draw camera-points-of-view (CPOVs) without the help of computers RoboMary managed to “calculate” and “draw” to herself the WIIL of colors. If was just that it took a lot more time, but it was worth it: she could now appreciate the mechanisms that bring colors to reality; and odly enough, colors are so much more interesting because she now knows that what brings them to realiry are just physical objects build into modulels that are further arranged into intrichate systems of which’s functnioality is all that matters.

        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;
}