Software Quality

Question 1

What is meant by “software quality”?

Answer 1

In this course we will define software quality using two categories:

• External: executable program running on hardware in some environment
• Internal: code as human-readable text

Question 2

What are the five aspects of “external” software quality?

Answer 2

1. Functionality: Does the software adhere to its specifications and deliver the features that the end-user wants and needs?
2. Reliability: Does the software maintain its level of performance? What is the likelihood that it produces the correct output or behavior?
3. Usability: How easy is it for users to perform tasks? How much time do they need to learn how to use the software? How likely are they to make mistakes?
4. Efficiency: Does the software use the minimal amount of resources needed to perform its tasks?
5. Security: Is data in the software available to those who have permission to access it, and unavailable to those who don’t?

Question 3

What are the five aspects of “internal” software quality?

Answer 3

1. Analyzability: How easy is it to read and understand the code?
2. Changeability: How easy is it to change the code?
3. Stability: Modifying one part of the code should have limited effect on other parts
4. Testability: How easy is it to create test cases and find bugs?
5. Reusability: Can the software be used in a variety of applications?

Question 4

What is a data structure?

Answer 4

An organization of a data collection that enables efficient access and modification. More precisely, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data.

Question 5

Why are data structures important?

Answer 5

Choosing the correct data structure is one of, if the not the most, critical decisions that impacts internal and external software quality.

Question 6

Analyzability

Answer 6

The readability and understandability of code. This is necessary so that a programmer can easily:

• Identify and fix defects
• Add / improve functionality
• Understand how an algorithm / solution is implemented

Question 7

Changeability

Answer 7

The ease with which code can be changed. Highly changeable code allows a programmer to easily:

• Fix defects
• Add / improve functionality
• Incorporate new code
• Improve other aspects of software quality

Question 8

Reusability

Answer 8

The ease with which code can be reused in other applications. Reusable code allows a programmer to:

• Reduce time spent developing new code
• Reduce the likelihood that new code will contain defects

Question 9

Stability

Answer 9

The idea that modifying one part of the code should have a limited effect on others. High stability allows a programmer to:

• Make changes in one part of the code without being required to make changes in other parts. This has the added benefit of reducing the time / effort required to change code.

Question 10

Testability

Answer 10

The controllability and observability of code. High testability allows a programmer to easily:

• Create test cases
• Identify and fix defects
• Increase confidence that software is working correctly

Question 11

Observability

Answer 11

An aspect of testability that refers to the ability to examine the state of the code you’re testing.

Question 12

Dictionary words

Answer 12

Words that occur in everyday language. These are good to use as variable names as they tend to be easier to read and recognize in comparison to words that are made up.

Question 13

What does it mean for code to “smell”?

Answer 13

It means that it is bad design or has bad internal quality.

Question 14

What is the most common code smell?

Answer 14

Using duplicate code, or very similar code, in multiple places by copy and pasting it in multiple locations.

Question 15

What are the 2 main ways to eliminate duplicate code?

Answer 15

1. Extract Method - create a new method that can be used in multiple places. (This assumes duplicate code is in the same class.)
2. Extract Superclass - create a new common superclass that contains a method that can be used in multiple subclasses.

Question 16

What is refactoring?

Answer 16

An activity by which we modify code but don’t change its functionality.

Why should we refactor?

• Improve the internal quality of code
• Simplify future code changes
• Reduce the amount of code to maintain
• It’s a way of understanding the code

When should we refactor?

• Constantly!
• When you see code (or are writing code) that doesn’t adhere to the intended design

What should we refactor?

• Make small changes before big ones
• Be careful about:
  
  • Introducing bugs
  • Breaking “published” interfaces
  • Unnecessarily decreasing external quality

When should we refactor?

• Code that smells
• Code that is hard to read or hard to understand
• Code that does not adhere to conventions
• Code that is unnecessary or in the wrong place

Question 17

Micro-optimization technique

Answer 17

TBD

Question 18

Lazy initialization

Answer 18

A programming technique in which we only create objects when we know we’re going to need them.

Question 19

Lazy evaluation

Answer 19

A programming technique in which we evaluate expressions only when we know we’ll need the results.

Question 20

Memorization

Answer 20

A programming technique in which we keep a Map of inputs (arguments) to outputs (results) and return the result from the Map if the same input is seen more than once. This will lead to more memory utilization but may greatly reduce execution time.

Question 21

Method in-lining

Answer 21

A micro-optimization technique in which we replace method call with method body.

Question 22

Loop unrolling

Answer 22

A micro-optimization technique in which we replace for-loop with multiple instances of body.

Question 23

Constant folding

Answer 23

A micro-optimization technique in which we replace a literal numerical expression with result.

Question 24

Strength reduction

Answer 24

A micro-optimization technique in which we replace complex operations with simpler ones.

Question 25

What tradeoffs exist within software quality?

Answer 25

Improving one aspect of external quality may harm other aspects of external quality and / or internal quality. For example, if we make our code faster, we may also make it: * harder to understand * harder to change * less likely to provide the correct functionality * less secure

Question 26

How can you measure execution time?

Answer 26

Execution time can be measured by various mechanisms: * Use Java System methods to measure execution time of small pieces of code. * Use UNIX “time” command to measure execution time of entire program. * Use profiling tools for more detailed information.

Question 27

What is meant by "wall clock" time?

Answer 27

The ​elapsed “real” time between two events, as would be measured by a wall clock, stopwatch, etc. This can lead to inaccuracies when measuring software execution time because of other factors, such as operations being performed by the Java Virtual Machine, operating system, hardware, etc.

Question 28

Rules of thumb for software efficiency

Answer 28

* Always use the right data structure * Make the common case fast * Don’t do work unnecessarily * Be careful about accidentally harming other aspects of quality * Don't allocate memory unnecessarily * Do more than one thing at a time (concurrency)

Question 29

What's the best way to avoid doing unnecessary work?

Answer 29

* Don’t check conditions unnecessarily * Don’t call methods unnecessarily * Don’t redo work you’ve already done * Use the Java API when possible * Use lazy evaluation, lazy initialization, and memorization * Take advantage of short-circuit boolean operators * Use micro-optimizations sparingly, especially if they may harm understandability