Moderator		Panelist		Panelist		Panelist
Pari Natarajan		Derek Waugh		Steve Jones		Gowri Subramanian
CEO and Co-founder, Zinnov Consulting		Director – Software Engineering, NCR		Technology Director, Cybit		Co-founder & CEO, Aspire Systems

Date: Tuesday, March 9, 2010

Time: 11 AM GMT

(Registration is Free)

Over the last several years, many packaged software vendors/ software providers have outsourced their development needs with cost-cutting in mind. However, that’s no longer the case. While having global R&D delivery capabilities are important, there’s more to it that just cost advantages.

Today, from architecture and design to development and support, offshore R&D teams are working hand-in-hand with their onsite counterparts to deliver innovative software at a faster pace and high quality. Global teams are now helping companies stay ahead of the curve, innovate and grow – and those who don’t utilize their capabilities are likely to be the ones left behind.

But not everyone reaps the benefits of globalization equally. So what are the factors that can help you leverage distributed R&D?

Join Aspire Systems for a Panel discussion on “Distributed R&D: Beyond just Cost Benefits”.  Some of the themes discussed will be:

• The impact of distributed R&D on software companies/teams
• How do you leverage software/product engineering expertise of global players?
• Challenges in outsourcing and how to overcome them?
• Globalization – myths and realities
• Best practices pertaining to globalization & distributed development

Aspire together with our customer, Biz-LX™ is organizing an informative webinar where we discuss the journey of building a software solution using Web 2.0 tools such as RIA and mashups, and demonstrate the benefits of such an exercise with a real-time case study.

In this webinar you’ll learn:

- Techniques used to design software solutions to allow better usability
- How to evaluate and select Web 2.0 techologies suitable for your software?
- The business benefits and implications of applying Web 2.0 designs to your software solution

Date: Thursday, Nov 19, 2009
Time: 11:00 AM ET/04:00 PM BST/ 09:30 PM IST

Regsitration is FREE!

Click here to register:

https://www1.gotomeeting.com/register/587477833

Panelists:

Dave Strite
Chief Information Officer, Biz-LX™

Elango Kanakaraji
Head – Web 2.0 Specialization, Aspire Systems

Here are some excerpts of the interview:

In the recent past, you’ve built engineering teams for 2 startup SaaS companies – what do you look for when building these teams and what were the major challenges you’ve faced?

John: I have been very fortunate in my career to have worked with a lot of talented people. Early in my career I worked at Lotus Development on products like 1-2-3 and Lotus Notes and was able to learn a lot about how great teams are put together and, equally important, how energy, excitement, and motivation is maintained while working on projects.

Putting together a great team in any company starts with having a clear understanding of your goals, looking out from 3 – 24 months. From this understanding you build an understanding of your needs, enough to recognize the skills required. From an individual perspective, the keys are character and skills. The key attributes that I look for include:

• An expert understanding of the skills required for the job. If I need a C# developer with 5 years of experience and knowledge of MVC I expect to hire people with those skills.
• I look for past examples of flexibility in their job roles. In startups you will be challenged to fill many roles, not just the one you were originally hired for. I love these challenges; you learn a lot and become a much more rounded individual. However, not everyone thrives under these conditions.
• I look for ethics and honesty. I want to work with people who can be honest about their failures, their shortcomings. When I ask people if they agree with a course of action I expect honesty. I will never know all the answers and I want people who are unafraid to speak up for the betterment of the team.

The most difficult thing in a startup environment is to bring enough attention to team and personnel development. I preach the importance of these things, I believe in these things, and I do better than many people I know. However, I find it very difficult to meet my own personal standards on this front. The challenges are varied, ranging from lack of money for training, lack of time for focusing on individual goals. At the end of the day this is an area where I know I want to focus more energy.

Is software usability a true differentiator when it comes to enterprise products?

John: Yes, and no. Many enterprise products are more difficult to use than they should be. Businesses will often have usability as a single item on a long checklist of features, and will sacrifice it over some other critical features. As some Enterprise products are commoditized, however, you see a stronger emphasis on usability arising, as it becomes more important when product pricing brace to the bottom.

From a software engineering perspective, what are the key things you would focus on to build highly scalable software?

John: As with everything else you need to understand the corporate goals and expected growth patterns for your software. While there are no one-size-fits-all rule that I would provide I would always urge focusing on database scalability first. It’s easier to scale web servers than database servers. From a performance perspective, however, I often see the biggest performance bottlenecks arising client-side with an over-use, or incorrect use, of AJAX capabilities. It is easy to bring the browser to a crawl if you are not diligent in your coding and testing efforts.

Read the full interview

2. Minimize server round trips: Minimize the number of hits to the server during an operation. For instance, while loading data or executing a set of operations.

3. Use memory sparsely: While using memory-critical system resources, stick to ‘Acquire Late Release Early’ principle. For example, opening web/DB connections and creating IO streams. Also determine the data required for the current page and current request and load only as much.

4. Use lazy/ asynchronous processing whenever possible: Always reduce the amount of workload for a single request by opting to delegate part of the work to a background process, by opting to make an external system’s processing asynchronous or by doing the processing later.

5. Use remote invocations selectively: Remote invocations are very expensive and have great impact on performance. Hence use them as selectively as possible.

6. Profile your code frequently: Use performance testing tools like SQL profilers and code profilers to benchmark your product’s performance. Also deploy some code analysis tool(s) in parallel, and make sure your code passes through all performance parameters in the project-specific checklist you have arrived at.

7. Audit performance: Monitor and track (log) performance-related data at chosen parts of the code consistently to monitor performance.

8. Benchmark your product for performance: Test your application periodically with large quantity of data and use appropriate tools to benchmark your application for performance.

1. Identify the right set of Test Data for testing:
Produce the right set of test data for testing. This test data (range of positive and negative values) will help you uncover the issues quickly

2. Make the test environment identical to production environment:
Have a thorough understanding of the test environment and adhere exactly to the same hardware/software requirements replicating the production environment (like operating system, database, application server, browser, patches etc.)

3. Complete unit testing before you do integration / system testing:
Test your units first, and once you’re convinced that they have no errors, start integrating them slowly, testing in groups of two, then threes, etc., until you finish testing the entire suite

4. Focus on Numbers:
Always collect quantitative data during different phases of your testing. During performance testing, get clear and exact numbers on the response time, throughput and resource utilization goals

5. Use 80/20 rule or Critical Path Testing when required:
Identify the right testcases that will provide maximum impact when testing the application. Identify specific test cases which will prove effective during multi-platform testing. For example, identify a page that has maximum controls and run them once in all the browsers

6. Test from the user’s perspective:
Focus on testing the functionality from an end user perspective. Discuss with the product management team in understanding how they approach the application. Interact with product support teams to know customer support issues which may give you idea on issues. Focus on specific areas of testing based on application needs. For example, security is of paramount importance when testing credit card or banking applications.

7. Perform Root Cause Analysis for Defects:
Mark defect as unit, functional, integration, system, etc at the time of filing them to perform effective root cause analysis. Perform root cause analysis periodically. Put in a prevention mechanism to avoid such defects in the future.

During execution, do not ignore failures. Troubleshooting the root cause of ‘fail’ will lead you to the solution of the problem.

8. Write clear, descriptive and unambiguous bug reports:
Be precise while writing the defect summary and its description. While writing the description, document it clearly and make sure that the developer does not misinterpret it. Attach snapshots wherever required

1. Know your end user and their working environment: Find out how the software you are developing will be used and get to know the end-user’s working environment. Look at the product from the end user’s perspective and use the existing product yourself to get a better idea. If possible, try to interact with the end user on certain functionalities to understand his/her expectations of the product.

2. Know the data that you are going to present to the user: Consider the volume of data, how the user is going to use the data (e.g. reports, graphs, etc.) while designing the user interface. This will impact the kind of controls you would choose to present the information and how the user would utilize the information.

3. Keep the UI simple: Show only useful and relevant information to the user. Do not clutter the screens with too many controls, buttons and other widgets. Think about how to present the information (data) in a powerful way to the user (e.g. grids, images, graphs etc.).

4. Navigation is important: Simpler the navigation – faster the task accomplishment. Provide clear entry and exit points for different functionalities. Ensure that the user can return to the appropriate location of the page from where the last action was taken. Make your navigation flexible to accommodate future requirements (e.g. tabs).

5. Be Consistent: Consistency in both appearance and behavior enables users to build an accurate mental model of the way the application works and accurate mental models lead to lower training and support costs. Use templates and a consistent approach while designing screens.

6. Create a match between your application and the real world: Always use words, phrases, and concepts that are familiar to the user. For example, say “Patient Chart” instead of “Patient Database Record”, show calendar icon for dates and so on.

7. Use standard GUI controls without altering their behavior: Users know how to use standard GUI controls. Do not change their behavior for your requirements. Avoid the usage of non-standard GUI controls, whenever possible. Position the controls for easy usage and group them properly.

8. Design for minimum inputs required from the user: Ensure that common inputs are required only once from the user. Do not ask the users to do more work for data entry, retrieval of information and operations. Spend more time on programming and minimize the user’s work (wherever possible, pre-populate the data).

9. Keep your user informed: Always let the user know what is happening in your application by providing appropriate feedback. When the user performs an action, provide feedback to indicate that the system has received the input and is operating on it. For example, if the user is deleting critical data, ask for confirmation before deleting the data. Make sure that the error messages use simple language, states the problem and provide solutions so that the user can fix the problem.

10. Expect that the user makes mistakes: Ensure that no matter what the user does,they can’t mess up. If they make a mistake, provide a mechanism to undo these mistakes and ensure that data is protected.

11. Consider technology impacts on UI design: Consider implementation techniques like Ajax, multiple image/content servers, personalization techniques to make the user experience pleasant.

12. Do time-study: User should be able to access important areas of the application with minimum amount of time and effort. Provide multiple paths to the user for all the important areas of the application. Do a time study on how the user would use your screens.

13. Do Hallway testing: Bring 2-3 people to play around your product and observe carefully, without commenting, while they are using it. Listen to their feedback – what they say and what they don’t.

Frameworks help maintain developer discipline, limit unnecessary re-invention of the wheel and provide features that are almost universal requirements. Enterprise product frameworks go one step further by providing a pre-built product architecture layer with many cross-concerns and design decisions addressed. This helps development teams focus on solving business issues and reduces development time by more than 30%.

“Propel” is Aspire Systems’ enterprise product framework, that reduces the time and cost to develop a software product by about 30%. It comes with a pre-built, tested product architecture layer and can help developers focus on solving business issues, instead of worrying about basic design decisions and other cross-concerns.

Aspire Systems hosted a webinar on the importance of Enterprise Product Frameworks this month.

Some other key take-aways from this session:

• How product frameworks can be leveraged to your advantage.
• The quality and other indirect benefits of using frameworks.
• How Propel can reduce your development time and costs by 30%.
• Real-life experience of Ajuba Solutions on how they use Propel to develop their solutions rapidly.

The recorded webinar can be viewed by registering here

1. Keep it simple: Simplify your design and do not complicate or over-engineer it. Frequently iterate through the design and look for avenues to improve.
2. Validate your assumptions: Design issues lead to major challenges in the product. So, if you have questions, get them clarified before you finalize the design.
3. Pay undivided attention to NFRs: Along with your functional requirements, design your product to fulfill non-functional requirements. Consider NFRs at the beginning of the design.
4. Use proven design patterns: Design patterns help in solving commonly encountered problems. Use design patterns wherever possible as it will help you uncover issues that can cause major problems during development.
5. Design interfaces first: This will help you start thinking about integration right at the beginning and will help in reducing integration challenges in future. This will also set the boundary for coding.
6. Build prototypes to validate your design: For every architectural and design step, build proof-of-concepts and prototypes to validate your design. This will help the design gain acceptance across the teams and also showcase how it works.
7. Communicate your design effectively: It is as important to communicate as it is to do proper design. Always use UML to depict your design; use a tool for depicting your design.
8. Go for reusable components and breakup the interface into logical pieces: Reusable components help reduce development efforts and also increase the quality of the work – check with your architect though before picking up components. Choose components from reliable sources and make sure you comply with their licensing requirements (if any).
9. Incorporate statistics in your design: Numbers are very important. Bring in mechanisms to get performance statistics, usage statistics etc. into your design. This will help you a lot while analyzing the overall performance of the product.

1. Adhere to your design: Follow your architecture and High Level Design. For example, always write code with respect to the layering architecture mentioned in your design. Know where to write each piece of code.

2. Use reusable components: Wherever possible, design and implement reusable components. Also check for existing reusable components in your project and across other projects in your organization before developing a new one.

3. Prepare LLD before coding: Design the LLD for your piece of functionality/work in terms of standard UML based interaction or Sequence Diagram for validating the design. This will help you in bringing a thorough consideration of requirements for your design without expecting surprises at a later stage. This will also act as a validation gate before the implementation is started, capturing short comings (if any) in the design with respect to the requirements.

4. Don’t over-engineer your code: Follow a minimalist approach to meet business requirements; however, your software should be malleable enough to meet changes in requirements without major rework.

5. Adhere to coding conventions: Don’t introduce any new conventions of your own in the code, always adhere to the standards defined in the project. If you have any concern with the prevailing standards then raise a flag to the appropriate person before following your own standards. This will help in having maintainable code.

6. Attempt 0 compiler warnings: Always try to make sure that your piece of work compiles with 0 compiler warnings; no matter how existing/old code has been written.

7. Centralized database control: Make sure that a single person manages the database related changes e.g. table, field level changes, stored procedures etc. Wherever possible make sure that you bring SQL into your source code repository.

We’ve defined good engineering practices, coding and design practices, performance and usability engineering practices and testing best practices. We’ll post them up here one by one, starting with our take on good engineering practices.

Please feel free to let us know whether you agree or disagree with any of these – whether you think some of them aren’t really applicable in some cases – or if you have any additions/modifications to these lists. I look forward to hearing from you.

Our list of good Engineering Practices that will help you produce higher quality output:

1. Dig deep into requirements: Collaborate frequently with all stakeholders and do more prototyping to clarify requirements. Use the Pareto rule: spend 20% of the effort required to identify 80% of the requirements, without getting into elaborate ceremonies. The remaining requirements will automatically fall in place once you start the iteration(s). Postpone doing any development work until you are clear with the concept (while everyone understands that you should expect changes).

2. Write structured code: Think how you will structure your code before you start writing. Write your code in small pieces – multiple functions and methods. Extract common functionality into methods and never duplicate code. Always look for reusing existing methods.

3. Use code analysis tools: Make sure that you have a source code analysis tool such as FxCOP, PMD, etc. integrated with your IDE. This will help you do code analysis easily and also help you adhere to coding standards.

4. Self review your work: Make sure you review all your work products. Never release deliverables without reviews. Generate a report from your defect tracking tool and do a root cause analysis on the bugs you have introduced. This will help you continually improve.

5. Write automated unit tests: Always write automated unit test cases as a part of your work. Integrate them as a part of your automated builds.

6. Test early and often: Testing your work is your responsibility. In addition to testing on your machine, always move your code to a fresh environment and test again. Never release your deliverables without testing.

7. Document your code well: Make sure you add inline comments in your code. All functions and methods should be adequately commented. Provide extensive commenting for complex logic. Generate code documentation with tools like nDoc, javadoc and review it.

8. Synchronize your code everyday: Make sure you synchronize your code with the repository on a daily basis. This will ensure that you have up-to-date source code from everyone and will reduce integration issues.

9. Communicate extensively: Communicate every day with your team and manager on your progress and challenges. Update your project management system on a daily basis (time sheet, project plan, task status, defect status, wiki, burn-down chart, etc.).