manu/mldr-zoomed-100char-total-queries-documents

chunk_id stringlengths 3 9	chunk stringlengths 1 100
9839_267	measures the size of the software deliverable from a user's perspective. Function point sizing is
9839_268	done based on user requirements and provides an accurate representation of both size for the
9839_269	developer/estimator and value (functionality to be delivered) and reflects the business
9839_270	functionality being delivered to the customer. The method includes the identification and weighting
9839_271	of user recognizable inputs, outputs and data stores. The size value is then available for use in
9839_272	conjunction with numerous measures to quantify and to evaluate software delivery and performance
9839_273	(development cost per function point; delivered defects per function point; function points per
9839_274	staff month.).
9839_275	The function point analysis sizing standard is supported by the International Function Point Users
9839_276	Group (IFPUG). It can be applied early in the software development life-cycle and it is not
9839_277	dependent on lines of code like the somewhat inaccurate Backfiring method. The method is technology
9839_278	agnostic and can be used for comparative analysis across organizations and across industries.
9839_279	Since the inception of Function Point Analysis, several variations have evolved and the family of
9839_280	functional sizing techniques has broadened to include such sizing measures as COSMIC, NESMA, Use
9839_281	Case Points, FP Lite, Early and Quick FPs, and most recently Story Points. However, Function Points
9839_282	has a history of statistical accuracy, and has been used as a common unit of work measurement in
9839_283	numerous application development management (ADM) or outsourcing engagements, serving as the
9839_284	"currency" by which services are delivered and performance is measured.
9839_285	One common limitation to the Function Point methodology is that it is a manual process and
9839_286	therefore it can be labor-intensive and costly in large scale initiatives such as application
9839_287	development or outsourcing engagements. This negative aspect of applying the methodology may be
9839_288	what motivated industry IT leaders to form the Consortium for IT Software Quality focused on
9839_289	introducing a computable metrics standard for automating the measuring of software size while the
9839_290	IFPUG keep promoting a manual approach as most of its activity rely on FP counters certifications.
9839_291	CISQ defines Sizing as to estimate the size of software to support cost estimating, progress
9839_292	tracking or other related software project management activities. Two standards are used: Automated
9839_293	Function Points to measure the functional size of software and Automated Enhancement Points to
9839_294	measure the size of both functional and non-functional code in one measure.
9839_295	Identifying critical programming errors
9839_296	Critical Programming Errors are specific architectural and/or coding bad practices that result in
9839_297	the highest, immediate or long term, business disruption risk.
9839_298	These are quite often technology-related and depend heavily on the context, business objectives and
9839_299	risks. Some may consider respect for naming conventions while others – those preparing the ground
9839_300	for a knowledge transfer for example – will consider it as absolutely critical.
9839_301	Critical Programming Errors can also be classified per CISQ Characteristics. Basic example below:
9839_302	Reliability
9839_303	Avoid software patterns that will lead to unexpected behavior (Uninitialized variable, null
9839_304	pointers, etc.)
9839_305	Methods, procedures and functions doing Insert, Update, Delete, Create Table or Select must
9839_306	include error management
9839_307	Multi-thread functions should be made thread safe, for instance servlets or struts action classes
9839_308	must not have instance/non-final static fields
9839_309	Efficiency Ensure centralization of client requests (incoming and data) to reduce network traffic
9839_310	Avoid SQL queries that don't use an index against large tables in a loop Security
9839_311	Avoid fields in servlet classes that are not final static
9839_312	Avoid data access without including error management
9839_313	Check control return codes and implement error handling mechanisms
9839_314	Ensure input validation to avoid cross-site scripting flaws or SQL injections flaws
9839_315	Maintainability Deep inheritance trees and nesting should be avoided to improve comprehensibility
9839_316	Modules should be loosely coupled (fanout, intermediaries) to avoid propagation of modifications
9839_317	Enforce homogeneous naming conventions
9839_318	Operationalized quality models
9839_319	Newer proposals for quality models such as Squale and Quamoco propagate a direct integration of the
9839_320	definition of quality attributes and measurement. By breaking down quality attributes or even
9839_321	defining additional layers, the complex, abstract quality attributes (such as reliability or
9839_322	maintainability) become more manageable and measurable. Those quality models have been applied in
9839_323	industrial contexts but have not received widespread adoption.
9839_324	Trivia
9839_325	"A science is as mature as its measurement tools." "I know it when I see it."
9839_326	"You cannot control what you cannot measure." (Tom DeMarco)
9839_327	"You cannot inspect quality into a product." (W. Edwards Deming)
9839_328	"The bitterness of poor quality remains long after the sweetness of meeting the schedule has been
9839_329	forgotten." (Anonymous)
9839_330	"If you don't start with a spec, every piece of code you write is a patch." (Leslie Lamport)
9839_331	See also
9839_332	Anomaly in software Accessibility Availability Best coding practices Cohesion and Coupling
9839_333	Cyclomatic complexity Coding conventions Computer bug Dependability GQM ISO/IEC 9126
9839_334	Software Process Improvement and Capability Determination - ISO/IEC 15504 Programming style
9839_335	Quality: quality control, total quality management. Requirements management
9839_336	Scope (project management) Security Security engineering Software quality assurance
9839_337	Software architecture Software quality control Software metrics Software reusability
9839_338	Software standard Software testing Testability Static program analysis
9839_339	Further reading
9839_340	Android OS Quality Guidelines including checklists for UI, Security, etc. July 2021
9839_341	Association of Maritime Managers in Information Technology & Communications (AMMITEC). Maritime
9839_342	Software Quality Guidelines. September 2017
9839_343	Capers Jones and Olivier Bonsignour, "The Economics of Software Quality", Addison-Wesley
9839_344	Professional, 1st edition, December 31, 2011,
9839_345	CAT Lab - CNES Code Analysis Tools Laboratory (on GitHub)
9839_346	Girish Suryanarayana, Software Process versus Design Quality: Tug of War?
9839_347	Ho-Won Jung, Seung-Gweon Kim, and Chang-Sin Chung. Measuring software product quality: A survey of
9839_348	ISO/IEC 9126. IEEE Software, 21(5):10–13, September/October 2004.
9839_349	International Organization for Standardization. Software Engineering—Product Quality—Part 1:
9839_350	Quality Model. ISO, Geneva, Switzerland, 2001. ISO/IEC 9126-1:2001(E).
9839_351	Measuring Software Product Quality: the ISO 25000 Series and CMMI (SEI site)
9839_352	MSQF - A measurement based software quality framework Cornell University Library
9839_353	Omar Alshathry, Helge Janicke, "Optimizing Software Quality Assurance," compsacw, pp. 87–92, 2010
9839_354	IEEE 34th Annual Computer Software and Applications Conference Workshops, 2010.
9839_355	Robert L. Glass. Building Quality Software. Prentice Hall, Upper Saddle River, NJ, 1992.
9839_356	Roland Petrasch, "The Definition of 'Software Quality': A Practical Approach", ISSRE, 1999
9839_357	Software Quality Professional, American Society for Quality (ASQ)
9839_358	Software Quality Journal by Springer Nature
9839_359	Stephen H. Kan. Metrics and Models in Software Quality Engineering. Addison-Wesley, Boston, MA,
9839_360	second edition, 2002.
9839_361	Stefan Wagner. Software Product Quality Control. Springer, 2013.
9839_362	References Notes Bibliography External links
9839_363	When code is king: Mastering automotive software excellence (McKinsey, 2021)
9839_364	Embedded System Software Quality: Why is it so often terrible? What can we do about it? (by Philip
9839_365	Koopman)
9839_366	Code Quality Standards by CISQ™ CISQ Blog: https://blog.it-cisq.org

9839_267

measures the size of the software deliverable from a user's perspective. Function point sizing is

9839_268

done based on user requirements and provides an accurate representation of both size for the

9839_269

developer/estimator and value (functionality to be delivered) and reflects the business

9839_270

functionality being delivered to the customer. The method includes the identification and weighting

9839_271

of user recognizable inputs, outputs and data stores. The size value is then available for use in

9839_272

conjunction with numerous measures to quantify and to evaluate software delivery and performance

9839_273

(development cost per function point; delivered defects per function point; function points per

9839_274

staff month.).

9839_275

The function point analysis sizing standard is supported by the International Function Point Users

9839_276

Group (IFPUG). It can be applied early in the software development life-cycle and it is not

9839_277

dependent on lines of code like the somewhat inaccurate Backfiring method. The method is technology

9839_278

agnostic and can be used for comparative analysis across organizations and across industries.

9839_279

Since the inception of Function Point Analysis, several variations have evolved and the family of

9839_280

functional sizing techniques has broadened to include such sizing measures as COSMIC, NESMA, Use

9839_281

Case Points, FP Lite, Early and Quick FPs, and most recently Story Points. However, Function Points

9839_282

has a history of statistical accuracy, and has been used as a common unit of work measurement in

9839_283

numerous application development management (ADM) or outsourcing engagements, serving as the

9839_284

"currency" by which services are delivered and performance is measured.

9839_285

One common limitation to the Function Point methodology is that it is a manual process and

9839_286

therefore it can be labor-intensive and costly in large scale initiatives such as application

9839_287

development or outsourcing engagements. This negative aspect of applying the methodology may be

9839_288

what motivated industry IT leaders to form the Consortium for IT Software Quality focused on

9839_289

introducing a computable metrics standard for automating the measuring of software size while the

9839_290

IFPUG keep promoting a manual approach as most of its activity rely on FP counters certifications.

9839_291

CISQ defines Sizing as to estimate the size of software to support cost estimating, progress

9839_292

tracking or other related software project management activities. Two standards are used: Automated

9839_293

Function Points to measure the functional size of software and Automated Enhancement Points to

9839_294

measure the size of both functional and non-functional code in one measure.

9839_295

Identifying critical programming errors

9839_296

Critical Programming Errors are specific architectural and/or coding bad practices that result in

9839_297

the highest, immediate or long term, business disruption risk.

9839_298

These are quite often technology-related and depend heavily on the context, business objectives and

9839_299

risks. Some may consider respect for naming conventions while others – those preparing the ground

9839_300

for a knowledge transfer for example – will consider it as absolutely critical.

9839_301

Critical Programming Errors can also be classified per CISQ Characteristics. Basic example below:

9839_302

Reliability

9839_303

Avoid software patterns that will lead to unexpected behavior (Uninitialized variable, null

9839_304

pointers, etc.)

9839_305

Methods, procedures and functions doing Insert, Update, Delete, Create Table or Select must

9839_306

include error management

9839_307

Multi-thread functions should be made thread safe, for instance servlets or struts action classes

9839_308

must not have instance/non-final static fields

9839_309

Efficiency Ensure centralization of client requests (incoming and data) to reduce network traffic

9839_310

Avoid SQL queries that don't use an index against large tables in a loop Security

9839_311

Avoid fields in servlet classes that are not final static

9839_312

Avoid data access without including error management

9839_313

Check control return codes and implement error handling mechanisms

9839_314

Ensure input validation to avoid cross-site scripting flaws or SQL injections flaws

9839_315

Maintainability Deep inheritance trees and nesting should be avoided to improve comprehensibility

9839_316

Modules should be loosely coupled (fanout, intermediaries) to avoid propagation of modifications

9839_317

Enforce homogeneous naming conventions

9839_318

Operationalized quality models

9839_319

Newer proposals for quality models such as Squale and Quamoco propagate a direct integration of the

9839_320

definition of quality attributes and measurement. By breaking down quality attributes or even

9839_321

defining additional layers, the complex, abstract quality attributes (such as reliability or

9839_322

maintainability) become more manageable and measurable. Those quality models have been applied in

9839_323

industrial contexts but have not received widespread adoption.

9839_324

Trivia

9839_325

"A science is as mature as its measurement tools." "I know it when I see it."

9839_326

"You cannot control what you cannot measure." (Tom DeMarco)

9839_327

"You cannot inspect quality into a product." (W. Edwards Deming)

9839_328

"The bitterness of poor quality remains long after the sweetness of meeting the schedule has been

9839_329

forgotten." (Anonymous)

9839_330

"If you don't start with a spec, every piece of code you write is a patch." (Leslie Lamport)

9839_331