chunk_id
stringlengths
3
9
chunk
stringlengths
1
100
9839_167
relative importance between the factors being measured].
9839_168
This view of software quality on a linear continuum has to be supplemented by the identification of
9839_169
discrete Critical Programming Errors. These vulnerabilities may not fail a test case, but they are
9839_170
the result of bad practices that under specific circumstances can lead to catastrophic outages,
9839_171
performance degradations, security breaches, corrupted data, and myriad other problems that make a
9839_172
given system de facto unsuitable for use regardless of its rating based on aggregated measurements.
9839_173
A well-known example of vulnerability is the Common Weakness Enumeration, a repository of
9839_174
vulnerabilities in the source code that make applications exposed to security breaches.
9839_175
The measurement of critical application characteristics involves measuring structural attributes of
9839_176
the application's architecture, coding, and in-line documentation, as displayed in the picture
9839_177
above. Thus, each characteristic is affected by attributes at numerous levels of abstraction in the
9839_178
application and all of which must be included calculating the characteristic's measure if it is to
9839_179
be a valuable predictor of quality outcomes that affect the business. The layered approach to
9839_180
calculating characteristic measures displayed in the figure above was first proposed by Boehm and
9839_181
his colleagues at TRW (Boehm, 1978) and is the approach taken in the ISO 9126 and 25000 series
9839_182
standards. These attributes can be measured from the parsed results of a static analysis of the
9839_183
application source code. Even dynamic characteristics of applications such as reliability and
9839_184
performance efficiency have their causal roots in the static structure of the application.
9839_185
Structural quality analysis and measurement is performed through the analysis of the source code,
9839_186
the architecture, software framework, database schema in relationship to principles and standards
9839_187
that together define the conceptual and logical architecture of a system. This is distinct from the
9839_188
basic, local, component-level code analysis typically performed by development tools which are
9839_189
mostly concerned with implementation considerations and are crucial during debugging and testing
9839_190
activities.
9839_191
Reliability
9839_192
The root causes of poor reliability are found in a combination of non-compliance with good
9839_193
architectural and coding practices. This non-compliance can be detected by measuring the static
9839_194
quality attributes of an application. Assessing the static attributes underlying an application's
9839_195
reliability provides an estimate of the level of business risk and the likelihood of potential
9839_196
application failures and defects the application will experience when placed in operation.
9839_197
Assessing reliability requires checks of at least the following software engineering best practices
9839_198
and technical attributes:
9839_199
Application Architecture Practices Coding Practices Complexity of algorithms
9839_200
Complexity of programming practices
9839_201
Compliance with Object-Oriented and Structured Programming best practices (when applicable)
9839_202
Component or pattern re-use ratio Dirty programming
9839_203
Error & Exception handling (for all layers - GUI, Logic & Data) Multi-layer design compliance
9839_204
Resource bounds management Software avoids patterns that will lead to unexpected behaviors
9839_205
Software manages data integrity and consistency Transaction complexity level
9839_206
Depending on the application architecture and the third-party components used (such as external
9839_207
libraries or frameworks), custom checks should be defined along the lines drawn by the above list
9839_208
of best practices to ensure a better assessment of the reliability of the delivered software.
9839_209
Efficiency
9839_210
As with Reliability, the causes of performance inefficiency are often found in violations of good
9839_211
architectural and coding practice which can be detected by measuring the static quality attributes
9839_212
of an application. These static attributes predict potential operational performance bottlenecks
9839_213
and future scalability problems, especially for applications requiring high execution speed for
9839_214
handling complex algorithms or huge volumes of data.
9839_215
Assessing performance efficiency requires checking at least the following software engineering best
9839_216
practices and technical attributes:
9839_217
Application Architecture Practices
9839_218
Appropriate interactions with expensive and/or remote resources
9839_219
Data access performance and data management Memory, network and disk space management
9839_220
Compliance with Coding Practices (Best coding practices)
9839_221
Security
9839_222
Software quality includes software security. Many security vulnerabilities result from poor coding
9839_223
and architectural practices such as SQL injection or cross-site scripting. These are well
9839_224
documented in lists maintained by CWE, and the SEI/Computer Emergency Center (CERT) at Carnegie
9839_225
Mellon University.
9839_226
Assessing security requires at least checking the following software engineering best practices and
9839_227
technical attributes:
9839_228
Implementation, Management of a security-aware and hardening development process, e.g. Security
9839_229
Development Lifecycle (Microsoft) or IBM's Secure Engineering Framework.
9839_230
Secure Application Architecture Practices Multi-layer design compliance
9839_231
Security best practices (Input Validation, SQL Injection, Cross-Site Scripting, Access control
9839_232
etc.)
9839_233
Secure and good Programming Practices Error & Exception handling
9839_234
Maintainability
9839_235
Maintainability includes concepts of modularity, understandability, changeability, testability,
9839_236
reusability, and transferability from one development team to another. These do not take the form
9839_237
of critical issues at the code level. Rather, poor maintainability is typically the result of
9839_238
thousands of minor violations with best practices in documentation, complexity avoidance strategy,
9839_239
and basic programming practices that make the difference between clean and easy-to-read code vs.
9839_240
unorganized and difficult-to-read code.
9839_241
Assessing maintainability requires checking the following software engineering best practices and
9839_242
technical attributes:
9839_243
Application Architecture Practices
9839_244
Architecture, Programs and Code documentation embedded in source code Code readability
9839_245
Code smells Complexity level of transactions Complexity of algorithms
9839_246
Complexity of programming practices
9839_247
Compliance with Object-Oriented and Structured Programming best practices (when applicable)
9839_248
Component or pattern re-use ratio Controlled level of dynamic coding Coupling ratio
9839_249
Dirty programming Documentation
9839_250
Hardware, OS, middleware, software components and database independence
9839_251
Multi-layer design compliance Portability Programming Practices (code level)
9839_252
Reduced duplicate code and functions Source code file organization cleanliness
9839_253
Maintainability is closely related to Ward Cunningham's concept of technical debt, which is an
9839_254
expression of the costs resulting of a lack of maintainability. Reasons for why maintainability is
9839_255
low can be classified as reckless vs. prudent and deliberate vs. inadvertent, and often have their
9839_256
origin in developers' inability, lack of time and goals, their carelessness and discrepancies in
9839_257
the creation cost of and benefits from documentation and, in particular, maintainable source code.
9839_258
Size
9839_259
Measuring software size requires that the whole source code be correctly gathered, including
9839_260
database structure scripts, data manipulation source code, component headers, configuration files
9839_261
etc. There are essentially two types of software sizes to be measured, the technical size
9839_262
(footprint) and the functional size:
9839_263
There are several software technical sizing methods that have been widely described. The most
9839_264
common technical sizing method is number of Lines of Code (#LOC) per technology, number of files,
9839_265
functions, classes, tables, etc., from which backfiring Function Points can be computed;
9839_266
The most common for measuring functional size is function point analysis. Function point analysis