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
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.