Quality Software Development

Quality Software Quality Software DevelopmentDevelopmentSoftware Developer Do’s & Software Developer Do’s &

Don'tsDon'ts

Touchpoint Solutions(I) Pvt.Ltd04/14/23

What is software 'quality'? What is software 'quality'?

Quality software is Quality software is reasonably bug-free, reasonably bug-free, delivered on time and within budget,delivered on time and within budget, meets requirements and/or meets requirements and/or

expectations,expectations, and is maintainable.and is maintainable.


What is 'good code'?What is 'good code'?

'Good code' is code that 'Good code' is code that works, works, is reasonably bug free, is reasonably bug free, and is readable and maintainable.and is readable and maintainable.


What is 'good design'? What is 'good design'?

Good internal design is indicated by Good internal design is indicated by software code whose overall structure is software code whose overall structure is

clear,clear, understandable, understandable, easily modifiable,easily modifiable, and maintainable; and maintainable; is robust with sufficient error-handling is robust with sufficient error-handling

and status logging capability; and status logging capability; and works correctly when implemented and works correctly when implemented


Good functional designGood functional design

Good functional design is indicated Good functional design is indicated by an application whose by an application whose functionality can be traced back to functionality can be traced back to customer and end-user customer and end-user requirements. requirements.

Touchpoint Solutions(I) Pvt.Ltd04/14/23 What are 5 common What are 5 common problems in the software problems in the software development process? development process?

Poor requirementsPoor requirements -- if requirements are if requirements are unclear, incomplete, too general, and not testable, unclear, incomplete, too general, and not testable, there will be problems. there will be problems.

Unrealistic schedule -Unrealistic schedule - if too much work is if too much work is crammed in too little time, problems are inevitable. crammed in too little time, problems are inevitable.

Inadequate testing -Inadequate testing - no one will know no one will know whether or not the program is any good until the whether or not the program is any good until the customer complains or systems crash. customer complains or systems crash.

Featuritis -Featuritis - requests to pile on new features requests to pile on new features after development is underway; extremely common. after development is underway; extremely common.

Miscommunication -Miscommunication - if developers don't know if developers don't know what's needed or customer's have erroneous what's needed or customer's have erroneous expectations, problems can be expected. expectations, problems can be expected.


What are 5 common solutions to What are 5 common solutions to

software development problems?software development problems? solid requirementssolid requirements - - clear, complete, detailed, cohesive, clear, complete, detailed, cohesive,

attainable, testable requirements that are agreed to by all players. attainable, testable requirements that are agreed to by all players. realistic schedules -realistic schedules - allow adequate time for planning, allow adequate time for planning,

design, testing, bug fixing, re-testing, changes, and documentation; design, testing, bug fixing, re-testing, changes, and documentation; personnel should be able to complete the project without burning out.personnel should be able to complete the project without burning out.

adequate testing -adequate testing - start testing early on, re-test after start testing early on, re-test after fixes or changes, plan for adequate time for testing and bug-fixing. fixes or changes, plan for adequate time for testing and bug-fixing. 'Early' testing could include static code analysis/testing, test-first 'Early' testing could include static code analysis/testing, test-first development, unit testing by developers, built-in testing and development, unit testing by developers, built-in testing and diagnostic capabilities, automated post-build testing, etc. diagnostic capabilities, automated post-build testing, etc.

stick to initial requirements where stick to initial requirements where feasible -feasible - be prepared to defend against excessive changes and be prepared to defend against excessive changes and additions once development has begun, and be prepared to explain additions once development has begun, and be prepared to explain consequences. If changes are necessary, they should be adequately consequences. If changes are necessary, they should be adequately reflected in related schedule changesreflected in related schedule changes. .

communication communication - - require walkthroughs and inspections require walkthroughs and inspections when appropriate; make extensive use of group communication tools when appropriate; make extensive use of group communication tools - groupware, wiki's, bug-tracking tools and change management - groupware, wiki's, bug-tracking tools and change management tools, intranet capabilities, etc.tools, intranet capabilities, etc.


7 Principles of Quality 7 Principles of Quality Development ProcessDevelopment Process

The First Principle:The First Principle: The Reason It All The Reason It All ExistsExists

A software system exists for one reason: A software system exists for one reason: to to provide value to its usersprovide value to its users. .

Before specifying a system requirement, Before specifying a system requirement, before noting a piece of system functionality, before noting a piece of system functionality, before determining the hardware platforms or before determining the hardware platforms or development processes, ask yourself questions development processes, ask yourself questions such as: "such as: "Does this add real VALUE to the Does this add real VALUE to the system?"system?" If the answer is " If the answer is "nono", ", don't do itdon't do it. All . All other principles support this one. other principles support this one.


The Second Principle: KIS (Keep The Second Principle: KIS (Keep It Simple)It Simple)

There are many factors to consider in any There are many factors to consider in any design effort. design effort. All design should be as simple as All design should be as simple as possible, but no simplerpossible, but no simpler.. This facilitates This facilitates having a more easily understood, and having a more easily understood, and easily maintained system. easily maintained system.

Simple also does not mean "quick and Simple also does not mean "quick and dirty." In fact, it often takes a lot of dirty." In fact, it often takes a lot of thought and work over multiple iterations thought and work over multiple iterations to simplify. The payoff is software that is to simplify. The payoff is software that is more maintainable and less error-prone. more maintainable and less error-prone.


The Third Principle: Maintain The Third Principle: Maintain the Visionthe Vision

A clear vision is essential to the A clear vision is essential to the success of a software projectsuccess of a software project. . Without one, a project almost Without one, a project almost unfailingly ends up being "of two [or unfailingly ends up being "of two [or more] minds" about itself. Without more] minds" about itself. Without conceptual integrity, a system conceptual integrity, a system threatens to become a patchwork of threatens to become a patchwork of incompatible designs, held together incompatible designs, held together by the wrong kind of screws. by the wrong kind of screws.


The Fourth Principle: The Fourth Principle: What You Produce, Others Will What You Produce, Others Will ConsumeConsume

always specify, design, and always specify, design, and implement knowing someone else implement knowing someone else will have to understand what you are will have to understand what you are doingdoing. The audience for any product . The audience for any product of software development is of software development is potentially large. Specify with an eye potentially large. Specify with an eye to the users.to the users.


The Fifth Principle: Be Open to The Fifth Principle: Be Open to the Futurethe Future

A system with a long lifetime has more valueA system with a long lifetime has more value. . In today's computing environments, where In today's computing environments, where specifications change on a moment's notice specifications change on a moment's notice and hardware platforms are obsolete when and hardware platforms are obsolete when just a few months old, software lifetimes are just a few months old, software lifetimes are typically measured in months instead of typically measured in months instead of years. However, true "industrial-strength" years. However, true "industrial-strength" software systems must endure far longer. To software systems must endure far longer. To do this successfully, these systems must be do this successfully, these systems must be ready to adapt to these and other changes. ready to adapt to these and other changes.


The Sixth Principle: Plan The Sixth Principle: Plan Ahead for ReuseAhead for Reuse

Reuse saves time and effort. Achieving a high Reuse saves time and effort. Achieving a high level of reuse is arguably the hardest goal to level of reuse is arguably the hardest goal to accomplish in developing a software system. accomplish in developing a software system. The reuse of code and designs has been The reuse of code and designs has been proclaimed as a major benefit of using object-proclaimed as a major benefit of using object-oriented technologies. However, the return oriented technologies. However, the return on this investment is not automatic. on this investment is not automatic.

““Planning ahead for reuse reduces the cost Planning ahead for reuse reduces the cost and increases the value of both the reusable and increases the value of both the reusable components and the systems into which they components and the systems into which they are incorporatedare incorporated.”.”


The Seventh Principle: Think!The Seventh Principle: Think!

This last Principle is probably the This last Principle is probably the most overlooked. most overlooked. Placing clear, Placing clear, complete thought before action complete thought before action almost always produces better almost always produces better resultsresults. When you think about . When you think about something, you are more likely to do something, you are more likely to do it right. You also gain knowledge it right. You also gain knowledge about how to do it right again. about how to do it right again.


Coding standardsCoding standards

Keep It SimpleKeep It Simple.. Try keeping your methods as Try keeping your methods as

small as possiblesmall as possible Use understandable object, Use understandable object,

method and variable namesmethod and variable names.. Comment where neededComment where needed.. Write safe codeWrite safe code Naming conventionsNaming conventions


Some Principles for Some Principles for DevelopersDevelopers

Focus on the User and the task not on the Focus on the User and the task not on the TechnologyTechnology

Consider Function first Presentation nextConsider Function first Presentation next

Conforms to the user’s views of the taskConforms to the user’s views of the task

Don’t complicate the users task.Don’t complicate the users task.

Promote LearningPromote Learning

Deliver Information not just the dataDeliver Information not just the data

Design the responsivenessDesign the responsiveness


Use all the tools you canUse all the tools you can

Tools can make the life of a software developer so Tools can make the life of a software developer so much easiermuch easier

ProfilersProfilers.. Code inspectionsCode inspections.. Visual Studio Add-insVisual Studio Add-ins.. Code generatorsCode generators.. Version Control managementVersion Control management..


Tools exist for various Tools exist for various development tasks:development tasks:ProfilersProfilers.. Profilers are a great help when looking for Profilers are a great help when looking for

performance issues.performance issues. Memory profilers exist to check the memory usage of Memory profilers exist to check the memory usage of

your application. your application. Other profilers can measure the performance of your Other profilers can measure the performance of your

application and/or database. application and/or database. They can also help you in deciding if you really need They can also help you in deciding if you really need

to build a certain component yourself, or if the library to build a certain component yourself, or if the library version is fast enough.version is fast enough.

Ex :- Ex :- Devpartner StudioDevpartner Studio, by Compuware. Not , by Compuware. Not freeware, but a very professional tool. It contains freeware, but a very professional tool. It contains profilers for memory usage, overall application profilers for memory usage, overall application performance. performance.


Code inspectionsCode inspections.. A lot of things that could be wrong in your code can A lot of things that could be wrong in your code can

be found using tools.be found using tools. FxCopFxCop for example is a freeware tool that can check for example is a freeware tool that can check

your .Net assemblies for various mistakes. your .Net assemblies for various mistakes. Devpartner StudioDevpartner Studio, by Compuware, which I , by Compuware, which I

mentioned before also contains tools that will check mentioned before also contains tools that will check your .Net code for common mistakes. It also your .Net code for common mistakes. It also produces code complexity calculations to give you an produces code complexity calculations to give you an indication about the complexity of your code. indication about the complexity of your code.

For this you can also use the For this you can also use the community edition of DevMetricscommunity edition of DevMetrics. This freeware . This freeware version will produce code complexity calculations version will produce code complexity calculations which can help you find the complex parts of your which can help you find the complex parts of your application. application.


Visual Studio Add-insVisual Studio Add-ins.. These are These are simply great. An add-in extends the simply great. An add-in extends the standard functionality of Visual Studio standard functionality of Visual Studio to make life as a developer a lot easier. to make life as a developer a lot easier.

Code generatorsCode generators.. This can really This can really make developing software fun. As I make developing software fun. As I said earlier, a lot of repetitive work said earlier, a lot of repetitive work can be eliminated when you use code can be eliminated when you use code generators. generators.


Version Control management.Version Control management. Whatever someone might suggest, Whatever someone might suggest, you cannot live without a proper you cannot live without a proper Version Control Management tool. Version Control Management tool. Use Use Visual Source SafeVisual Source Safe, , Rational Clear CaseRational Clear Case, or the open , or the open source source Concurrent Versions SystemConcurrent Versions System. . And there others. Just make sure you And there others. Just make sure you use oneuse one

Thank You….!Thank You….!

ANUANU

Business

Quality Software Development