placeholder

placeholder

Software quality glossary

It's a good idea to become familiar with these important software quality terms because when you hire us they all become integral parts of your business.

Accessibility Testing
What It Is:
Accessibility testing assures that people with disabilities can interact with an application using alternate means, such as audible screen readers and braille displays.
Why It's Important:
The sight and hearing impairments most affecting website accessibility are suffered by 6.8% of people 15 years and older and 21.3% of people over 65. It's obviously a good idea to make it easy for such a large and potentially profitable segment of the population to easily purchase your goods and services.
Application Optimization
What It Is:
Application optimization relieves the application from unnecessary burden and finely tunes its use of resources, resulting in a more performant application. For example, data caching can eliminate the majority of trips to the database.
Why It's Important:
Application optimization determines how performance problems discovered by Application Profiling will be resolved, and then resolves them.
Application Profiling
What It Is:
An application profiling tool examines a running application and reports on important details like how many times each method is called and how much it cost in terms of memory, CPU utilization, disk activity, etc. Experienced analysts use profiling reports to pinpoint and reengineer portions of the software responsible for performance problems.
Why It's Important:
Application profiling discovers where to resolve performance problems and what contributes to those problems.
Architectural Review
What It Is:
Architectural review looks at how your software design interacts with its environment and interfaces with external systems, then produces an action plan for implementing any changes necessary to accommodate the software.
Why It's Important:
If your operating environment is either too weak or misapportioned for the software that runs on it, then you're just throwing your infrastructure money down the drain.
Automated Builds
What It Is:
Automated builds automate every task associated with the process of building an application from source code, testing it thoroughly, building its installer, and either deploying it if successful or reporting problems to the development team if it's not.
Why It's Important:
Manually performing all the required software quality tasks on daily builds is a slow and tedious process where it's easy to forget a step and jeopardize the quality of a build. Automated builds ensure that only perfected software is released to production and that discrepancies are formally tracked through resolution.
Browser Testing
What It Is:
Browser testing ensures that a web application runs successfully in its supported browsers on its supported platforms, and that it degrades gracefully in unsupported browsers.
Why It's Important:
If you don't formally browser test your web application, you can easily end up with a website that looks like a Picasso abstract the moment it is launched in Firefox or Safari.
Bug Tracking
What It Is:
A bug tracking application enables users to report bugs and make new feature requests, and developers to update estimates of the time required to handle those issues.
Why It's Important:
Defects reduce software quality, which puts your business at risk. Bug tracking is the only effective way of indicating that all defects are removed from the software in a timely fashion.
Code Commenting
What It Is:
Code comments are non-executable plain English descriptions embedded directly in a software's source code.
Why It's Important:
When software is properly engineered it doesn't require embedded comments to explain what is going on, but it can be made more easily readable by embedding brief comments as if they were bookmarks or headings in an article.
Concurrency Testing
What It Is:
Concurrency testing discovers problems created by multiple operations executing at or near the same time. These problems may be due to poor multi-threaded design, the idiosyncracies of an optimizing compiler, heavy multi-user load, or a combination of these factors. Concurrency-related problems can take different forms, and all of them tend to be difficult to reproduce and resolve.
Why It's Important:
Concurrency-related problems often corrupt data due to their non-deterministic nature, which is a fancy way of saying that you can't tell what it's going to do from one run to the next. And that spells trouble.
Database Analysis
What It Is:
Database analysis creates a triage of the most resource-consuming work done by your database server. This work may be legitimate, but more often than not it is the result of either pathological design, unoptimized scripts, hardware assets that are either misconfigured or underpowered, or other causes.
Why It's Important:
Your database server is often the biggest workhorse in your company. If it isn't properly provisioned and configured, or if it's unnecessarily overburdened, it's going to slow to a crawl or fail when you need it most.
Database Tuning
What It Is:
Database tuning maximizes the performance of a properly analyzed database by reformulating the relational algebra of queries; creating, modifying, and deleting indexes; and reconfiguring connectivity between database servers and the resources that use them.
Why It's Important:
The database server is often the most expensive equipment you'll pay for in terms of both software licensing and hardware. Greater efficiency translates to less powerful hardware requirements, which translates to fewer CPUs, which results in a less expensive software license.
Dependency Analysis
What It Is:
Dependency analysis discovers all dependencies between each piece of software that makes up an application.
Why It's Important:
Unnecessary dependencies are the result of improper software design, and typically cause software to become difficult to maintain and enhance as new business needs arise. Dependencies also get in the way of unit testing — sometimes to the point of making an application virtually untestable.
Deployment Testing
What It Is:
Deployment testing ensures that software written in the vacuum of the software lab functions properly (and uses the correct database and mail servers!) when pushed out into the wild. It also makes sure it can complete the trip.
Why It's Important:
Dozens of things can prevent tested software from working properly once it's deployed: bad configurations, forgetting to switch from the development database server, leaving the application in Debug Mode, etc. Testing your deployment procedure (which is best automated using automated builds) ensures these things won't happen.
Exception Testing
What It Is:
Exception testing discovers all exceptions that can possibly be thrown by an application and checks whether code has been written to handle each of those exceptions.
Why It's Important:
Unhandled exceptions can corrupt data where proper transactional control is not employed. At the very least, they bring business to a halt for one unlucky user (or all of them).
Functional Testing
What It Is:
Functional testing is the process of validating that an application provides specified features and functionality from a user's perspective. A testing engine takes control of one or more computers and mimics users' actions against the application under test (AUT) according to a collection of test scripts.
Why It's Important:
Functional testing tells you whether the application will work when the user launches it. It also tells you whether or not it will prevent users from destroying things and getting stuck when they try to misuse the application (and trust me — they will). Without proper functional testing, you don't have an application your business can rely on.
Information Architecture
What It Is:
Information architecture (IA) is the planning and designing of shared information environments. It entails organizing and labeling information, and making it easy to find by both search and navigation mechanisms.
Why It's Important:
If while on your website they can't instantly find what you've got, they won't stick around.
Installer Creation
What It Is:
An installer is a single file of software that deploys a new or updated application by launching it and following a few simple instructions.
Why It's Important:
Even for applications restricted to a private corporate environment, deployment can be support intensive unless all the decisions and tricky installation maneuvers are performed programmatically for the user.
Integration Testing
What It Is:
Integration testing ensures that an application's interactions with external resources like databases and mail servers work properly.
Why It's Important:
You're testing more than whether your application can connect to the database; you're testing how well it handles those times when it doesn't, and the extent to how well you prevent those events from corrupting data and workflows.
Load Testing
What It Is:
Load testing is just an alternate term for performance testing.
Why It's Important:
Because if we didn't list it separately, half the people coming to this site would look at the headings and think we didn't do "load testing."
Manual Testing
What It Is:
Manual testing entails a user following a series of pre-defined steps that will exercise the software. It is especially useful in the initial phase of software development when the software and its user interface are not stable enough, and automated testing is not yet practical to implement.
Why It's Important:
Manual testing is easy to create and modify, and you can begin incorporating it into the development lifecycle as soon as the very first parts of a preliminary user interface begin to form. This introduces a form of functional testing as early as possible in the development cycle, which leads to higher quality sooner and less reworking later.
Penetration Testing
What It Is:
Penetration testing discovers an application's software, hardware, and network vulnerabilities, attempts to penetrate them using unauthorized means, assesses the potential damage, and recommends steps to harden the application and reduce its attack surface.
Why It's Important:
As you've seen from far too many evening news broadcasts over the recent years, hacking is on the rise and the results can be anything from destroying data to stealing credit card numbers and personal data. If you collect it or store it, you're legally liable for protecting it.
Performance Testing
What It Is:
Performance testing discovers the level at which a realistic workload begins to significantly degrade or destroy application performance. Performance testing covers a range of functionality in application, and tests the entire system as a whole.
Why It's Important:
If you website it slow, prospects will become frustrated and leave for your competition. If your internal Line of Business applications are slow, your whole business (i.e., "Profit Engine") slows down.
Process Analysis
What It Is:
Process analysis discovers the tasks and workflows within your business that should be supported by software, then determines the best way to implement them in both new and existing applications.
Why It's Important:
Process analysis is arguably the most important of any Quality Assurance endeavor because it is supposed to be the earliest task performed in any software development project. Start off in the right direction and you at least have a chance of getting where you want to go. Start off in the wrong direction and you're screwed.
Recovery Testing
What It Is:
Recovery testing determines how well an application recovers from catastrophic problems.
Why It's Important:
If your line of business application doesn't gracefully recover after crashes and hardware failures, then your business will suffer during the long and tedious manual recovery process.
Refactoring
What It Is:
Refactoring iteratively simplifies the structure of software without changing its behavior.
Why It's Important:
Simplifying software eliminates unnecessary yet potentially detrimental code and improves maintainability, performance, extensibility, source code readability, and use of established design patterns.
Regression Testing
What It Is:
Regression testing ensures that changes to an application have not introduced new flaws in existing features and functionality.
Why It's Important:
How many times have you experienced the dog-chasing-his-tail world of "fix one bug and create three more — two of which are the same ones that keep popping up each time a change is deployed?" Wanna stop? Regression test.
Requirements Vetting
What It Is:
Requirements vetting is the process of carefully testing software requirements from multiple perspectives using a variety of complementary techniques in order to discover and remediate deficiencies.
Why It's Important:
Those requirements are your complete itinerary for a trip into untraveled territory, so they'd better be correct. They're like a step-by-step instruction sheet for navigating the opening scene of Raiders of the Lost Ark. One misstep, and you don't reach your goal (or worse).
Scalability Testing
What It Is:
Scalability testing discovers the most effective way to scale your environment in order to handle increased load.
Why It's Important:
Without scalability testing, you're just guessing where you should spend your hardware budget to handle increased business (and you're probably wrong).
Search Engine Optimization
What It Is:
Search engine optimization (SEO) is the process of improving the volume or quality of traffic to a web site from search engines. SEO employs dozens of multi-disciplinary techniques to make content more attractive to the search engine indexers that crawl websites and rank what they find.
Why It's Important:
If on Google (and Bing and Yahoo, etc) they can't find what you've got, they won't find you, either.
Smoke Testing
What It Is:
A smoke test is a quick and simple test performed immediately after each new build to provide some assurance that the software will not catastrophically fail at first touch. When the build passes the smoke test, it is ready for unit and functional testing.
Why It's Important:
A smoke test stops the testing battery short if the build is fundamentally flawed. Without a smoke test, any rudimentary problem that passes unit testing (like a configuration problem) could easily generate thousands of unnecessary errors throughout the comprehensive battery of tests.
Stress Testing
What It Is:
Stress testing concentrates stress on specific targeted functions and tasks within an application.
Why It's Important:
Stress testing discovers the levels at which certain functions drastically slow or crash an application, which helps developers decide which need bolstering or even complete reengineering. It also uncovers concurrency problems — especially those introduced by optimizing compilers which rearrange the execution of multi-threaded code in order to achieve better performance.
System Documentation
What It Is:
Within the scope of software development, system documentation is a detailed illustrated description of a system or the enterprise containing that system as it pertains to an application.
Why It's Important:
Good system documentation helps developers navigate and better understand what they are about to modify, which in turn prevents them from writing code against established design or writing new code in places where he could have simply reused fully tested objects they weren't aware already existed.
Unit Testing
What It Is:
Unit testing ensures that the internals of your software not only work according to requirements, but also fail safely when bad things happen. Unit testing is like taking a part out of the engine of your car and thoroughly testing it for strength, proper dimensions, surface finish, and metal hardness.
Why It's Important:
You cannot exhaustively test software through its user interface (UI) alone, since UIs rarely allow targeted access and unrestricted inputs to their underlying mechanisms. The only way to test an application's internals is to execute the methods of each unit via separate pieces of software called "testing harnesses" and measure inputs against expected outputs.
Usability Testing
What It Is:
Usability testing records test participants spoken thoughts and on-screen activities as they attempt to accomplish key business tasks using the application under test (AUT), which may be a website or a desktop application.
Why It's Important:
Even the most experienced design and development team has only an imagination of how the user will interpret and use the AUT. The only authority on the AUT's shortcomings is the user, who in real life doesn't tolerate frustration at all. Usability testing details the AUT's problems for stakeholders so they can be discovered and resolved.
User Documentation
What It Is:
User documentation shows users how to operate an application and answers questions they may have. It is typically started from an outline based on requirements and guided by process flow diagrams, then later fleshed-out into a complete document with screen shots and other useful details.
Why It's Important:
Aside from user documentation's direct benefits to users, during the writing process you will often run into conflicts between what the requirements claim versus what users are actually able to do. Resolving these conflicts typically leads to a refinement of the requirements and a higher quality product.
Version Control
What It Is:
Version control is a shared repository for files that coordinates file modifications so that one user's changes do not interfere with or destroy another user's changes. Version control also maintains a complete history of all changes and enables files to be "rolled back" to earlier versions if a later modification proves to be unusable.
Why It's Important:
If you don't track every single change made to every file involved in creating an application, and also track who made which modifications, then you will never know the current state of your source code. Which means you have absolutely zero quality control. It's as simple as that.
Web Analytics
What It Is:
Web analytics measures and analyzes internet data collected from activity on your website so you can better understand how people use your website.
Why It's Important:
Web analytics provides half the answer to the question "What must we do to convert more prospects to paying customers?" (The other half is the stakeholders report that results from usability testing, which tells you why they use your website the way they do.)
Whiteboard Testing
What It Is:
Whiteboard testing obtains feedback from test users regarding the preliminary sketches of an application's proposed user interface.
Why It's Important:
Potentially massive problems can be avoided by whiteboard testing because it happens very early in the design and build process — typically before any software is written. Whiteboard testing not only discovers holes in workflow, it often discovers holes in the requirements themselves.

Now that you're familiar with the language of software quality, let's discuss the best way to make your business profit from it. Call 770-446-8866 and ask for Adam.