Just searching the title of this blog post on Google will give you a ton of information and opinions about HTML5 mobile apps versus native mobile apps. In my opinion, the question that is being asked is sometimes unfair. If you are asking whether HTML5 mobile apps will be the death of native apps, then you are putting too much responsibility on the poor young shoulders of HTML5.

However, if you are asking whether HTML5 is a viable alternative to native apps for developing mobile apps, then we are talking about a completely different matter. This is a debate that often comes up when we are discussing mobile strategies with our clients and prospects. The answer (as is the case with most things) is always “it depends”. In order to put things in a little more structured manner, I put together a couple of SWOT diagrams that illustrate what is good or bad with both these options.

Continued »

Category: Mobile | 3 Comments »

The recent buzz about Apple leaving people running OS X 10.4 in a lurch if they buy the latest iOS devices (such as iPhone 4 or iPad 2) got me thinking about how important backwards compatibility is when you are a products company. The issue is that new iOS devices require iTunes 10.x to sync with the computer. However, iTunes 10.x requires a minimum of OS X 10.5 to run. This means that anyone who is still running the (couple of generations old) 10.4 version cannot use a new iOS device unless they upgrade their operating system.

The catch? You have to pay for the upgrade. There is an upgrade cost of around $30 to upgrade. The reason there’s been a lot of buzz is that the new iTunes works just fine on Windows XP (OS X competitor). This simple instance demonstrates the wildly different approach that a product company can take when it comes to providing backwards compatibility.

This post is not an analysis – instead it’s just a collection of examples taken from various articles about how different software giants handle backwards compatibility.

Continued »

Category: General | No Comments »

Here’s a blog post by Martin Fowler on Cross Platform mobile applications. This post talks about the availability of various cross-platform toolkits – allowing you to write a mobile app once and deploy many times. A lot has been said about the flaws and benefits of this approach.

Mr. Fowler talks about the various reasons for why one should not use cross-platform toolkits. From usability perspective to security models across various platforms, there are several reasons that are not in favor of the cross-platform toolkits.

The major crux of his argument is that all platforms are different when it comes to how they are used best. So, if you are not designing for any particular platform (as you are doing when using a cross-platform kit), then you are not putting out the best design for any platform. So, while you do save on some effort and cost, you lose out on delighting your end-user because the overall experience of your application is going to be mediocre.

Here is a summary of the article:

• Don’t use cross-platform toolkits
• For maximum reach: build a web app that looks like a web app
• To appeal to a particular platform: build a native app for that platform, with an experience design based on that platform’s interaction style.

While most of what he says makes a lot of sense (as it should), I can’t help but think that there are still going to be plenty of situations wherein the cross-platform toolkit method looks very enticing. But we are finding that more and more such situations are well handled by making a web application (as Mr. Fowler recommends).

With HTML5 the differences between what you can do with a cross-platform app and HTML5 are not so significant anymore.

What is the approach that is followed at where you work?

Comic credit: Geek and Poke.

Category: Mobile | No Comments »

Measuring your application for performance is something that is one of those things that sometimes gets pushed to the end of milestones. This means that when you do test for performance, if the application is not performing well due to any number of reasons, you have to go back and fix it – going back and fixing things is always costlier and riskier than doing them right in the first place.

At Nagarro, we tend to stay away from this model by training our team members to follow a philosophy that advocates giving importance to performance throughout the development lifecycle. As the diagram below shows, this includes measuring and testing for performance iteratively throughout the development process.

Why is this hard? At Nagarro, we have test benches setup along with a formal performance testing process that the project teams use to measure the performance of their applications. However, being ‘formal’ and how they are setup, it is difficult to use them multiple times during the project. Ideally, I would like performance to be measured in our projects on a daily basis.

We ought to be able to measure the performance of our applications on the fly (on demand).

Continued »

Category: Scalability, Testing | 2 Comments »

At Nagarro, we are big fans of Amazon (even with all it’s fallibilities), and when Amazon launched SES, we couldn’t be happier. SES stands for Simple Email Service. It is a scalable and reliable mechanism for sending mass email at very low prices. We often have the need to send email through applications that we develop (for notifications mainly), and we normally end up using a client supplied email ID which may be running through their mail server, or is provided by their email service provider. However, this has its own set of limitations – reliability is one, and cost is another (with higher reliability options costing a whole lot more).

So, with Amazon’s launching of SES, we now have another option that we can suggest to our customers whose needs include sending large number of emails from their application in a scalable and reliable manner. Here are couple of highlights about the service:

• Pricing: $0.10 per 1000 email messages sent. Data transfer rates are $0.10 per GB incoming, and $0.15 and lower per GB for outgoing.
• Email sending statistics are automatically collected (how many bounces, complaints, rejects, etc.)

First time users get 2000 mails per month free along with some free data transfer per month. This makes it perfect for a service that you can try out up front, and as your needs grow, you pay as per your usage. We couldn’t wait to try it out, so we incorporated it in an internal application. Below is the basic code that we used to send emails using Amazon SES from our .Net application.

Continued »

Category: Cloud Computing, Code Snippets | No Comments »

Wikipedia defines Usability as the ease of use and learnability of a human-made object. “Ease of use” and “Learnability”. As software engineers, we often overlook these two things (which is why Nagarro has a dedicated department for User Experience to make sure our customers don’t suffer from this trait). The reason we overlook these things are very straight forward:

• Ease of use - well our level of understanding as well as skill when it comes to software is above the average software user. So for us, the software that we design is ‘easy to use’. It’s like saying that an airplane is easy to fly – if you are a pilot.
• Learnability – here our view is biased by definition – we designed it, so we don’t really need to learn it; we already know it. It is no wonder that we often forget that the software that we are designing has to be ‘learned’ by the end user – and so we should make it easy for them to learn it.

Much has been said about how to go about doing these two things – and this is not the topic of this post. The reason I am writing here is that sometimes the lack of usability (as defined above) comes back and hits you – and hits you hard. And then when you are in the end user’s shoes, you realize that usability is important; it’s very important. And as a software engineer, you should really pay attention to the usability of the application that you are developing.

Here’s what happened:

Continued »

Category: Usability, User Interface Design | No Comments »

Traditionally, software development for devices that are constrained on resources has been limited to using C/C++ languages which allow for generation of highly optimized code for the device. Higher level languages and frameworks such as C#/.Net provide a lot of productivity gains that have not been translated to an embedded systems programming environment. However, in recent times a number of frameworks have been developed which let you program these devices using Java or .Net.

Continued »

Category: .Net, Framework | No Comments »

It has been a while since we put up a post on this blog. It’s a good thing because at Nagarro we have been extremely busy keeping up with all the new customers and exciting work that has been heading our way. At Nagarro, we do a fair bit of mobile app development and although there is growing demand for iPhone and Android phones, we still see a lot of work on Windows Mobile based phones.

One of the queries that we field the most is with regards to the introduction of Windows Phone 7 (earlier called Windows Phone 7 series). The most common question is whether applications being (have been) developed on Windows Mobile will be compatible with Windows Phone 7.

Windows Phone 7 is NOT a successor of Windows Mobile.

The other question that we answer a lot is whether Windows Mobile 6.5 is at its end of life (since Windows 7 is now out). In this quick post, I hope to spell out the basic differences; and talk a little about Microsoft’s strategy for Windows Mobile.

Continued »

Category: Mobile | 1 Comment »

A large number of applications today have some kind of a notification mechanism built-in. More often than not, an email is used to send these notifications. Typically, while developing these applications, developers use their own inbox to send notifications to. Or they setup some dummy account to send test emails to; or sometimes they might send test mails to real users (it’s been known to happen). Continued »

Category: Testing, Tools and Utilities | 2 Comments »

At Nagarro, we are always looking to stay tuned into upcoming technology (of all types – gadgets to frameworks); and the current flavor is of course Visual Studio 2010 and .Net Framework 4. We have been trying out the beta and the earlier preview versions of VS2010, however, that is not the topic of this post.

Recently, we had the opportunity to give our opinion on the latest avatar of the Ado.Net Entity Framework to Jeffrey Schwartz from Application Development Trends magazine. Jeff was kind enough to publish our opinions in an article on the Visual Studio Magazine (thank you Jeff). The article is titled “Will Entity Framework 2 appease early adopters of LINQ to SQL?“. We, as can be deduced, were early adopters of LINQ (to SQL and others).

If you would like to see that question answered, I urge you to go and read that article. In this article, I wanted to discuss a little bit more about how we look at Entity Framework v2.

Continued »

Category: .Net | No Comments »

Exception Logging is always an interesting problem to solve. Depending on your needs you may have a simple log statement which writes to a text file, or you may need to have a full-fledged exception management module which Continued »

Category: .Net, Framework | 3 Comments »