Thursday, July 26, 2012

I was eagerly waiting to dig into Boot to Gecko, build it and run on my Linux machine. I am amazed by concept of using collection of webApps to act as Desktop environment for an OS. Boot to Gecko (B2G) is a new mobile operating system developed as part of the Mozilla project. It uses a Linux kernel and boots into a Gecko-based runtime engine, which lets users run applications developed entirely using HTML, JavaScript, and other open web application APIs.

So what does Boot to Gecko stands for ? Gecko is a Rendering Engine used by Firefox. So they want you to boot up your mobile device directly to Gecko rendering engine-which is responsible for rendering web pages in your firefox browser. Developers contributing to Mozilla have placed all the pieces together to create a complete desktop environment around the Linux Kernel. This is similar to what we have in most of Linux distributions where GNOME is the desktop environment for Linux Kernel.

Another core component of Boot to Gecko project is Gaia, a collection of web apps which make up the UI for the desktop enviroment. All you need to know in order to contribute to this project is HTML5 ! Yes, You read it right, its HTML5. You can develop apps on the fly with HTML5 and rich media and use it.

Mobile applications are majorly categorized into 3 categories: Native app, Web app and the Hybrid app( mix of both). So majority of applications being used in the current trend are Web apps and the hybrid apps built using HTML5. Thus, it is a great opportunity for app developers to publish, test their apps on Boot to Gecko and enhance them to explore rich API of the OS.

The concept is to use HTML tags to render application. application will consist of tree of widgets which are also written in HTML5. The rendering engine, Gecko is then responsible to interact with Gaia, run time engine and the Linux Kernel to perform operations. The best part here is that this projects allows developers to explore OS level API, phone level API using HTML tags itself.

So lets dive into steps on how to build B2G Desktop on your machine and start it.

Checkout Gaia

Now checkout Gaia in order to create a profile for running the desktop builds using git. This is a lengthy process, a .bz2 file of approx sixe~160MB is downloaded. So be patient:
$ git clone git://github.com/mozilla-b2g/gaia

Build Gaia

Once you are done with checkout you need to build gaia profile using following command:$ make -C gaia profile

This step creates a profile to access gaia interface. This is very time taking step as it downloads another .bz2 file of approx ~332MB.

Run B2G

Once your make process is complete you can run the B2G desktop build by using this command(make sure you are within b2g directory):$ ./b2g -profile gaia/profile

Sunday, July 22, 2012

We have seen a complex process involved in building sugar on fedora 14 using JHBuild. Now we have an easy way out to build and run sugar by using sugar-build.

sugar-build it is an alternative of sugar-jhbuild developed by Daniel Narvaez that allow us to get a development version of Sugar easier than with sugar-jhbuild. Also, it works on Fedora 16, 17 and Ubuntu 12.

Yesterday, I was able to build sugar on my Fedora release 17( Beefy Miracle). So here I am sharing my experience with sugar-build.

These are the steps to build and run sugar on the fly using sugar-build:

Get the source code

You need to get the latest repository of sugar using git

$ git clone git://git.sugarlabs.org/sugar-build/sugar-build.git

Make

Then run the make command to build it( It usually takes 20-30 mins depending on processor and RAM)$ make

you will see such message once make is complete:

Run
Once the make process is complete you should be able to run your sugar environment$ make run

and here you go....your sugar is up and running!
You can switch between your fedora environment and sugar by Ctrl+Alt+F1 and Ctrl+Alt+F3

Saturday, July 21, 2012

In this post I will describe the process of building Sugar using JHBuild. You can use Debain, Fedora or Ubuntu for this process. Fedora is suggested to avoid conflicts of you want to share your code with community.

Make sure you don't follow the following process as root to avoid any unpredictable results that can affect your system.

Make sure you have these installed in your system before starting the build process:

python: The sugar-jhbuild command is a Python script, so you need the Python interpreter.

git: To get the source code of sugar-jhbuild itself and many other Sugar packages you need the git
command-line tool from the distributed version control system of the
same name. In many distributions the minimal package you need to install
is "git-core".

subversion: A few packages (as of January 2010, only squeak and part of etoys) do not use git, and you need the svn command-line tool from the Subversion version control system to get their source code.

There are basically two ways to do: one is to git clone the sugar base and build it( This will bring out latest code base from git) and other approach is to download the jhbuild zipped file, extract it and start building it.

First approach: git clone the sugar base and build it( This will bring out latest code base from git repository

The first approach gives issues most of the times. Let's dive in details and see what error it gives and what is the root cause for it ?

Check out sugar-JHBuild

Create a directory within your home directory:

So I will be checking out sugar-jhbuild within:/home/kartik/Sugar_Repository

Friday, July 20, 2012

To all free software distribution evangelists !! You'll love it :D

This time I am sharing my experience with Sugar. Sugar is an open source desktop environment designed with the goal of being used by children for interactive learning. Developed as part of the One Laptop per Child (OLPC) project, it is the default interface on OLPC XO-1 family of laptop computers, but also runs on most computers' hardware. It is available as a LiveCD, as LiveUSB, a package installable through several GNU/Linux distributions, or on Mac OS with virtualization.

Sugar is now developed under the umbrella of Sugar Labs, a nonprofit spin-off of OLPC. Unlike most other desktop environments, Sugar does not use the "desktop", "folder" and "window" metaphors. Instead, Sugar's default full-screen activities require users to focus on only one program at a time. Sugar implements a novel file-handling metaphor (the Journal), which automatically saves the user's running program session and allows him or her to later use an interface to pull up their past works by date, activity used or file type.

The best part of any open source project is that anyone can get involved in it and contribute to it at anytime :). You can checkout the code, go through it, fix the bugs, make changes to code, share the updates as patch with the sugar community. You can become volunteer, Donate online, become a translator, provide support, use your technical knowledge and skills to develop software for SugarLabs.

Sneak Peak into Sugar

This is the home screen for Sugar. Here all the icons you see are links
to activities. The user is allowed to run single activity at a time.You will find activities like pippy, browse, calculate, read, chat, turtle art,etc which have been developed/under development for interactive learning. Each activity has been developed by taking into consideration a definite set of factors that ensures good usability design principle.

An activity is easy to use program developed mainly in python and GTK+. GTK+ (GIMP toolkit) is the native GUI library used for developing cross platform applications. The cross platform nature of Sugar makes it available for Linux distributions, within VM on windows,Mac OS X. It is also available as USB-bootable Linux distribution("Sugar on a Stick")-using this you can install on your hard disk and start using it. Apart from these, it is available forOLPC XO-1.

The awesomeness of sugar is that simplicity is the prime concern in development which is supported by variety of developers across the globe and it is used within a noble project, OLPC.

Thursday, July 12, 2012

This post helps you to write your own simple HTTP Web server in C language. This will give you a direction on how to proceed with writing web server using Berkeley Sockets( part of Berkeley Software Distribution). Berkeley sockets (or BSD sockets) is a computing library with an application programming interface (API) for internet sockets and Unix domain sockets, used for inter-process communication (IPC). We will get in details of socket in further section.

Lets discuss about traditional client-server architecture. Server is a process/layer which is listening on a port for requests to serve resources. Client is a process/layer which is requesting for the service or resource hosted on the server.

Server listens on a specific port for requests and respond to request on same connection. A socket is basically combination of IP and port number i.e. [IP,port number] defines a socket. As per TCP/IP software stack we can have TCP connection as well as UDP connections. Each have specific purpose. TCP is a connection oriented protocol and UDP is not connection oriented.i.e it send packets independent of each other. UDP does not guarantee delivery of packets.

Lets consider the flow of socket communication between client and server : The diagram shown below describes sequence of function call made to establish socket connection and exchange data.

Server:

1. Invoke socket() function to get socket identifier. set options for socket if required using setsockopt()

After writing this code, compile it and run it. I compiled this code using GCC compiler version 4.5.2.GCC comes within Linux OS. For windows systems you can download minGW which consists of gcc, g++,etc.

Once you start the server by double clicking server.exe file you will see like this:

Now open up browser and navigate to URL : http://127.0.0.1:8080 and see the server responding to your request with web page. i.e HTML data:

and in the server console you can see the request structure and response returned:

I hope this post helps you in understanding the concept of socket communication and writing a simple HTTP web server in C language.

Sunday, July 8, 2012

This post describes the concept of execution context in Apex. We are aware that Force.com enforces governor limits to ensure that no
single tenant is completely using the runtime engine resources. Earlier it was different for apex class, trigger, anonymous apex code block. But now
they have generalized it for execution context.

So let's dive in following section to get more insight.

Consider we have a class:

And consider submit() method is invoked when a button is clicked. This method inturn invokes 3 other methods: method1() then method2() and finally
method3() of ABC class. So here is how execution takes place:

Starting from "Submit()" execution start point, Force.com runtime engine considers beginning of execution context. It involves all actions
like arithmetic operations,other method invocations, service invocations performed from this point as part of same execution context till the record
is finally committed to database. So number of SOQL operations performed by each say method 1 makes 20 SOQL queries; method 2 makes 30 SOQL and
method 3 of ABC class makes 120 SOQL queries, then on total SOQL made in execution context will be 170. Thus runtime engine will throw error saying
"SOQL limit exceeded". Reason behind this is governor limits.

Force.com enforces governor limits to ensure that no single tenant is completely using the runtime engine resources. Thus it has limits on number of
service invocations or callouts made in a execution context and that is 10. In order to overcome such situations we can make use of asynchronous
methods in Force.com to invoke external services. There is no such limit on number of invocation in their case.

I hope you find this post helpful in understanding the
concept of execution context within Force.com platform.

Sunday, July 1, 2012

Have you ever thought of sharing your functionality to outside world where someone like you would like to consume that functionality in his app ? How you have been doing that till now....by sharing shared library or by dynamic link libraries or by sharing the actual code ? :) And how many times you got feedback asking to resolve compatibility issues due to language constraints?

The best way to share your functionality/logic with others is through Web Services. W3C established two frameworks SOAP and REST for web services. They have defined the standard format in which two systems will interact using web services.

The main differences between SOAP and REST based services:

REST based services are light weight as compared to SOAP

SOAP based services are secured as compared to REST. If you are creating a REST based service, then you need to explicitly take care of securing it.

REST based services work closely with OAuth: the open authentication model that is followed by most Web2.0 apps.

SOAP and REST based services accept input in XML and JSON format.

REST based services provides response in XML and JSON. SOAP does the same but the response is wrapped within SOAP envelop with header and body.

In this post we will see how to create a web service in Microsoft .Net framework using Visual Basic language.

NOTE: I have used Visual Studio 2010 for describing this.

Steps:

1. Goto File>New Website> ASP.Net Empty Website.

2. Right click on solution in Solution explorer> click on Add New Item

3. Select Web Service, set its name as MyService.asmx and click ok:

4. Now you can see the web service "MyService.asmx" file and code file "MyService.vb" is added to solution

5. Double click on MyService.asmx to open it :

I have written web service method "Greetings" as example. You can write your own web service method in similar manner.

The important thing to keep in mind is that when you are publishing your web service make sure you set the appropriate namespace for your service. Currently it is by default value "http://tempuri.org".

6. Hit Run(F5) to start Cassini( your local web server that comes with VS). This will take you to the service description page where service is available for consumption:

7. Click on the service name "Greetings" to open the page from where you can test the web service:

Enter the name parameter and hit "Invoke" button and see the result :

8. You can hit navigate to the URL : http://localhost:30149/WebSite1/MyService.asmx?WSDL

to view the WSDL file for this service:

You may then share this WSDL with the consumer of your service. Then it is very easy to generate the client using WSDL to invoke the service.

I hope you find this post helpful in understanding how to create SOAP based web services on the fly with .Net framework.