The advent of HTML5 has initiated a revolution which started with web development and is now already an important player in the mobile application development arena. The greater integration of HTML5 with all major web browsers poses a fatal threat to Flash. Till now flash has been the major choice when it came to displaying video and audio content in a web browser. Viewing HTML5 as “Flash Killer” has been a topic for debate till only sometime back. But with Adobe giving up on Flash for mobile devices, the picture is pretty much clear now, atleast in the area of mobile devices. Adobe announced in November 2011 that Flash Player 11.1 would be the last version of Flash for mobile devices. Adobe has also stopped the development of Flash for connected TVs. Adobe itself has recognized the amazing potential that HTML5 has. This has come as a blessing in disguise for Apple which had already refused to integrate Flash with its iPads and iPhones.

Earlier complicated animations, games, screen-casts, video and audio were mostly possible only with Flash but support for these features has been incorporated in HTML5. Adobe is already working on increased support for hardware based acceleration in Flash which is already a key feature of HTML5 for quite some time. Now with the help of HTML5 and CSS3 amazing texts effects and fonts can be used that was mostly done by Flash in the days gone by.

Inspite of the numerous advantages that HTML5 holds over Flash, it would be unwise to declare Flash as dead. Flash is still important as a software and game development tool. We should not forget that HTML5 is still in its drafting stage and it needs to undergo many changes before it can replace Flash. However, there are companies that have been using Flash for years to develop their products and HTML5 alone cannot make them to drop Flash. In terms of Open Web technologies, HTML5 may be able to completely route out Flash from areas where it has been acting as a stub. Google who is one of the major contributors to HTML5 has an inbuilt Flash Player with its Chrome browser.

The title tag on official site Drupal.org says: It is “Easier and More Powerful than ever” and we would agree . It indeed is. Some high level things one should know about Drupal7

- Drupal7 includes a number of usability improvements for site administrators to make their job easy. This is a big step forward as this was a common complaint from Drupal detractors.

A number of things have been done to achieve the same. (i) edit-content functionality is much easier to use now with better text editing modules and features (ii) the admin dashboard is completely customizable now (iii) It is much easier in Drupal7 to find the task correctly

- Drupal has taken a lead and implemented RDF in Drupal7. This should be a clincher for those who are looking to implement the semantic web on their websites.

- There are improvements in security aspects. Once the frameworks bring in new securiy features, the hackers attempt even newer techniques and then the framework architects respond by bringing in new security features in new release. Since Drupal7 is a major release so new security features were expected.

- The default theme is much more attarctive and looks modern. The theme for admin console is also brand new.

- Almost every application built in Drupal these days uses CCK [Content Construction Kit] module. In Drupal7 CCK has been added to Drupal core and thus enabling much tighter integration. Second insllation profile can be used as a module to make peripheral changes in user profile.

- One would always expect the customizability of look and feel in any CMS. Drupal never imposed its own layout and UI and always had a good theming layer. Drupal7 goes further ahead in improving the theming layer concept.

- The installation process of Drupal modules would be much more simpler now. One can even do it with UI in a couple of clicks. Not everybody likes FTP and command based installation. Right??

- Drupal7 ships with JQuery1.4.4. This version of JQuery is faster and provides excellent features to developers such as $.proxy().

- Last but not the least: Scalability is an important aspect while choosing the right framework for your application. Drupal has never been the preferred choice for performance fanatics. But we know some very high traffic websites built on drupal such as The Economist. Drupal has worked on the performance and scalability aspect in Drupal7 and has achieved significant results on this count. New optimization and caching techniques implemented in Drupal indeed shows results.

We at Mobicules has always focussed on performance and scalability aspect and have published some information articles on our tech-blog. You can read more about performance and scaling and Choosing a framework/platform for a social network that needs to be 10 million users ready on our blog.

HTML5 is the hottest technology right now and the support for HTML5 in mobile web browsers in the smartphones makes it all the more interesting. The HTML5 technology has a good amount of overlap with the Mobile Apps in the sense that it web apps written in HTML5 can be packages as native apps for various mobile platforms. So, what is the biggest advantage of building an HTML5 app? It is platform agnostic. You can write code once and create applications for all platforms (Android, iOS, Windows, Blackberry etc) from the same codebase.

The queston is: Is it possible to build “native-class” in HTML5 app? If Yahoo Mail for Android (written in HTML5) is something to go by then he answer is yes. Yahoo’s HTML5 Yahoo! Mail Web app for iPhone and iPod touch offers users desktop-class features, lightning-fast speed, and an engaging, rich media experience. The counterpoint, largely true, is that the native apps can hook into the device’s ecosystem, e.g. Widgets and notifications on Android, in a much better way. Native apps can typically act on hard keys being pressed, like Android’s search button and volume controls etc. Native apps have better access to hardware, like GPS and camera. Some of it is possible, but if say you have to detect the remaining battery charge from HTML5 it woud probably not be possible. Even some native apps interact with other apps (Yes! Android allows that). This much is not possible with “web” apps. However the good news is that the web is closing the gap (very fast).

Moreover, it is always better to write a performance oriented (heavy on resources) app in native technologies only as Native apps can take advantage of performance boosters like GPU acceleration and multithreading. However, web apps have improved tremendously in this respect as well. V8, the JavaScript engine that ships with Chrome, was a major development in web performance when it launched, and since then, it has only gotten faster. Also, some performance-optimizaed libraries are available for web apps to boost the performance. The developer should be good enough to take advantage of these libraries and oher well researched optimization techniques.

Talking about the ease of development, web apps are usually easier to develop especially if you are targetting multiple devices and platforms. Also, the availability of web developers is much higher than the availability for native mobile app developers. If you have to integrate the app very tightly with the system (device) then it could be much easier to build a native app.

So, do we have a winner? The answer is there is no clear winner. If depends on the kind of application you want to create. One technique getting popular these days is hybrid apps, and this may be the best compromise for some developers: web view where it’s possible and platform-specific native components where it’s not. More on this soon in another article.

Amazon EC2 (Elastic Cloud Computing), allows users to create Virtual Machines within Amazon’s enormous web farm (aka: the cloud). The Amazon launched this product in 2006. Since then EC2 has come a long way. The AWS or the Amazon Web Services are associated with them.

As a Company or even as someone who wants to be host to web services, this is definitely something you want to be familiar with.

Dynamic, on-demand-scaling has been and remains the biggest advantage of Amazon EC2. You can use the Amazon EC2 web service APIs to start, monitor, terminate, etc. as many virtual machines as you want. This means you can scale your application to as many servers as you need on the fly. If you do the resource (web servers) planning to handle the potential “peak load” then for majority of the time, you are likely to use only 10% – 20% of your computing resources. The other 80% is sitting there “just in case”. It’s obviously not a great use of resources and/or money. This is where EC2 scores. The resource allocation on Amazon EC2 can be done dynamically and programmatically i.e. you can “reserve” the servers on the fly as per the traffic load. You don’t have to worry about scaling. Let Amazon handle that for you.

Another, big advantage of EC2 is Amazon’s brand name. To quote the Chief Geek and Co-founder of a SaaS company – Grexit, Nitesh Nandy: “”AWS’ compliance with Type II SAS 70 requirements and PCI data security requirements made it a very good fit for us to store our data and code in a virtualized environment. For SAAS applications that deal with a lot of sensitive customer data, AWS provides a great infrastructure which is secure, and also offers dynamic scaling of compute and storage capabilities.”. (Disclaimer: This articles is primarily based on the inputs gathered from EC2 users Niraj Ranjan Rout and Nitesh Nandy, Founders of GrexIt Inc.)

Amazon EC2 has its share of cons as well.
- Amazon web services are costlier than the other options such as Linode. But If you go for a reserved instance, the cost is less, on demand ones cost more.
- No persistence in instances. If you want persistence you will have to get EBS. On EBS if you have lots on I/O operations, you get charged a lot. EBS is good on machines that host database and other data as its a real time backup.
- There is a learning curve to ec2 for sure. But, once you get past the learning curve and get comfortable with the idea of putting data only on machines which have EBS and using other machines as pure compute units, Amazon is good to work on. I think that is the key part of the learning curve (Plus making insances, images etc.).

Bottom-line: If one primarily needs dynamic scaling then it makes more sense to go for ec2, otherwise EC2 is not the best option and not the best value for money for sure.

People keep asking what Web 3.0 is? A friend with whom I was discussing about the future of web mentioned that to him Web 3.0 — or the Semantic Web — is a web of applications which are capable of talking and exchanging data automatically between each other. But I don’t think a consensus has emerged yet on what web3.0 is or is going to be. Many people say it is the full integration of location features into the web. Many also related web3.0 with Augmented Reality. To them, full adoption of AR with location would usher in a new era of internet usage, especially of mobile devices. But the term is largely associated with semantic web. It’s not clear to me that the semantic Web will become ubiquitous or even commonplace in the consumer Web industry anytime soon. But looking at the advancement in web and mobile technologies, I don’t agree with those who say that web3.0 is just a PR/Marketing fluff.

So what is this semantic web all about? The Semantic Web is all about enabling applications / documents / links in the whole web talk to and exchange data with each other. Imagine if you were to plan for your vacation. In the Semantic Web ideally, your calendar, Maps, weather forecast website and bank accounts will be able to talk to each other. There will be a robot sitting at the back who will only receive a single command from you saying that you want to go for a vacation and then it does all the job and planning for you. The robot will take your appointments from your calendar and then decide possible days when you are free. It checks for possible destinations on Google Maps which may be covered in that duration you are free and then automatically checks for hotel reservations available over the web. The robot also will also be capable of checking if the weather is suitable for travel and then access your bank account to check for funds required to book an affordable hotel. This example might be too farfetched at this point of time and many of us may not even want that much automation. But technically speaking to make these possible different apps should be able to talk to each other even if these are written in different languages/frameworks/technologies. The universal standard for making different apps talk to each other to enable the path for web3.0 is not yet finalized and its a matter of debate in the web community/leaders.

What started just as a blogging platform now powers more than a tenth of the world’s websites. So, what is it about WordPress that makes it the most popular CMS?

WordPress has had support for multiple websites for a long time in the form of WordPress MU. Starting WordPress 3.0, launched in June 2010. WP MU was integrated with WordPress. This means, that a single installation of WordPress can be used to manage multiple websites. It can allow users to start their own blogs within the site, each with its own theme, plugins and set of permissions.

While earlier only Post and Page were the supported content types, the newly launched Custom Content Type Manager plugin gives you all the freedom relating to content types, and is a serious answer to Drupal’s all powerful CCK. With an option to create custom content types, WordPress can finally shed of the tag of being a primarily blogging platform.

Another feature that it has recently borrowed from rivals Drupal and Joomla is custom taxonomies. Taxonomies allow better arrangement of content and better interlinking of various posts. They are similar to the pre-existing tags and categories, only more powerful as they are totally custom and give the user much more control over what he wants to see and how. For example, in a car listing, you may have a field for Seating Capacity. Using taxonomies, you can connect different cars on the basis of their seating capacities.

What makes it a complete CMS are its e-commerce plugins. Although they are not as mature and feature rich as the popular ones in Drupal and Joomla, they do their job pretty well. Plugins like WooCommerce, Cart66 and Shopp are worth mentioning. All of them have multi-site support provide all kinds of features like product configuration, shipping details and tax options.

Although most of the features provided by WP are available in other CMSs too, there are quite a few things that set it apart. Compared to other popular options like Drupal and Joomla, WP has a relatively smaller disk footprint. Setting up WordPress is very easy and takes less than 5 minutes. Its administrative panel is very intuitive and anybody can start using it easily, even if it’s their first time. In newer versions, the admin panel comes with help tips, which further ease out the usage. Among all the CMSs, WordPress has the largest developer community which is constantly working toward delivering a better solution. These things make WordPress the CMS of the future.

Facebook has launched timeline apps. Timeline apps are meant for the activities you want to share with friends and allow a much broader range of functions. Once users sign up for the timeline apps, their activities on Facebook will be automatically shared through Facebook.

Where the activities would be shared: It would appear on the user’s Facebook Timeline. When a user gives permission to the app to add activity to his/her timeline, that activity may also appear in ticker and News Feed depending upon the settings.

That said, it doesn’t mean the user can not opt out of sharing of activities on Facebook. It would entire depend upon the privacy and sharing settings. There is an in-line audience selector on the app install screen that controls who can see your activity from that app.

Facebook has referred to the Timeline apps as ‘frictionless sharing’ and is extremely bullish about the prospects of timeline apps. Carl Sjogreen, Facebook director of platform products said: “We think that thousands of applications will be built on this platform in the coming weeks and months”, at the launch of the apps in San Francisco. At the time of launch Facebook has 60 timeline apps. This number is likely to be in thousands very soon.

We at Mobicules have always been prompt in adopting latest facebook features in our apps. Locotext, our soon to be launched location based services utility app for android and facebook platforms makes full use of the timeline features.

If you want to explore how your website/web-app/mobile-app can benefit from this new facebook feature for app developers do write in to us at smita@mobicules.com to schedule a free consultation session.

So you’ve decided to build a website and have everything chalked out. One question that is bound to trouble you and that can be responsible for the success or failure of your project is how you plan to implement it. Not much time back, the most popular solution was hand coding the entire project while making use of some openly available libraries. With the increasing complexity of web applications, that is no longer a feasible option. Today, two of the most popular approaches are using an MVC like Symfony or a CMS like Drupal or WordPress.

Whether you choose to go with a CMS or an MVC depends on what you are building and what kind of effort and money you are ready to put in. A CMS will work for you out of the box. It will have the basic functionality that a portal needs and additional features will be available as add-ons or plugins. With popular CMSs like Drupal and WordPress, you can expect to find a plugin for any regular feature that you want to incorporate and you won’t have to write a single line of code. The problem with a CMS begins when you want something very specific which is not available as a plugin. Suppose the user login and authentication systems is different from what comes out-of-the-box with the CMS then, it’s reasonable to assume that you will not find a plugin that suits your needs and you will have to modify the existing plugin or write your own. You may write a plugin for the CMS but with the constraints placed by a CMS, depending upon the effort required, it may be a better option to build your own application from scratch. An MVC framework like Symfony will give you all the tools you need to build up your application and you can make the application exactly the way you want it. If you have a lot of business logic to implement, a CMS is not for you. Using Symfony will give you complete control of things such as data storage and UI, it will allow you to separate your business logic from the presentation layer and also, it will let you use the latest in technology.

If you have decided to go for a CMS, you still have a lot of options to choose from, the popular ones being Drupal and WordPress. Both are great in their own way. WordPress powers almost 15% of the world’s top websites and this figure alone speaks volumes. It is really quick and easy to configure and can get you a multi-user blogging platform ready in under 5 minutes. With thousands of free and paid themes and close to 15000 plugins, you can very well get a site close to what you wanted. Other things that work in its favour are easy administration, low maintenance costs, large community, frequent updates and good SEO out of the box. While it is mainly a blogging platform, it has been successfully implemented in News portals, image sharing and other such fields where the content types are limited. For that matter, WordPress allows only two basic content types- Post and Page. So you can do a lot of stuff on this platform, but it cannot provide you with everything that you may want. Here comes Drupal. It powers close to 2% of the world’s top websites. It is heavier than WordPress, not as intuitive and is relatively costly to maintain. So why would you use it? Because it can provide you with everything from forums and user networks to fully functional shopping portals and payment gateways as add-ons. It allows you to create your own custom content types, and also design the view of your pages. It has a very active community and updates are regular. So, if you are not planning on writing a single line of code, you can still have an e-commerce site or a social network ready, and obviously, you can write your own add-ons .

So, in a nutshell, if your website is something very specific to your needs, don’t go for a CMS. Use a Framework such as Symfony or CodeIgniter. If your project is something generic, using a CMS will save a lot of effort. Go for WordPress if you have simple content types. Large applications with complex functionality are better off on Drupal.

Tuning an application for best performance and scaling is a challenging task. Before you begin to scale, you should be sure you really need to scale. You need tools to monitor the server loads and identify the bottlenecks in a system first. What is causing the slowdown or downtime?

Before scaling, make sure you have optimized your existing code to work properly with whatever resources you have. Here are a few options that you should look at first.

Presentation Layer
Improvements in this field are among the easiest to implement and are seldom the major culprit for a poor user experience. You can use a browser add-on like YSlow or PageSpeed to see the performance status of your application. An excellent article is available here outlining the issues and their resolutions.

Server
You can start by using a profiler like X-debug to check the areas which need improvement or are slowing down your website. You may be running unnecessary loops and slow database queries and perhaps queries in a loop. The profiler will help you identify these and take appropriate action.
Check the apache logs to see if there are any problems. See if you are logging too much or unnecessary data. Are you including any unnecessary apache modules – do away with any component that is not required. Here is a more comprehensive guide for tuning apache performance.
Try a linux command line tool like top or procinfo to take note of apache performance and resource it is using.
Next, try using a caching program like APC or X-cache. This would improve performance significantly.
Move to a dedicated server if you have not.
Use a CDN – they will reduce load on your server by taking care of the static data and leave your server to handle the dynamic part.

If you have implemented above and think you still need to scale to multiple servers, you have made the right decision. To begine with, you must have answers to this question: For how long do you need to scale and how many servers would you be needing?

Spending on hardware yourself should be your last resort as they are expensive. Also, simply increasing the processing power and RAM of your single server may not be the best of the ideas. It is more feasible to deploy across multiple smaller servers and employ load balancing to distribute load. This way is cheaper, easier to extend and removes SPoF problem.

But first try cloud solutions – there are various services like Amazon and Rackspace that provide many flexible options. This would be best to go for as you do not have to worry about the hardware setup and maintenance. Some may also provide you with autoscale on demand option.

If these do not work for you, then scale to more servers.
You can use a tool like rsync which will ease your process of getting your files on each server and maintaining same state across all of them. Alternatively you can also use Subversion (SVN) to update all servers separately. You can also use a file server like NFS for this but they will also become an SPoF. Find more info here.
You can implement load balancing directly from Apache using mod_proxy_balancer or you use round robin dns.
You should also employ proper logging methods so they easy to manage across all servers. As an example you use a dedicated program like syslog for this.

When scaling, session management is an important aspect to consider. If a user is directed to different server on each request, he will be continuously logged out. You can tackle this by storing session data in MySQL or using memcache to handle the session.

Database
Keeping a check on your db performance is very important.

First make sure you are using the right storage engine for your requirements. These can be done on table level, so if the table is accessed for mostly reads, you should use MyISAM and if it write intensive, use INNODB. You should also use MEMORY tables for frequently accessed data as this would be significantly faster.
Check the slow query log frequently to see if there are some specific queries that are destroying the otherwise good performance.
Go for batch inserts wherever practical as it would be faster than multiple individual inserts.
Make sure you are using MySQL query cache optimally and the settings are right. Read here for more info.
If your database houses a lot of data, you can try making partitions.
If you need further improvement, try hosting your db on a separate machine which is fine tuned for serving database queries. Mysql Accelerators are available that will take care of most of the scaling part.

If you still find that you need to scale to multiple servers on your own after following the above steps, you may be right.

If your application is read intensive, you can distribute read load among slaves. This will be fairly easy using mysql replication.
Distributing writes is more difficult. You can employ sharding to distribute write load among multiple servers. Here is a good article related to this topic.
You can further speed up your database by using memcache. This will make the db queries considerably faster.
Using clusters may help if you need high availability and performance, but they may not be the solution for distributing write load.

Conclusion
This is just the tip of the iceberg and what steps you take to improve an application’s performance is very specific to your application. Scaling an application comes with a price – either in terms of installation and running cost or in terms of manageability and code changes or enhancements.
This blog has been written to serve as a guide for options available to you before and when you decide to work on improving performance or scale your app.

Your comments, corrections or improvements are welcomed.

Whats new in Symfony 2 – A developer’s perspective

Symfony is an Open-Source PHP Web Application Framework which Mobicules started using for large and complex web applications and is now at the forefront of Symfony development. Here is the brief synopsis of some of the applications we have developed in Symfony 1.1 and 1.2:

• www.voyavo.com
• The backend dashboard for AGame
• The Innovative Recruitment Application MyJobLinx in use by Adobe Corporation.
• WushuPlayer.com
• Backend admin panel for iPhone application Yo-Momma Battle and Penance

After developing and maintaining a variety of web applications in Symfony 1.1 and 1.2 we are now geared up to adopt Symfony2 for future development. Based on an innovative architecture, Symfony2 is fast, flexible, and easy to learn. It allows developers to build better and more easily maintainable websites with PHP. Following are some of the reasons why we are so excited to embrace Symfony2 for future development:

High on performance and easy on resources: Symfony2 has been developed primarily keeping the performance in mind. It is as much as 3 times faster than its previous versions and Zend which is another PHP framework based on MVC Paradigm. At the same time Symfony2 consumes very little RAM for the same or faster performance than its predecessors.

High on productivity: Symfony2 provides many useful tools for development and debugging. Here are some examples:

The Web Debug Toolbar: It appears at the bottom of every page in the development environment and provides access to lot of information instantaneously which provides access to lot of information which is extremely help for debugging.

To quote directly from the Symfony’s official website:

“Symfony was the very first framework to propose such a web debug toolbar to ease debugging. Since then, numerous other web frameworks have followed the same path and you can find web debug toolbars for Zend Framework, Django, Ruby on Rails, Rack, and CakePHP.”

The Web Profiler: The Symfony2 profiler collects information about web requests and stores them for later analysis. The Web Profiler is a visualization tool for profiling data that can be used to debug the source code and enhance performance. It can also be used to explore problems that occur in production.

Separate Environments for Development, Test, Staging and Production: Symfony comes bundled with those environments by default. A development environment refers to a server tier designated to a specific stage in a release process. Here is the direct example quoted on http://symfony-reloaded.org:

The development environment must be optimized for the developer (the web debug toolbar is enabled, nice exceptions are shown on the screen in case of an error, and all the details of a request are logged to ease debugging). But the production environment should be optimized for performance and the user experience (errors should be masked behind a friendly page, and an aggressive cache layer must be activated). Creating a new environment in Symfony is a matter of creating a new set of settings.

In addition to above mentioned development tools Symfony2 also provide helpful error messages and useful logs. More details can be found at: http://symfony-reloaded.org/tools

To summarize Symfony2 is fast, flexible, extensible, borrows the best concepts from Symfony1, Django, Spring, Ruby on Rails and last but not the least it is built for developers.

Read our earlier blog entry on Symfony here

To receive a quote for Symfony development services please write to us at info@mobicules.com to get the process started.

What is E4X?

E4X stands for “ECMAScript for XML” and ECMA in turn stands for European Computer Manufacturers Association. ECMAScript for XML (E4X) is a programming language extension. It adds native XML support to ECMAScript. Here ECMAScript ActionScript, DMDScript,JavaScript, and JScript.

ECMA is the organization standardizing Javascript. ECMA has also developed standards for quite a few stuff apart from Javascript e.g. C# language, Optical disks, Magnetic tape, Data compression and communication etc .

E4X is available to both Firefox and ActionScript developers that turns XML into a native data type on par with strings, arrays, objects, and regular expressions. Worth to mention its not the DOM equivalent of XML but is a distinct entity itself which has its own set of methods. E4X is implemented in SpiderMonkey (Gecko’s JavaScript engine) and in Rhino (JavaScript engine written in Java).

Why Use E4X?

There is a basic question which arises out of curiosity needs to be answred while addressing new technology.Why work with E4X when you can do the same thing with JSON objects (keeping in mind that both E4X and JSON objects are “part” of JavaScript, though JSON is an expression of the JavaScript Object object)?

JSON is marginally more compact to encode— than for attribute intensive XML or element heavy encodings. But this advantage disappears if the resource is gzipped as for both the cases we are storing labels and associated values. Thus if transmission is concerned then gzipping the content will occur as a matter of fact and the speed becomes insignificant comparison. Apart from this some very interesting work is going on with EXI (i.e. Efficient XML Interchange) that to at W3C level that is trying to make EXI more compact than even compressed JSON.

Moreover it is very easy to use and user friendly as for an example we can define the XML object variable just any other variable such as Date, Array etc. using new operator.

Such as

var myXmlObj = new XML();

var myDate = new Date();

The most significant difference between working JSON and working with XML using E4X is that the latter is an example of array programming.

Things like “html.body.p” aren’t possible to express in most programming languages. The fact to be noticed here is above expression in E4X and JSON means something completely different.

In E4X “html.body” returns a trampoline object (XMLList), which asks all the elements in it for their “p” children, where as working with JSON, “html.body” returns one object or a list of objects. If it’s a list we write loop to do something with children. Just getting the text contents of all p will require 2 nested loops. Of course the code behind E4X uses loops but the point is we don’t have to.
Creating E4X Objects

Creating E4X object is very easy …

e.g.

To load an XML doc

var xmlDoc=new XML();

xmlDoc.load("note.xml");

document.write(xmlDoc.body);

The above will print the content of body tag from the note.xml doc

We can access any XML node using “.” (dots)

e.g.

var myXmlVar =  Mr XMr.Y

document.write(myXmlVar.to);

Above code will print “Mr X” 

Key features of E4X include

• ECMAScript for XML specification defines a new set of classes and functionality for working with XML data.
• You manipulate XML data with well-known operators, such as the dot (.) operator.
• Use the @ and (.) operators not only to read data, but also to assign data.
• Using E4X functionality is much easier and more intuitive than “walking the DOM”.
• E4X can be used for creating templates for dynamic content.

If one adds a few common purpose functions (especially along with the convenience of JavaScript 1.8 expression closures), the templates can function more dynamically, offering the power and readability of templating languages such as Smarty for PHP (though admittedly without the currently wider cross-browser support of XSLT or the strictly-XML approach of PHPTAL or See through templating).

E4X Support

• Firefox1.5 and above supports E4X.
• Currently there is no support for E4X in IE,Opera, Chrome, or Safari

Limitations of E4X

• It is not currently possible to access a DOM object through E4X.
• E4X doesn’t support parsing XML declaration

http://en.wikipedia.org/wiki/ECMAScript_for_XML

Heroku is the instant ruby platform. Deploy any ruby application instantly with a simple and familiar git push. Take advantage of advanced features like HTTP caching, memcached, rack middleware, and instant scaling built into every app. Never think about hosting or servers again.

It is a multi-tenant platform and hosting environment. Your app doesn’t need its own servers, slices, or clusters, and you’ll benefit from continuous platform improvements.

It is a new approach to deploying web applications. Forget about servers; the fundamental unit is the app. Develop locally on your machine just like you always do. When you’re ready to deploy, use the Heroku client gem to create your application in our cloud, then deploy with a single git push. Git allows you to have multiple source repositories all at the same time. By making Heroku just another source repository, you can push your code and deploy your application in one easy step.

• Prerequisites
  • Run your Ruby application locally
  • Install Git
  • Create a Heroku account and Install the Heroku gem
• Getting your app on Heroku
  • Track your application with Git
  • Setup your SSH keys
  • Create your application on Heroku
  • Push your application to Heroku
  • Bootstrap your database
• Next steps : Now that your application is running you can push updates anytime with three easy steps:
  • Develop and test changes locally.
  • Commit code to git.
  • Push your changes to Heroku with git push heroku.

Basic usage of Heroku is free. When you first sign up for your account, you have access to 1 dyno and a 5MB database. From there, you can extend your application with add-ons from their catalog. Use of any add-on requires that they first verify your account, in order to prevent abuse.Verification is completely free, and they will never charge your card until you explicitly confirm that it is OK to do so.

To use paid features such as some add-ons, additional dynos or workers, you must confirm that they may charge you. This step ensures that it is OK to start charging the credit card on file.

Heroku supports all versions of Rails, from 2.0 through 3.0. Using the Bamboo Stack and manually specifying your rails version through gem config is the easiest way to deploy your app.

Features supported by Heroku :-

• Background Jobs – Fetching data from remote APIs, reading RSS feeds, resizing images, and uploading data to S3 are all examples of tasks that should be processed as background jobs.
• Full text search : Heroku recommends using Solr for full text search. You have two options, running your own Solr server on any internet-connected server, or using the Websolr add-on.
• Outbound Email / SMTP : Heroku does not provide an outgoing mail service but does allow the use of an external SMTP server. For production use, they recommend Sendgrid add-on which lets you scale from very light requirements to thousands of emails per day with no change in configuration.
• Storing uploads in S3 : Heroku also runs on the Amazon platform, transfers to S3 are free.
• DNS & custom domains : All Heroku apps are accessible via their heroku.com subdomain: appname.heroku.com. Enabling the custom domains add-on allows you to assign additional custom and wildcard domain names.

Heroku also provides a command-line tool which acts as an interface to the Heroku Web API and includes support for things like creating/renaming apps, running rake commands, taking backups, and configuring add-ons.

The Heroku PGBackups addon lets you easily capture and manage backups for your shared and dedicated Heroku PostgreSQL databases. Heroku keeps system-wide backups of all apps on the platform, but these are only for recovery from the extremely unlike possibility of catastrophic system failure such as hardware failures. If your app stores important data you, the app developer, should keep your own backups to handle cases such as bugs in your code causing corrupted or lost records in your database, or your users accidentally deleting data. Heroku provides several tools to make this easy.

On an all Heroku provide everything you need to run a modern, high-performance, scalable web app.

http://en.wikipedia.org/wiki/Heroku

Full text search is a technique for searching a document or database stored in the computer. A full text search engine examines all the words, in every stored document, to find a match of the keyword searched by the user. Many web sites and application programs provide full-text search capabilities.

There are quite a few choices when it comes to adding a full text search in a Ruby on Rails application. A choice can be made on the basis of the language the search engine is written in or the scalability options suited for the application.

Acts As Indexed being a pure Ruby implementation makes for a tool that is totally portable, and suitable for almost any application requiring full text search capabilities. Search queries support many standard boolean operators, namely exclusion of a term through the use of ’-’ and the matching of phrases through the use of quotation marks. It is useful in case of a simple site and need to implement a basic search very quickly.

Ferret is a full text search engine library written for ruby implemented in a rails application by the Acts As Ferret plugin. It is inspired by the Apache Lucene Java project. The first step to implementing a search is to get an index built and then the index is searched for the documents having the keyword. One of the more useful features especially in a web scenario is highlighting the matched words. This is made trivial by Index’s highlight method. It’s also possible to use Ferret as a more general purpose data store

Xapian is written in C++ with bindings to allow use from Perl, Python, PHP, Java, Tcl, C# and Ruby. An important feature of Xapian is the Ranked probabilistic search – important words get more weight than unimportant words so more relevant results appear at the top. It also supports Synonyms as an automatic form of query expansion and can even suggest spelling corrections for user supplied queries. Full range of structured boolean search operators (“stock NOT market”, etc).

Sphinx, written in C++, is the most logical successor to Ultrasphinx, since both utilize Sphinx as the search server. Sphinx works by reading information out of the database to build the search index. Communication with the Sphinx server occurs by sharing C “objects” over sockets. A variety of text processing features enable fine-tuning Sphinx for application requirements, and a number of relevance functions ensures you can tweak search quality as well.

Sunspot is a Ruby library for expressive, powerful interaction with the Solr search engine. Sunspot uses Solr, a Java search server built on the Lucene search library. It provides robust, flexible full-text search with no boolean queries and no string programming. Solr servers can be clustered and since they manage the index, Sunspot can automatically update the indexes when the model objects change. There’s no need to run a cron job to reindex the data or setup delta indexing like with Sphinx.

Thus we see that Full text search has come a long way since the early days of Ferret. The incompatibility of Ultrasphinx, once the most preferred, with Rails 3.0 resulted in the emergence of Sphinx and Sunspot as favourites. Solr is a compelling alternative to Sphinx, since the most scalable Web apps (Facebook, Twitter) use Java behind the UI layer. Xapian can be considered as the best option whenever ranked probabilistic search is required. Acts_As_Indexed, written entirely in Ruby, works out great and is very easy to implement with automatic indexing. (ie No cron jobs needed to keep the index up to date).

Appcelerator’s Titanium is full featured application development platform for building mobile and desktop applications with native technologies. You can start working for any application with your favorite languages – html5, css3 and javascript only. There is support for ruby, python and php for desktops applications, so you can start your dream application without any learning curve or new technologies involved. And there is more – you can develop a desktop application for Windows, OSX and Linux on a single code base. In addition, iphone and android application development on the same platform is possible – without more than 80% of reusable code, and you don’t have to learn a single line of either objective c or java. Now to me, a platform with such capabilities is truly revolutionary. It gives you the ability to be at three places at once – online, on phones and on desktops. So essentially, you don’t need to stick to the browser and your users can have fun with you apps wherever they are! Titanium is opensource, released under the Apache2 license and free for all to use – personal or commercial! You also have free access to Titanium Developer, a desktop app built on our platform for developing, managing, and publishing your apps.

Moving on to technical stuff, titanium has four parts:

• The html/css/javascript code that makes up the core application logic and UI
• The APIs that access native device/desktop functionality, analytics or other modular functionality – over a hundred APIs ranging from user’s file system and database connectivity to native UI to Facebook Connect, media, social sharing and location-based services.
• The language-OS bridge that compiles web code into native application code.
• The run-time shell that packages the application for cross-platform distribution.

Once built, Titanium-based applications can be tested, packaged, and distributed through the Appcelerator Network’s cloud services. They also boast of titanium desktops applications taking up to 1/10th the memory of Adobe AIR apps and having complete access to the local system.

In all, our conclusion is that Titanium is an all out winner when it comes to binding web, desktops and phones together. As an easy to learn and use platform, it opens up immense possibilities to build more feature rich, more engaging applications and to build them fast. However, once HTML5 is supported by all major mobile browsers the need of mobile applications might only be limited to games or those application which are very tightly integrated with a phone’s native feature set like call recording, auto SMS responses etc

PS: We will soon come out with an article on Titanium’s comparison with other cross platform mobile application development tools Sencha and PhoneGap.

The key to build good rich internet applications (RIAs) is zero lag connectivity to the server and the ability to get realtime data from server as and when needed. The request and response architecture of the HTTP protocol prevents the web applications running on browsers to achieve that same degree of user experience that native desktop applications enjoy. In an ideal condition the server should be able to push data to client through a persistent connection. To address the connectivity issue of web apps a good number of techniques were employed like the Comet model which involves using long polling (asynchronous polling) and quite a few browser plugins like java applets, flash and silverlight.

What is a Websocket ?

Websocket is an exciting new feature in HTML5 which allows bi-directional (duplex) communication over a single TCP socket connection. In simple words the web application client can maintain an always open connection with the server and data can be sent and received at the same time. Exciting isn’t it !

It runs via port 80/443 (will work even if the user is behind a firewall or using a proxy), the tcp handshakes are HTTP compatible and it also integrates with cookie based authentication. The message headers have been kept small (only 2 bytes overhead per frame) and latency from establishing new connection every time as in HTTP have been dealt with by using a single persistent connection. All these result in impressive network throughput. Apart from that Websockets API is much simpler to code than the XmlHttpRequest(). Bottomline, you can make the process of web application development more responsive and interactive with lesser effort.

Sounds cool! How to make this work?

You have to get the Websocket server working first. There are a various websocket server implementation available:

phpwebsockets (php)

mod_pywebsocket (Apache extension)

jWebSocket (java)

web-socket-ruby (ruby)

Socket IO-node (node.js)

They will work alongside the http web server. Grab any of these and fire them up. You might have to set the listening port in the configuration and you will have your server ready.

Client side implementation involves making javascript calls to connect to Websockets server and for sending and receiving data. Check the W3C Websockets API to know more about the supported APIs.

Browser Support

Currently all browsers do not support the Websockets API. List of browsers that support them are:

• Chrome 4.0
• Firefox 4.0 beta
• Opera 11
• Safari 5.0.3
• IE9 will support websockets (Microsoft claims)

For other browsers it’s not so clear but support will come as major browsers are already in line.

Overall things appear exciting as web applications will become realtime and allow better resource utilization allowing developers to build interactive and responsive applications.

HTML5 brings a whole set of new and exciting functionality to the browser. One of these features is the new Web Storage API.

The new storage api is designed for two basic purposes – session storage and local storage.

Session Storage enables carrying out multiple transactions in different windows at the same time, in effect giving each window its own data store for current session.
While it sure is very helpful, the one that we find more interesting is local storage api.

Storing data on the client has been a challenge for Web developers for ages and HTTP Cookies have been the only way to accomplish that. Cookies do not handle this case well, because they are transmitted with every request – which is a performance hit if there is more and more data. Web Storage brings us the freedom to do this with local storage api.

Apart from uses like personalization or tracking user behavior, a much more significant one is caching data from your servers, on the client’s local machine. This allows you to avoid waiting for potentially slow calls back to your servers and minimizes the amount of data needed from your servers. It is often inefficient, insecure, or inappropriate to store that data on a server and this may amount to megabytes of user data, such as entire user-authored documents or a user’s mailbox.

The recommended storage space for each site is 5MB. This is way more than the 4KB space available via cookies. Stored data is accessible from multiple windows and lasts beyond current session and each site has its own separate storage area.

Another important aspect is the ease of use of the API. The Storage API is a classic name/value pair data structure. It has simple methods like getItem(name), setItem(name, value) and remove(name). For iterating over all of the name/value pairs, one can use the length property which gives you the total number of name/values pairs being stored, or go along with a key(index) method which returns a name from an array of all names used in storage.

It is already supported in the latest versions of all major browsers: Microsoft®, Internet Explorer®, Mozilla Firefox, Opera, Apple Safari, and Google Chrome. Even more importantly for mobile developers, it is supported in WebKit-based browsers like those found in the iPhone and phones using Android (version 2.0 or later) phones as well as other mobile browsers like Mozilla’s Fennec.

We, as developers, suddenly have a huge amount of storage space on the client. For mobile developers, it’s even more exciting as it really opens up the local caching of data. In addition to dramatic improvement of the performance of your application, local caching is key to enabling another new exciting capability of mobile Web applications – going offline.

Google’s API and services allows developers and IT departments of companies that use Google Apps to create applications that work with Google Apps services like mail, docs, calendar etc. Such applications can then be sold through the Google Apps marketplace. In addition to API for Google’s services like docs and calendars, such applications can also use Google Apps API and services. The following is a quick overview of the Google Apps API and services, and an idea of what can be achieved with this API.

1. Google Secure Data Connector – The SDC enables the deployment of Google Apps applications that user resources deployed inside an IT departments firewall. The idea is simple, even when a company is using Google Apps to host their email, documents, calendars etc., there might still be digital resources within the corporate firewall that users might need. A very simple example might be a telephone directory of clients, stored on a computer within the corporate firewall. Using the SDC, a Google Gadget can be created that can allow users access to this telephone directory from inside their email or google docs interfaces. Not only that, permissions regarding which user can access which resources can be defined using SDC, so an IT department can strictly control access privileges.

SDC is only available for Premier Edition or Education Edition Google Apps accounts.

2. Provisioning API – The provisioning API provides functions for creating, retrieving, updating and deleting user accounts, nicknames, and groups. Essentially, it can enable creation of custom admin panels for administrating Google Apps accounts for their admins.

Provisioning API is also available only for Premier Edition or Education Edition Google Apps accounts.

3. SML Single Sign On service – Security Assertion Markup Language (SAML) is an XML standard that allows secure web domains to exchange user authentication and authorization data. Using SAML, an online service provider can contact a separate online identity provider to authenticate users who are trying to access secure content. Essentially, this allows Google to ‘off-load’ the job of authenticating the user on another provider, whose primary responsibility might be to be a single window authentication service for all digital resources and facilities of a company. Very intelligent, and very useful.

From Google’s documentation on this service: ” Using the SAML model, Google acts as the service providerand provides services such as Gmail and Start Pages. Google partners act as identity providers and control usernames, passwords and other information used to identify, authenticate and authorize users for web applications that Google hosts. There are a number of existing open source and commercial identity provider solutions that can help you implement SSO with Google Apps.”

4. Email Migration API – Targeted at users who had earlier been using some other email service or provider, and would now like migrate to Gmail for their company. How it works is simple, a domain admin or user can send POST web requests to Google to enter data into their email accounts. There are also a wide variety of applications now available from Google to migrate email to Gmail from popular email software like Microsoft Outlook.

Again, Email Migration API is only available for Premier Edition and Education Edition Google Apps accounts, and can not be used to migrate Standard Edition email or gmail accounts.

We at Mobicules, being long time Google Apps users, have been playing around these API for some time build some internal tools. Get in touch if you think we can do something for you to make Google Apps work better and do more for you

There are many PHP frameworks available for a developer to choose from – Zend, Symfony, CakePHP, CodeIgniter to name a few. All these frameworks provide a solid structure for the code along with in-built library to address commonly needed programming tasks which makes life easier for the developer. Framework allows a developer to creatively focus on the project by minimizing the amount of code that needs to be written for a given task.

We shall be discussing two frameworks here today – Symfony and CodeIgniter.

To first note down a few similarities between the two:

• Both the frameworks follow MVC architecture, which gives us distinct separation of code in terms of logic, view and database interaction.
• Use configuration files to help you maintain vital metadata, such as the location of the database, base URLs, and the like.
• Provides helpers classes for various features.
• Allow the developer to extend the core code and build their own libraries and helper functions.
• Both support caching, multiple databases, form support, form validations and other common features.

Both the frameworks are very similar in the sense that they allow a platform to web developers to easily create their application in minimum amount of time and effort. But they differ in terms of implementation and the features they provide.

• One of the biggest difference between the two frameworks is the ease of use. CodeIgniter is pretty easy to start with where as Symfony has a distinct learning curve and can be little difficult to start with.
• CodeIgniter has a very small footprint, which is only about 1MB where as Symfony comes to around 5MB. This is due to the fact that Symfony comes bundled with many 3rd party libraries (which one might not be using at all). This also makes Symfony slightly slower in the run-time compared to CodeIgniter.
• Installing Symfony can be tricky on shared hosting as it has PEAR dependency and requires shell/command line access for setting up projects, creating modules and other tasks, where as setting up CodeIgniter is as easy as copying the source folder on the server and changing a single line in the config file.
• Another area of difference between the two frameworks in the PHP version support. Symfony only supports PHP 5 where as CodeIgniter supports both PHP 4 and 5. This is due to the fact that Symfony is developed fully with Object Oriented approach.
• Symfony facilitates user with auto code generation for modules, models, database etc which is missing from CodeIgniter. Symfony comes bundled up with propel/doctrine ORM tool which provides wrappers for database functions. This feature is not available by default in CodeIgniter but can be integrated separately.
• Symfony provides in-built Ajax support, which is lacking from CodeIgniter.
• Debugging capabilities of these frameworks differ a lot. Symfony provides a debug toolbar in development mode which provides information about database connections, load time, parameters passed, session details among other things. This helps is analyzing and optimizing an application to a great extent. A similar feature is not available in CodeIgniter.
• Symfony CLI provides commands to quickly (and effortlessly) create an admin backend for the generated model classes. Again, no such feature is available in CodeIgniter.
• CodeIgniter is a simple and easy framework to use. It give the developer options to implement the application as desired and is flexible in implementation. Symfony on the other hand is a very powerful but somewhat rigid framework which follows convention where ever possible. Symfony is all about best practices whereas CI seems to take a more pragmatic route.

Whenever we compare things, we’ll always have pros and cons but that doesn’t necessarily make one thing better that the other. The same applies here as well. Both the frameworks have their own advantages/disadvantages and should be used according to the requirements.

In my opinion CodeIgniter works well for something quick and small, Symfony work wonders when it comes for complicated projects.

In developing a software system, choosing the right design pattern is very important. It directly impacts the application in terms of Maintenance, scalability and/or re-usability.

A Design Pattern is a known solution to commonly occurring problems or scenarios in software design. It is a kind of a template or structure on which one can code the application. It drills down in to the details relating to implementation of certain components. Benefits of knowing and using design patters are several. Patterns are known solution for building software systems. They can reduce web application development time as known solutions are used instead of reinventing the wheel. It is also a benefit to use known solutions that are tried and tested.

We, at Mobicules understand this and try to utilize design patterns where ever possible. We’ve developed many projects using the Symfony Framework, which implements the MVC pattern quite effectively. We’ve also made use of Symfony EventDispatcher, which is an implementation of the Observer Patter.

Implementing Singleton pattern (described below) with Ruby on Rails (another area of expertise at Mobicules), is as easy as adding ‘including Singleton’ in the class. This makes the class a singleton class and can be used throughout the application accordingly.

Below are the few popular design patterns which Mobicules have implemented in various projects:

Singleton:

This pattern is used in applications when only a single instance of a resource is required. Most common type of resource, on which this can be applied is database connection.

Using singleton pattern for database connection, the overhead caused for creating multiple connections is reduced.

MVC:

Model-View-Controller, this is the most commonly used design pattern. This patterns separates the business logic and presentation logic in such a way that any changes in the presentation logic should not interfere with the business logic and vice-versa. This is done with the help of a middle object called controller whose job is to take the request from the view pass it on the model and if required present the updated/new view to the user.

Factory Method:

Factory Method is a object oriented creational pattern.The method is used to create and initiate objects for classes. Use of factories gives the programmer the opportunity to abstract the specific attributes of an Object into specific subclasses which create them i.e. it defines an interface for creating an object, but let the subclasses decide which class to instantiate.

Observer:

The Observer pattern allows one object (the observer) to watch another (the subject). The subject object notify the observer object if the subject’s state changes (Conceptually, the Observer pattern in something like a trigger in a database, which runs a stored procedure when a table row is modified).

The main advantage of this pattern is that it decouples the observer from the subject. The subject doesn’t need to know anything special about its observers. Instead, the subject simply allows observers to subscribe. When the subject generates an event, it simply passes it to each of its observers which they can use in whichever way required.

There are many other creational/structural/behavioral patterns, like Iterator, Adapter, Prototype, State etc. But in order to implement a pattern effectively a detailed study is done at our end to understand the nature of the problem and how a particular design pattern solves it.

F8 has generated a huge amount of interest among users, web developers and business owners alike. And quite understandably so, as it brings about some sweeping changes in Facebook’s strategy in how it plays with the web. Additionally, there are some very logical ‘enhancements’ to the Facebook API, which we are sure developers are going to love.

First the Social Plugins. Social Plugins enable functionality most of which was already possible using Facebook Connect, but Social Plugins make integration with Facebook much more uniform, simple and intuitive. With Social Plugins, site owners can very easily ‘embed’ Facebook related functionality into their websites, enabling user actions which can then reflect back on the user’s profile on Facebook. A few key points of note:

• When they visit a site, even before they log in to the site using Facebook, they would be able to see their friends who are members of the site using Facebook, if the user is logged into Facebook from the browser.
• Users can comment on content on the site using functionality enabled by Facebook, and the comments would be visible on Facebook on the user’s profile.
• The Facebook “Like” button is going to be everywhere on the web, and would be an easy single step process for users to connect their facebook profiles with the content on the site.
• A very interesting Live Stream plugin can be embedded on your website to enable a live discussion between a Facebook user and his Facebook friends on your website

We’re sure a lot more would come soon. This paradigm of enabling connections can be stretched to a great length by Facebook to enable a lot of interesting functionality.

Whats next is the OpenGraph protocol, which is Facebook’s baby step (but a profound one) towards the semantic web. What it provides is a very simple way for any site to link itself up with Facebook content and pages, so that the sites can show up seamlessly and richly across Facebook – in search results, user profiles or newsfeeds. Site owners can now easily declare meta information on their site that can be picked up by Facebook and shown on newsfeeds, search results and user profiles. Site owners can not only define titles and descriptions for their pages to show up inside Facebook, but they can also direct Facebook as to which section or category on Facebook should the page appear under. Additionally, owners can also declare contact information using the meta tags, which makes it very easy to contact the site owners from inside Facebook. All this is fairly simply, and from what it appears, potentially very effective.

What has the developers interested is the Facebook Graph API. Other than the fact that it brings in a completely new way for developers to interact with the Facebook platform, what is of great interest is that Facebook application developers can cache Facebook’s data on their own servers for more than 24 hours, which was, till now, strictly disallowed. This has raised privacy concerns, and it will be interesting to see how Facebook handles it.

All in all, in our opinion, this appears to be the most important and biggest step in the Facebook system after the release of the Facebook API years back. The effect of this is going to be potentially explosive, and if this works out well, will make Facebook totally ubiquitous, probably even synonymous, with the web.

We are really excited to see the private-beta release of Voyavo, a trip planner, which we recently developed for one of our clients, Momentum Design Lab.

Voyavo is an application developed with latest web2.0 technology and cutting-edge user interface. Highly interactive and having all the social interaction features – Voyavo is just the right tool for all the travel enthusiasts for planning their trips. Apart from making trip management a piece of cake, Voyavo also helps you find the best and book flights, hotels, car hire and activities and you can easily add them to your itinerary.

Voyavo brings a more social travel experience with the ability to share proposed itineraries, watch for the best priced items, store travel bookings, and quickly develop a travel plan – to meet the needs of all travelers on a trip, before your book the travel details. Voyavo harness social networks and helps consumers to organize, share details and invite others to join in travel planning and search, book, post and share activities with friends, family and associates.

All of your restaurant reservations, day activities, flights, hotel stays and other details from your trip can be kept together and organized by day, and by week. Voyavo has a seamless integration with maps and you can even view your trip details in relation to each other – get directions to and from all your planned events. With a number of privacy options, you decide who can view what. Keep your own itinerary separate from everyone else. For group trips, you can keep a separate itinerary that is private from the rest of the group. You can also create other organizers to help plan the trip. You can also create a watchlist of fares & prices – Voyavo keeps track and notifies you of the best deals and prices of flights, hotels, and cars you add to your watchlist.

You can login with any of your social network or email accounts – connect to Voyavo with your MySpace, Facebook, Yahoo!, AOL/AIM, Gmail, OpenID, or Twitter account! You don’t need to create another set of login information you might forget! Invite your friends from Facebook and your address books to easily keep everyone up-to-date on travel plans.

Voyavo is developed using Symfony and JQuery – the latest in web technology. Symfony is a php-based framework designed on the principles such as DRY and KISS. It is the perfect tool for developing feature rich complex web applications such as Voyavo. It is also highly customizable with a wide range of plugins and an active community. JQuery is one of the most feature rich and customizable javascript library. It accelerates development to a great extent and helps you deliver a highly enhanced GUI to the users. Again, with a wide variety of plugins available, you can create a state-of-the-art interface to impress your consumers.

Symfony is a great framework to build sophisticated, maintainable, extendable and scalable applications using php. Following the MVC paradigm, it keeps code maintainable, and heavily minimizes the number of repetitive tasks that need to be performed while building and maintaining the application.

Choosing the right tools for development of a product is an essential part of its success. Symfony developers at Mobicules understand this and recommend the best solutions from the industry.  The Internet is ever-changing and ever-expanding and so are the applications.

We know it makes more sense for most people having their social networks built to have a first version built very quickly and test it with the target user group or the market, but we have recently had experience with building social networks where the focus was on coming up with an architecture that will scale up to 10s of millions of users economically and effectively. Web developers at Mobicules did an analysis of all the options available, and the following is a quick summary of our findings and recommendations.

Goal

To select a platform/framework which will allow scaling to 10s of million users for a social application.

The core issue here is Database Scalability and Flexibility. We’ll touch upon both one by one:

Database Scalability: As it turns out, perfectly normalized, flat databases with absolutely no data/information duplication are not essentially right for applications that need to scale to a huge user base. Such a database structure needs excessive computation and a lot of table joins, which end up getting computationally very expensive as user base grows.

Database Flexibility: Complete control over database structure is required if one is to design an application that is needed to scale to a huge user base, as with time, different clustering and partitioning schemes might be required to help the application scale horizontally.

Platform Assessment

The following is an assessment of Elgg, Drupal and Symfony on the above parameters:

ELGG: Due to a very flat and normalized database structure, the only way to scale horizontally with ELGG is to duplicate the database using MySQL replication on multiple servers. The negative with this approach is that it ends up duplicating the complete database, with the result that each machine running a copy of the replicated database will have to be very powerful server, rendering the solution expensive. (MySQL clusters is a standard way of doing it)

Drupal: Similar problems as ELGG with Drupal development , but database is not as flat and normalized as ELGG. Scaling up in a similar manner as described for ELGG wity MySQL clusters would probably be cheaper with Drupal.

Symfony: Allows us to use a custom database structure. We can design the database and replicate it as we like. Symfony also uses its own query/object caching mechanism, which is efficient. As an example, the Yahoo bookmarks site supports 20 million users on Symfony.

Proposed Solutions

Solution 1:
Get deep into the ELGG code and customize the database interaction layer so as to support our own database, that can be designed and partitioned as we wish. The problem that this approach comes bundled with is that subsequent ELGG updates/releases will not be directly usable by us, and we will have to manually merge them into our ‘custom ELGG’. The positive of this approach is that ELGG plugins will work on our ‘custom ELGG’ with none or very little changes, if any.

Solution 2:
Build the solution ground up with Symfony, with our own custom database design that allows us the flexibility to partition it as we like.

Recommendation

Our recommendation in a case where you are looking to scale up to 10s of millions of users would be write everything from scratch (and not use a ‘platform’ like ELGG/Drupal), that allows you to customize and tweak anything and everything. Symfony seems to have a good reputation for enabling creation of very large websites, and so, we would recommend using Symfony as a framework.

With this experience in the background, Mobicules is now capable of designing, developing, deploying and maintaining rich kiosk multimedia applications and kiosk management infrastructure.

We did a talk at the Facebook Developers Garage, Delhi on why deferring a call to require_login() can be good for your Facebook application. Here’s the presentation.

Here is our Barcamp Delhi presentation about ELGG, the open source social network development platform. Hope you find it useful. We are providing ELGG based social network development services and ELGG customization/plugin development services, so please get in touch with us if there is anything we can do for you.   We’re currently developing a plugin for ELGG, and we’ll be posting about it very soon. So watch this space.

Introduction to ELGG, the Open Source Social Network Platform

View SlideShare presentation or Upload your own. (tags: barcampdelhi barcampdelhi5)

We did a talk in Barcamp Delhi on Facebook Application Monetization Case studies, which generated a very good response from the attendees. We had a lively discussion that ended up taking quite a while longer than the allotted time. Here’s the presentation.

We have been doing Facebook Application Development for quite some time now, and many of our clients come in with queries about how to best monetize on Facebook. The presentation above might throw some light on answers to that question.

Facebook recently announced its Connect program, and we at Mobicules are really excited about the possibilities. There is already a good amount of buzz about Facebook Connect, and we’re talking to a few of our clients about how this can fit into their scheme of things, and can make their web applications more useful and more “sticky”.What Facebook Connect does is, it allows users to connect their Facebook profiles, friends and privacy rules to any site.

What that would mean is that a website which was not social until now, would suddenly come alive, with the user’s Facebook Social Graph being instantly available on the website. It looks like a lot of privileges available to Facebook Application Developers till now would now also be available to stand-alone websites.

We think this is a very sensible balance between
(a) Developing a stand-alone website, attracting users, getting them to invite friends and get them all engaged, and
(b)Developing an app for Facebook that can use Facebook’s features and data, but now has no independent presence.This is going to make a lot of sense to a lot of people.

We’re eager to start working with our clients on this.

Google’s OpenSocial defines a set of open API, which developers can use to build applications that can be hosted on websites that are “OpenSocial Containers”. OpenSocial containers are websites that have provided implementations for the OpenSocial API, and plugged the implementation with their data, effectively making their data available to applications which use the OpenSocial API. This opens up a great possibility for website owners who have any kind of social data, making them ideal candidates for hosting social applications. Social applications on a website can take a user’s engagement with the website to a whole new level.

How does one convert an existing website to a Social Container? Thats an important question to ask, and as it turns out, its not really too difficult. But before we get into that, it is important to understand a few things about the Google development platform in general.

Google has had, since long before OpenSocial, a widget platform that supports widgets called Google Gadgets. Google Gadgets API enables hosting of widgets on the iGoogle page, and provides APIs to access data from various Google Services like Google Maps. What OpenSocial does is, it extends the list of APIs to introduce APIs that make social data from a social container available to a social application.

Due to the reasons above, Implementing an OpenSocial Container broadly requires implementing the following two components:
1. Gadget Server providing the Gadgets API – The Gadget Server implements the Javascript Gadget API which allows Google Gadgets to be hosted and run on the Website

2. SocialData Server providing the RESTful APIs for servicing the requests from OpenSocial Gadgets (Social Applications) – The SocialData server would connect with the website’s server at the back-end, and provide implementations of the RESful APIs to be used by the Social Applications.

As it turns out, doing the above is not excruciatingly complicated really. Shindig comes to your rescue here. Shindig is an open-source implementation of the Gadgets Server and the OpenSocial API. Once you have Shindig running on your server and plug with your website, your website will be able to host Google Gadgets, and service OpenSocial API calls. You’ll have to plug in the implementation of the APIs with your websites’s back-end database to enable the APIs to access the data.

So there! Make your website an OpenSocial applications host, and engage your users with new and interesting functionality.

We think Dialog Boxes are the most underused among features provided to developers by the Facebook Developers Platform. We find that Dialog Boxes, if used, are used mainly for issuing alert messages on User Actions. While it is very reasonable to use Dialog Boxes that way, there’s a lot more Dialog Boxes can do.

Dialog Boxes are a very good way of taking user input, validating it, and submitting it to the server without having the user navigate away from the page where he performed the action that opened up the Dialog Box. This keeps navigation, simple, compact and very very intuitive. Have a look at the use of Dialog Boxes we’ve made in iAspire. We use Dialog Boxes for almost all user actions where the user needs to enter any additional input after having taken the action.

We recently had a requirement from one of our clients to build a fairly complex dialog box that was a complete menu system that would allow the user to navigate a list of objects arranged as a tree, read details about them which would pop up in boxes inside the Dialog Box, and finally, purchase or add one of them to some sort of a cart. We thought it would be just about impossible to do it with a Facebook Dialog Box, but thought we should try a few it out. And know what, its all possible from inside a Dialog Box!

We’ll post the link to the application when we have released it, and a few tips/caveats/gotchas too. Till then, have a look at the documentation .

We haven’t found anything with the Facebook Developer’s platform to be as intriguing as Templatized Feeds. Templatized Feeds were released by Facebook with an assurance that Feeds which are properly constructed would also land up in the News Feed of those friends of the user who sent out the feed who haven’t installed the application. Now that creates a great viral possibility, and we are among the many developers who went ahead and took the pain to modify their feeds to suit the Feed Template formats.

But with no results. We haven’t yet seen our Feeds landing up on non-application users’ News Feeds. We investigated into this, and here’s what we think is critical ot successfully publishing Templatized Feeds to a large number of users on Facebook:

1. Possibility of Aggregation: The TitleTemplate and BodyTemplate fields of the feed must be simple to aid aggregation. Best practice is to have everything other than the {active} parameter in the feed unchanged from feed to feed. The {target} field should not be used, as it reduces the possibility of aggregation.

2. Links: All links in the feed should be accessible to the viewer of the feed without having to add the application. Facebook analyzes the click-stream of the user once he clicks on any of the links in the feed, and records it if installation of the application is needed to view the content behind the link. Forcing an install from any of the links would put the Feed into Facebook’s bad books.

3. Quality of Content: All links in the Feed must point to pages which are relevant to the content of the feed. This means linking everything to the About page of the application might not help. This implies developers might have to put in a good amount of effort into making some pages from their applications viewable without the user having to add the application. Many leading applications seem to have done this, and we’ve done it for iAspire too here.

There’s no guarantee even after you’ve done all the above that your feeds would land into the News Feed of non application users. But without having implemented the above, it seems, there IS a guarantee that your feeds won’t reach too many users ! Take your pick.

We’re back with some cool new features with iAspire. We have been listening to our users, and have just put in a few of the most wanted features. Here’s a quick overview:

1. Create your own Aspirations: We have just modified this feature to do away with the moderation because all you users had been adding really great Aspirations. You can click the “Create an Aspiration” button on the top right corner of the page to create an Aspiration.

You would need to upload an image for the Aspiration which is lesser than 50kB in size in jpeg/gif/png format. And you’ll be directed straight to the Aspiration page where you can add the aspiration, and then Inspire your friends to add this Aspiration too. So go ahead, and Express yourself.You’ll see a “Report Abuse” link beside all Aspirations created by users. We are sure our users would use this link to keep iAspire clean and free of any inappropriate content.

2. Convert your Aspirations to DoneIts: iAspire is not just about Expressing your Aspirations, but also about collaborating with your friends, Inspiring each other, and actually achieving your Aspirations. So when you have done that, you can convert your Aspiration into a DoneIt. Use the DoneIt button beside your Aspirations on the “My Aspirations” page to convert your Aspirations to DoneIts.

Upon doing this, you can edit the text that you had enterd while adding the Aspirations to convert it to your DoneIt text.3. Delete your Aspirations: We all change. Something that appeared to be the ultimate goal of our lives till yesterday might not appeal to us today. Thats why on iAspire, you can remove your Aspirations. Just look out for the cross shaped buttons on the My Aspirations page under the Aspirations and DoneIts tabs.

4. Inspire your Friends: All applications have invites. Its not without reason that an iAspire Invite is called “Inspiring a Friend”. When you Inspire a friend to join a certain Aspiration, and the friend joins it, we credit you for having successfully inspired your Friend. You’ll see a link about the details of the people you have inspired on the My Aspirations page.

Hope you have a lot of fun with these features. We are very keen to listen to all you users, so keep the feedback coming.Keep Aspiring andInspiring,The iAspire Team

The number of Applications on Facebook has risen continuously since Facebook announced its Developer API in mid 2007. While there has been a slew of applications, it is very easy to see a clear trend. As much as 50% of the applications on Facebook are identity definition applications like Characteristics and Compare People, where people characterize their friends, and get characterized in various ways. A big share of the rest of the pie is taken by communication enabling applications like FunWall and SuperPoke which identified the limitations in Facebook early-on and made a field-day of the lower restrictions on spamming in the early days of the Facebook Developers Platform.

Is that all? Can a Facebook Application go beyond the fun to be had out of throwing cows at people, and try to do something that is useful, engaging and fun at the same time? Is there much sense in trying to do anything like that on Facebook? Why not an independent site? These are big questions. And questions any one launching a web-app today must answer. We have taken a close look at Facebook, and we think we have an answer.

We think it makes a lot of sense for a lot of web-apps to start out on Facebook, and here’s why:

1. An existing Social Graph: Any web-app that needs connections between its users to be established should consider being on Facebook. It makes a lot of sense to utilize the connections that people have already built on Facebook with their friends, family and strangers, than to try building it all over again from scratch in a stand-alone web-application.

2. Diverse user demographics: While almost all of the current most successful applications on Facebook have ridden on huge activity of teenagers on Facebook, there is a continuously rising base of users who are post their mid twenties, are college grads, and are not really interested in xMe and SuperPoke. A “useful, engaging and fun app” sure might appeal to them.

3. Freedom to Developers: Facebook allows developers to do pretty much anything inside their applications as long as they do not bother Facebook users who don’t want to use the application. This allows web developers to do just about as much they could have done on an independent web-site, at a place the user frequents often.

The above three factors, combined together, offer a very exciting possibility for anyone launching a web-app today. Your web-app might be of the “serious” kind, and not as much “fun” or “viral” as a FunWall or Compare People, but it would still make a lot of sense to launch it on Facebook. What more, a “serious” application can potentially put the Social Graph to more interesting, beneficial and directly monetizable uses.

Of course, the opportunity comes with its own set of hazards. More later!

iAspire is an innovative, meaningful and engaging new application on Facebook by Mobicules. Express your Aspirations, and know what others Aspire to with iAspire. Discover people with similar Aspirations, and grow your network by connecting with them. Join iAspire on Facebook.

Visit this page for the latest news, views and updates about iAspire.