SpringSters - Blogging Bunch

About a year and half back when we first started MangoSpring we had this vision of making the web a more connected experience. We spoke extensively of web being a lonely experience and “connected everywhere” as our driving mission. We had this exciting contest in the office where teams came up with the best use case for ‘connected every where’ paradigm (winning team members got IPods). MangoSpring SiteGroups and our internal vision of ‘advancing the web one conversation at a time‘ was born out of these discussions and aspirations.

A few days back I came across this interesting article on ReadWriteWeb about the real time web deserving a place in the “next big thing” column. To quote from the article “a real time web can offer social connectedness, interface responsiveness and a smooth user experience that stands head and shoulders above the call-and-response web of the past.”

Wow! that is exactly what we have been after and I was glad to see the good folks at ReadWriteWeb talk about it. Needless to say, we see an immense potential in creating an instant community around a website/service and making the web browsing experience real time.

So how is MangoSpring advancing real time web?. Well like I said our vision is to advance it ‘one conversation at a time’. MangoSpring SiteGroups enables any website in the world big or small, any blog, any web page for that matter to add real time interactivity and conversations around it in a matter of few minutes. The premise is simple:

• Show the people who are on the same site as you are (not necessarily the same page) in real time
• Allow them to talk to each other as a collective group
• Allow them to talk to each other in 1-1 setting
• Allow them to easily carry these conversations with them as they move away from the site by offering rich desktop and mobile access to this micro-community

We are very close to launching SiteGroups and hope that you will be as excited about the possibilities SiteGroup opens up as we are.

One day Anuj (Our Product Boss :)) came to me with some layouts and asked to support all of the following layouts in J2ME application.

All these layouts are combinations of images and strings. Initially, I was worried about the implementation, but after going through the layouts couple of times, I thought Gridbag layout of swings would support all these combinations. I knew how Gridbag worked but didn’t know how I could arrange components in horizontal and vertical cells. The most challenging issue was J2ME’s memory limitations for both jar and jad. We can develop a full fledged Gridbag layout class just like swing but some issues could arise.

• Potential big class size
• We will have to keep minimum instances of components for heap issues, the best case being one instance per component.

So let’s start engineering with minimum requirement of arranging cells.

Here is the list of items which we need to consider while adding components in layout:
• Starting horizontal cell
• Starting vertical cell
• Number of horizontal cells required
• Number of vertical cells required
• Component

All these will go as parameters in the add method.
add(component, start_horizontal_cell, start_vert_cell, no_of_horizontal_cell, no_of_vert_cell)

To store these components, we can have an array of components or some custom defined array list.
Each cell will have some height and width say CellH =20 and CellW = 20.

Thats all.. we are ready to construct a layout class which will hold images and strings.
Say we have two UI classes for rendering a single image MyImage and a single string as label MyLabel.

Here is the code piece for our layout class. We are considering this layout class itself as a component which will make it easy for us to add it to a container.

/**
* A class which can hold any component, which can be rendered at any position
* in this component’s boundary depending upon its cell location.
* This is a Gridbag layout. To create a label of this type with any
* component,
* e.g to add MyLabel at cell position row 0, column 0 with
* 2 horizontal cells and 1 vertical cell,
*
* TestLabel label = new TestLabel();
* myCanvas.addComponent(label);
* MLabel strLabel = new MLabel(”First label”);
* label.add(strLabel, (byte)0, (byte)0, (byte)2, (byte)0);
*/
public class TestLayout extends Component{

private MyArrayList components; //user defined array list
public int cellW = 20;
public int cellH = 20;
public int noOfRowCells;
public int noOfColumnCells;
public boolean showGrid;

/**
* Creates a new instance of TestLabel
* @Param boolean tells whether this Label will should have
* canvas width or width that is neccesary to component
*/
public TestLabel() {
height = 20;
width = canvasW;
components = new MArrayList();
calculateDimensions();
isStatic = false;
}

/**
* this method renders component
* @param Graphics
**/
protected void renderComponent(Graphics g) {
int posX = compX;
int posY = compY;
int size = components.size();
g.setColor(MMasterColors.GREY);
if(showGrid){
for(int i = 0; i < noOfRowCells ; i ++){
g.drawLine(compX, posY, width, posY);
posY += cellH;
}
g.drawLine(compX, posY, width, posY);
for(int i = 0; i < noOfColumnCells ; i ++){
g.drawLine(posX, compY, posX, compY + height);
posX += cellW;
}
}
for(int i = 0; i < size ; i ++){
((MComponent)components.get(i)).renderComponent(g);
}
}

/**
* This method calculates dimensions
**/
protected void calculateDimensions() {
noOfColumnCells = width / cellW;
noOfRowCells = height / cellH;
}

/**
* A method to add component to AdvLabel
* @param MComponent component which is to be added
* @Param byte rowNo cell at row level
* @Param byte Columno cell at Column level
* @Param byte no of horizontal rows required
* @Param byte no of vertical rows required
* @param byte alignment
**/
public void addComponent(MComponent comp, byte rowNo, byte ColumnNo, byte noOfHoriCells, byte noOfVertCells){
components.add(comp);
if(height < ((ColumnNo + noOfVertCells) * cellH))// setting height if needed
height = (ColumnNo + noOfVertCells) * cellH;
calculateDimensions();
int tempX = 0;
int tempY = 0;
tempX = compX + ((rowNo * cellW) + (((noOfHoriCells * cellW) - comp.getComponentWidth()) / 2));
tempY = compY + (((((noOfVertCells * cellH) - comp.getComponentHeight())/ 2) + (ColumnNo * cellH)));
comp.setComponentXY(tempX, tempY);
}
}

public class Component{

public int componentX;
public int componentY;
protected int height;
protected int width = canvasW;

protected void renderComponent(Graphics g) {
}

protected void calculateDimensions() {
}

/**
*Mutator method to set x, y positions
*@param x X co-ordinate
*@param y Y co-ordinate
*/
public void setComponentXY(int x, int y) {
componentX = x;
componentY = y;
}

/**
*returns component height
*@return height
*/
public int getComponentHeight() {
return height;
}

public int getComponentWidth() {
return width;
}
}

Above code is at very primary level which will fulfill our requirement of arranging components in a grid. We can then add (if memory permits ) advanced features like:

• Providing key navigations
• Maintaining and highlighting current component
• Aligning components within the mentioned cells
• Providing more ui specific things like borders, background colors etc.
• and so on….

Resources are always scarce, aren’t they? I have always wanted someone to take care of the resources I need and use. For instance that book I had borrowed from a friend with a promise of returning in 2 days time. Which despite all my good intentions I still forget to return even after 3 weeks have lapsed. In real life it is still a dream, but in my Symbian life I have found someone - “Cleanup Stack”.

Cleanup stack is a place to store the variables which are not member variables of any class but allocated on Heap (defined inside function). The objects are pushed onto CleanupStack once they are allocated memory. And popped from the CleanupStack after we are done with them. In between if any exception occurs (We call it a “Leave” in Symbian ), the CleanupStack Pops the object and calls the destructor of the object.

Few questions are always popped up when we talk about CleanupStack. Lets try to find the answers for some of them.

Q. What are the different types of Objects that we can push on CleanupStack?
A. CleanupStack has three overloaded Push functions.

1) PushL(TAny* aObj): We can put any object (void* in C++)

2) PushL(CBase* aObj): We can put a CBase class object. So it is advised in Symbian to derive your class from CBase. To use the CleanupStack functionalities.

3) PushL(TCleanupItem aItem): TCleanupItem encapsulates the cleanup operation (function pointer) and an Object with it. That function is called if any Leave occurs.

Q. How to Use CleanupStack to handle the object of a non CBase class?
A. We should use TCleanupItem to put the object on CleanupStack of non CBase classes. Using TCleanupItem we can associate an Object with a function which will be called if a Leave occurs.
Q. What will happen if we put non CBase object on CleanupStack?
A. CleanupStack will call User::Free() for the object. But will not call the destructor. If the pushed object contains data, it’s a memory leak.

Q. What if I forget to pop the items from CleanupStack?
A. We get E32User CBase 71 Panic. You must pop an item before you leave a function.

Q. Suppose I have pushed 100 items onto CleanupStack, do I have to pop all of them manually?
A. Not actually. One of the overloaded PopAndDestroy function takes the count which is number of items to be popped and destroyed.
eg. PopAndDestroy(100);

Lastly, don’t use the “Check” function as it is for debug builds used by Symbian. It can crash your application if not used properly.

Every year, hopefuls in the technology industry predict a revolution in mobile technologies and pronounce that the new year will be the year when mobile finally comes of age and takes the world by storm. Barring some interesting developments, that has not really happened yet. Mobile continues to be perplexing for most people to use for everything except basic calling and text messaging. Clearly, mobile has the potential to be more powerful than providing just two services.

Both these functions are little more than actions that consumers have been used to for years, and as a result, need little change in their behavior. Voice calls work quite the same as telephones that we have been using for at least a century now, and text messaging is quite akin to emails that people are reasonably well used to. Can other applications be built that require minimal changes to consumer behavior, or at least require a couple of simple clicks that one can get used to as quickly as making a voice call on the mobile?

That is the question that many in the industry are trying to answer today, and there are some important tectonic shifts in the mobile industry that are underway that are slated to change this landscape. Here are some of these shifts:

1). For the first time, major software players are entering the erstwhile carrier-dominated mobile industry in a big way. Until now, perhaps only Microsoft was a pure software player with a mobile operating system. They have played in the enterprise mobility market with sophisticated business users and have faired well in that, but have not quite been able to bring it to the masses. No other player (either big enough or creative enough) brought a user interface design to mobile that was intuitive enough for mass users to adopt and for carriers to push.

More than being a hype, Apple’s iPhone is a sign of changing times. Even if it doesn’t itself gain a prominent market share, it is changing how software for mobile is being looked at. The ripple affect it will have will finally bring some serious creativity and ease of use to many mobiles and devices. A simple feature like visual voice mail was something long time coming. The fact that no carrier could think of it is a tell-tale sign of the difference a software and user-interface-oriented company can bring to the table in this industry.

It is still early days to take a call on Google’s Android but if Google is able to translate its simplistic user interface philosophy to the mobile world, that would be a second successful software player that we can talk about. For now, its premature and Google still has to prove itself in this new landscape.

Nokia-backed Symbian is another player that has a powerful and stable platform that can give Apple a run for their money. Symbian interface again lacks the simplicity that a lay user needs and still consists of relatively complex browsing of folders and accessing applications through shortcuts etc. However, with some effort and creativity, they can get it right.

2). The advent of widgets-based design in desktop as well as web will redefine the structure of mobile operating systems at some level. User acceptance of widgets is far more plausible than expecting users to run complex “applications” on their tiny devices. The difference is not merely in the vocabulary, but the whole way in which a service is presented to the user on mobile including automatic updates, hard versus soft updates and the intelligence being split between the client and server component of the widget. The concept of one-widget-one-function will be the driving force behind mass user acceptance, as users like simple, one-click icons on their devices that perform a well-defined and useful function for them.

3). No product is complete without great packaging. For products like Coca Cola, packaging might be as obvious as using a bottle (instead of a box, let’s say!), but for software, packaging involves navigating the intricate web of standards, business models and partnerships. A lot of people associate the success of iPod with its looks and Apple’s marketing, but dig a little deeper and you cannot miss the profound impact of iTunes and iTunes Store (and the resulting deals with record labels) behind the success of iPod. They say that content is king on the web and there is no reason to believe otherwise for mobile. Google maps on the Apple iPhone is a great example of how a good partnership and packaging could work in the mobile world.

Google Maps is actually a great example of all of these three elements (great interface, widget-like architecture and good partnership) working together to deliver great content to users in great style. There are umpteen examples of each of the three elements successfully in play on the web, from Netflix to Amazon to blogs to Facebook. It’s only beginning in the mobile world and all the plumbing for a great user interface, packaging and content delivery are only beginning to be put in place. In a sense, it is still early days and the field is wide open.

Carriers are often accused of being “closed” to some applications that can hamper their revenue stream. However, if the above shifts do take place during 2008 and beyond, there is no reason for them to not wake up to the rising potential of mobile and the new revenue streams mobile software can offer them. The key still lies with the software vendors to provide useful applications in a manner that is easily understood and accessible by a lay user.

Dare I say then that 2008/2009 will be the year of the mobile?

Celebrated with cakes,a treasure hunt and a special visit by the Santa!

From the first day of our existence in the web 2.0 sphere to today what a great year it’s been and what an amazing adventure! The past year saw us going through various growth spurts (scrums), immunization shots (code reviews), positive parenting (Happiness Manager) and have crossed various milestones.

Like any other one year old baby MangoSpring is ready to take the first baby steps in the web wide world. It’ll be just a matter of time before we learn to walk and then sprint.

Springsters celebrated the day with cakes and a special treasure hunt that had them running around the office, the parking lot and even the restaurant across the street that caters to their hunger pangs. It was such a gripping affair that the designated photographer of the event forgot all about the camera and photos to be clicked and we have no pictures to share with you

Since our birthday was just around Christmas Santa also came visiting while the Springsters were at a pot-lunch. Check out some of the photos below .

Happy New Year from the Springsters to all of you!

All through September and October the pace was frenzied as we geared up for the beta release of Pproductl. With the release out of the way on November 2nd Springsters headed to the beaches of Goa for some fun, sun and relaxation. It was a well deserved break and Springsters made the most of it spicing each day with a different experience. After a lot of online search we had zeroed in on Alcove Resorts on the Little Vagator beach. With a breathtaking view of the sea and coconut trees, open air sit outs facing the sea, it not only lived up to our expectations but also set the right mood for the holiday we will cherish forever. Surf boarding, para-sailing, hiking, campfire, river cruise with fishing and dancing, driving through the winding streets of goan villages all night, getting ourselves tattooed and chilling out in the pool with a drink in hand, visiting some good night spots, we packed all this and more in the four days we spent at Goa. As Goa wove it’s magic on Springsters the outgoing ones turned gregarious and the quiet one’s came into element of their own. Awesome food and free flowing spirits helped :).

Our web UI guys metamorphosed into “official” photographers for the trip, here are a select few capturing Springsters in action or preening especially for the camera!

Much has changed in India since the mid-nineties. The opening up of the economy gave India access to foreign markets. One place India grabbed the opportunity was of course, IT exports. But even before all the hoopla of IT services, changes were already taking shape. Small schools in nondescript towns started introducing computers for sixth graders and business systems were being automated using computers. While, automation of systems such as payroll and inventory were not new to India even in the eighties, what was new (world over) was availability of cheap personal computers for everyone from a college graduate to big corporations. Things were chugging along in their own sheepish pace until the mid-nineties, when we realized that the rupee had depreciated to half it’s value while we were sleeping – from 18.1 on 2nd Jan, 1991 to 35.21 on 2nd Jan, 1996.

This is a story that has been told many times, and each time for a reason. The IT services exports boom is of course everyone’s favourite reason. The reason I am bringing it up today is that rupee went up in another curve to about 48 and is back to the level it was in January, 1998. The IT services boom lasted through this curve, and if markets are left alone, we will see a shift in economy towards a higher-value rupee. The rising rupee has the services giants nervous. Nobody likes to challenge status quo, much less a successful organization in an industry that has seen a 30-40% compounded annual growth rate over a decade and more. But we are at another inflection point in the history of India Inc. Rising rupee, increasing wages, foreign investment - all of them together are leaving more money in the hands of people, government and institutions, resulting in higher spending by all. The rising rupee needs to be looked at in its complete context of this new wave. To successfully ride this next wave, it is important to look at what was achieved in the last wave.

Some years ago, a friend of mine and I were talking about what US has gained from India and vice versa. We decided that US companies have been able to concentrate on creative, design, architectural and strategic stuff – the stuff that thought-leadership and dreams are made of. We were left thoughtful and humbled, and we didn’t really end up discussing what India gained. But what I realize today is that during the last decade, we built products that were world class. We didn’t do it for ourselves, so we never owned the intellectual property on what we did. What we did own however, is the intellectual capital in the form of people who built this IP (well most of them anyway). We have a large pool of knowledge-rich, smart folks who can build products. All we need is right direction and good leadership.

To build products, managers and engineers will need to adapt to some important differences from the services business. For example, the business cycle in a services company starts with sales and ends with product delivery. Most managers in the Indian IT business today started their careers with the IT services boom and are all too familiar with this model. As part of the next wave, when we see more and more product companies proliferating the market, these companies will need managers who are adept at building and delivering products not as an end in itself, but as the beginning of a longer and more complex business cycle. The difference is subtle, but has important ramifications for an organization.

This is not to say that the era of services is ending. Far from it, it will evolve into better things and higher-value-chain work. But before we know it, everyone will be talking about the new wave and Indian software products will start selling globally. A decade ago, we joined the IT services industry blissfully unaware of what was brewing and were fortunate to have been part of an incredible boom. In today’s India of choices, the question is, do you foresee another wave and can you catch it right at the beginning?

When I was a school kid, I never actually worried about the resources I was using or occupying. I always finished my pocket money before the month end. I was wasting a lot of resources and the reason for that I think was that I didn’t realize where the importance and also the source of resources! But after finishing my schools I never remained careless about my resources. I would attribute the change to learning C and C++ in my college. “Isn’t it funny?” J … Yes, the memory management in C and C++ encouraged me to handle my resources.

Then came mobile platforms in my life. The best platform to learn doing a lot of things with very less resources. Every chunk of memory you allocate, needs a reason to do so. Gives another dimension to your resources handling skills.

In last few years I have come across a few mobile technologies. Started with Symbian switched to Palm OS for some amount of time and then back to Symbian a little bit of Windows mobile here and there for a change of taste for few days. I came across different memory management techniques, ways to handle exceptions. And of course distinguishing features for every platform. For Palm its “Locking and unlocking of memory chunk”. This I could talk about in one of the later posts. This one is about my first love Symbian and the bunch of features that distinguish Symbian

Two of the Symbian features I like most are:

1. Two phase construction
2. Cleanup stack

Two phase construction:

How do you feel when you just start to construct something and it fails? Some things don’t happen as per the expectations, it’s failure on the planning side. Lets take an example: you start building your house and during construction you notice that the carpenter you booked for your furniture didn’t give you proper estimates for resources and your construction fails .. or at least gets delayed for few weeks or months. But in this scenario you can recover by finding another carpenter. But while programming what if the code in your constructor fails? Lets take an example -

class Person

{

char* name;

char* surname;

public:

// constructor and destructor

Person();

~Person();

}

Now let’s say we allocate these two member variables in a constructor as follows:

Person()

{

name = new char[100];

surname = new char[200];

}

Now the allocation for “name” goes well according to plan. And due to unavailability of a free 200 bytes the allocation for “surname” fails. Now what will happen to the “name” which is already allocated? Its orphaned and finally a memory leak in my application. The constructor of any class should not throw any exceptions ( Leave in Symbian ).

According to me, the best way to handle this situation would be a Two phase construction. It’s a method of creating an object in two phases. First phase would be a constructor and other is say “Construct” method. Let’s take above example class and add a two phase constructor to it.

Class Person

{

Person();

bool Construct()

public:

static Person* Create();

~Person()

}

Person* Person::Create()

{

Person* me = new Person();

if(Person == NULL)

{

return NULL;

}

if( me->Construct() == false)

{

delete me;

return NULL;

}

return me;

}

bool Person::Construct()

{

name = new char[100];

// check for allocation

if(name == NULL )

{

// allocation failed

return FALSE;

}

surname = new char[200];

if(surname == NULL )

{

// allocation failed

// delete previously allocated memory

delete name;

name = NULL;

return FALSE;

}

// everything is successful it means my object is properly allocated

return TRUE;

}

This technique of allocation of memory is very impressive for mobile platform because it handles the failure of object construction. I would love to see non wireless platform adopting similar techniques to ensure cleaner object construction.

Be back with the next post on “Cleanup Stack” soon, remember thats other feature I like the most in Symbian.

- Kiran