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 »
Need for AppFabric
As a trend Microsoft has always tried to come up with kind of programming models that are focused on faster business logic development thereby moving away the developers from intrinsic implementation details. Ideally developers shouldn’t spend their time creating infrastructure. The people who write business applications should focus primarily on creating business functions for their users and not infrastructure. Whatever infrastructure is required should be provided by the platform they’re building on.
With .Net 3.0 Microsoft came out with two new programming paradigms that are modeled to assist the developers to implement business logic more easily than ever with Windows Communication Foundation and Windows Workflow Foundation. WCF took SOA and interoperability to next level and WF provided platform for authoring and execution of long-running workflows. Till .Net 3.5 developers needed to write their own infrastructure stuffs.
Microsoft in its attempt to provide a platform for better application infrastructure rolled out Windows AppFabric. By providing a set of extensions to Windows Server, Microsoft aims at making it easier for Windows developers to create faster, more scalable, and more manageable applications. To come up with terms of the requirements of a complete ecosystem MS released two application development platforms: -
- Windows Server AppFabric: This provides comprehensive infrastructure based on IIS 7.0 & WAS based platform to provide caching and WCF/WF services. AppFabric comes with limitation of targeting only IIS 7.0 and above. WAS provided several features that were always present on the wish list of the developers who work around the Service-oriented Architecture (SOA). Features like Message-based Activation, capability to recycle worker process, application management and easy configuration.
- Windows Azure AppFabric: This provides a comprehensive cloud middleware platform for developing, deploying and managing applications on the Windows Azure Platform. It delivers additional developer productivity adding in higher-level Platform-as-a-Service (PaaS) capabilities on top of the familiar Windows Azure application model.
AppFabric is not the same “app server” both for Windows and the Cloud as there is absolutely no feature parity between the two. Windows Server AppFabric provides service hosting and caching, while Azure AppFabric provides Service Bus and Access Control. The two are "AppFabric" in name only. In this article we shall only cover Windows Server AppFabric. The idea of this article is to get started on configuring & understanding Windows Server AppFabric.
Continued »
Category: Concepts, Framework | 1 Comment »
Introduction: Ever since the dawn of the Internet Application Service Providers have developed internet based applications for which they can charge through a subscription based business model. Earlier there was no standardization across these online service offerings, but web services emerged to create various standards for providing these online services: SOAP, UDDI, etc. Internet businesses adopted web services quickly and started introducing pay-to-use services on the Internet. Many companies even made publishing web services through a subscription model as their core business (weather services, financial data, etc.).
Continued »
Category: Concepts, Design | 1 Comment »
When you are developing a windows application, it is necessary to have an updater strategy built-in. We all know that enhancements and fixes are a part of the software development process. Best practices and frameworks exist for creating application updaters services, and integrating them in your windows application. Microsoft provides ClickOnce technology which makes it very easy to package your application so that it can easily updated whenever there is an update in the application. Another approach is the Updater Application Block (UAB) which is a bit more difficult to implement, but also offers a great deal more flexibility in what you can do with it.
Continued »
Category: Concepts, Design | No Comments »
Scalability and robustness
Since a very compelling business reason for using cloud computing is the ability to scale on demand and when needed, using the best practices and guidelines for designing large scale distributed systems is a good starting point. While academia has a preference for distributed transactions, ACID properties, and all kinds of consensus protocols, you are better off with loosely coupled systems where nodes will eventually reach a consistent state (as opposed to waiting for all nodes in a very large system to reach a consistent state before proceeding). Considering the state of existing systems, loosely coupled self healing self regulating systems should be preferred over system with exotic distributed transactional properties and consensus protocols. Continued »
Category: Cloud Computing, Design, Programming | No Comments »
Enterprise Application Integration
You need to consider how your system integrates with other systems in your organization. Clouds are good but one-off systems that use cloud but do not integrate with existing systems will diminish the payoffs of using a cloud.
You need to consider how your system and its data get integrated with existing data. This may need to be done both ways. Without access to existing data or data created and maintained by your cloud based system, you will again limit the potential of your system under design. Continued »
Category: Cloud Computing, General, Programming | No Comments »
Definitions and architecture
I am not a big fan of using definitions as a starting point. In technology many useful and successful concepts have escaped definition. People still argue about what exactly is an object in an object-oriented system. There is no scarcity of definitions for software architecture. The internet cannot be pinned down to a simple definition. A definition, however, it is still useful in certain contexts. Continued »
Category: Cloud Computing, Design, Programming | 3 Comments »
We have all heard the usability spiel: that technology is more or less a commodity, that ease of use – and in fact “delight of use” – should be paramount. We have also heard the horror stories of expensive enterprise and consumer applications that failed miserably because they were just too “kludgy” to use. Yet even today, for every wonderfully user-centric design (think iPhone) there are dozens of desktop or web applications that are boring at best, and simply unusable at worst.
Why is this so? Perhaps the problem is that when you are early in the SDLC, there are so many other challenges and moving parts that you have little time to worry about usability. You worry that bringing the “naïve” users in for design discussions will just derail the project or send it off on a tangent. On the other hand, if you wait till you are through with version 1, you have been compromised as well – it requires great courage to admit at this point that usability is poor and that major elements of the application have to be re-designed.
These are formidable challenges. Yet we at Nagarro recently had a very positive series of usability-related discussions with a major client, which may be useful to recount in this context.
Continued »
Category: Usability | No Comments »
I am a big fan of .NET reflection. However most often you will hear more of critics than praise. The biggest of all “It’s slow.” Web is full of cautions and warnings telling you not to use it. Some will go as far as saying that if you care for performance, do not even think about using reflection. If you go on and read beyond the highlight points, you will realize that a large percentage of these warnings and cautions are discussing a particular scenario where some developer failed to get what s/he was trying to achieve. And while being judgmental with the experiment a generalized statement like this comes up as an end result. Continued »
Category: .Net, Concepts, Programming | 2 Comments »
Google recently released a Java runtime environment for their App Engine platform. As a software development organization, this offering is of special interest to Nagarro, as it offers several advantages over competing cloud hosting environments. Hosting a Java application on Google’s infrastructure provides automatic scaling and load balancing, a feature that is of interest to a number of our software product development ISV customers. To better understand the issues and risks, we conducted an internal exercise to assess the technical effort required to port an existing application to the Google App Engine for Java (GAE-J). Continued »
Category: Design, Framework, Java, Programming | 2 Comments »
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 »
One of the first places where the ActiveRecord pattern first appeared, was in the book Patterns of Enterprise Architecture by Martin Fowler. The ActiveRecord pattern embeds the knowledge of how to interact with the database directly into the class performing the interaction. Continued »
Category: Concepts, Java, LAMP | No Comments »
