Coding by exception - Revision history

Goszei: /* top */General fixes, added orphan tag

2022-09-30T07:26:53Z

← Previous revision		Revision as of 07:26, 30 September 2022
Line 1:		Line 1:
			{{Multiple issues\|
			{{Orphan\|date=September 2022}}
	{{unreferenced\|date=July 2015}}		{{unreferenced\|date=July 2015}}
			}}

	'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions. When an issue arises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability. Executing code even after the exception is raised resembles the [[goto]] method in many software languages, which is also considered poor practice.		'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions. When an issue arises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability. Executing code even after the exception is raised resembles the [[goto]] method in many software languages, which is also considered poor practice.

AnomieBOT: Dating maintenance tags: {{Unreferenced}}

2015-07-29T07:22:18Z

Dating maintenance tags: {{Unreferenced}}

← Previous revision		Revision as of 07:22, 29 July 2015
Line 1:		Line 1:
	{{unreferenced}}		{{unreferenced\|date=July 2015}}
	'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions. When an issue arises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability. Executing code even after the exception is raised resembles the [[goto]] method in many software languages, which is also considered poor practice.		'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions. When an issue arises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability. Executing code even after the exception is raised resembles the [[goto]] method in many software languages, which is also considered poor practice.

Beland: trim repetitious and confusing content and unhelpful reference; now {{unreferenced}}

2015-07-29T07:01:23Z

trim repetitious and confusing content and unhelpful reference; now {{unreferenced}}

← Previous revision		Revision as of 07:01, 29 July 2015
Line 1:		Line 1:
			{{unreferenced}}
	'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions. When an issue arises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability.		'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions. When an issue arises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability. Executing code even after the exception is raised resembles the [[goto]] method in many software languages, which is also considered poor practice.

	==Background==
	As a general rule, well designed software projects contain very few [[corner case]]s.<ref name="slideshare">http://www.slideshare.net/ExigenServices/anti-patterns-part-2</ref> There are a variety of [[software development methodology\|software development methodologies]] that purport to help engineers develop software that avoid these corner cases. They typically address [[Dependency (computer science)\|dependency management]] issues. [[Design pattern (computer science)\|Design patterns]] are another tool for arriving at less of a 'one-off' solution. As a simple solution, programmers should avoid writing code to specifically handle an error and instead use a more generalized solution. [[exception handling\|Exceptions]] were invented to keep a program running when simple errors are made and should not be improperly used.

	==Incorrect exception usage==
	Often coding by exception can lead to further issues in the software with incorrect exception usage. In addition to using [[exception handling]] for a unique problem, incorrect exception usage takes this further by executing code even after the exception is raised. This poor programming method resembles the [[goto]] method in many software languages but only occurs after a problem in the software is detected.

	==See also==		==See also==
Line 11:		Line 6:
	*[[Creeping featurism]]		*[[Creeping featurism]]
	*[[Test-driven development]]		*[[Test-driven development]]

	==References==
	{{reflist}}

	[[Category:Anti-patterns]]		[[Category:Anti-patterns]]

Beland: /* Incorrect exception usage */ remove over-bolding

2015-07-29T06:57:43Z

Incorrect exception usage: remove over-bolding

← Previous revision		Revision as of 06:57, 29 July 2015
Line 5:		Line 5:

	==Incorrect exception usage==		==Incorrect exception usage==
	Often ~~'''~~coding by exception~~'''~~ can lead to further issues in the software with ~~'''~~incorrect exception usage~~'''~~. In addition to using [[exception handling]] for a unique problem, ~~'''~~incorrect exception usage~~'''~~ takes this further by executing code even after the exception is raised. This poor programming method resembles the [[goto]] method in many software languages but only occurs after a problem in the software is detected.		Often coding by exception can lead to further issues in the software with incorrect exception usage. In addition to using [[exception handling]] for a unique problem, incorrect exception usage takes this further by executing code even after the exception is raised. This poor programming method resembles the [[goto]] method in many software languages but only occurs after a problem in the software is detected.

	==See also==		==See also==

Beland: /* Accidental complexity */ remove off-topic section which also duplicates anti-pattern

2015-07-29T06:56:20Z

Accidental complexity: remove off-topic section which also duplicates anti-pattern

@@ Line 3: / Line 3: @@
 ==Background==
 As a general rule, well designed software projects contain very few [[corner case]]s.<ref name="slideshare">http://www.slideshare.net/ExigenServices/anti-patterns-part-2</ref>  There are a variety of [[software development methodology|software development methodologies]] that purport to help engineers develop software that avoid these corner cases.  They typically address [[Dependency (computer science)|dependency management]] issues.  [[Design pattern (computer science)|Design patterns]] are another tool for arriving at less of a 'one-off' solution. As a simple solution, programmers should avoid writing code to specifically handle an error and instead use a more generalized solution. [[exception handling|Exceptions]] were invented to keep a program running when simple errors are made and should not be improperly used.
 ==Incorrect exception usage==

Jackmcbarn: combine duplicate refs

2015-07-14T21:40:13Z

combine duplicate refs

← Previous revision		Revision as of 21:40, 14 July 2015
Line 2:		Line 2:

	==Background==		==Background==
	As a general rule, well designed software projects contain very few [[corner case]]s.<ref>http://www.slideshare.net/ExigenServices/anti-patterns-part-2</ref> There are a variety of [[software development methodology\|software development methodologies]] that purport to help engineers develop software that avoid these corner cases. They typically address [[Dependency (computer science)\|dependency management]] issues. [[Design pattern (computer science)\|Design patterns]] are another tool for arriving at less of a 'one-off' solution. As a simple solution, programmers should avoid writing code to specifically handle an error and instead use a more generalized solution. [[exception handling\|Exceptions]] were invented to keep a program running when simple errors are made and should not be improperly used.		As a general rule, well designed software projects contain very few [[corner case]]s.<ref name="slideshare">http://www.slideshare.net/ExigenServices/anti-patterns-part-2</ref> There are a variety of [[software development methodology\|software development methodologies]] that purport to help engineers develop software that avoid these corner cases. They typically address [[Dependency (computer science)\|dependency management]] issues. [[Design pattern (computer science)\|Design patterns]] are another tool for arriving at less of a 'one-off' solution. As a simple solution, programmers should avoid writing code to specifically handle an error and instead use a more generalized solution. [[exception handling\|Exceptions]] were invented to keep a program running when simple errors are made and should not be improperly used.

	==Accidental complexity==		==Accidental complexity==
	[[Accidental complexity]] is that complexity which arises in computer programs or the development process which is deemed not essential to the problem being solved. Coding by exception is an example of [[accidental complexity]]. Where this issue arises from poor planning or programming, some complexity is an [[essential\| essential complexity]] and unavoidable. Here is a list<ref~~>http://www.~~slideshare~~.net/ExigenServices/anti-patterns-part-2<~~/~~ref~~> of some programming accidental complexities:		[[Accidental complexity]] is that complexity which arises in computer programs or the development process which is deemed not essential to the problem being solved. Coding by exception is an example of [[accidental complexity]]. Where this issue arises from poor planning or programming, some complexity is an [[essential\| essential complexity]] and unavoidable. Here is a list<ref name="slideshare" /> of some programming accidental complexities:
	*Incorrect Exception Usage: see below		*Incorrect Exception Usage: see below
	*[[Accidental complexity]]: Introducing unnecessary complexity into a solution		*[[Accidental complexity]]: Introducing unnecessary complexity into a solution

Shenme: "arrises" -> "arises"

2015-05-25T02:31:48Z

"arrises" -> "arises"

← Previous revision		Revision as of 02:31, 25 May 2015
Line 1:		Line 1:
	'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions. When an issue ~~arrises~~ in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability.		'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions. When an issue arises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability.

	==Background==		==Background==

38.97.68.126: remove space for grammar

2015-03-05T20:26:22Z

remove space for grammar

← Previous revision		Revision as of 20:26, 5 March 2015
Line 1:		Line 1:
	'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions . When an issue arrises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability.		'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions. When an issue arrises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability.

	==Background==		==Background==

Andkore at 03:31, 18 November 2014

2014-11-18T03:31:50Z

← Previous revision		Revision as of 03:31, 18 November 2014
Line 1:		Line 1:
	'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions . When an issue arrises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability.		'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions . When an issue arrises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability.

	==~~How to Avoid~~==		==Background==
	As a general rule, well designed software projects contain very few [[corner case]]s.<ref>http://www.slideshare.net/ExigenServices/anti-patterns-part-2</ref> There are a variety of [[software development methodology\|software development methodologies]] that purport to help engineers develop software that avoid these corner cases. They typically address [[Dependency (computer science)\|dependency management]] issues. [[Design pattern (computer science)\|Design patterns]] are another tool for arriving at less of a 'one-off' solution. As a simple solution, programmers should avoid writing code to specifically handle an error and instead use a more generalized solution. [[exception handling\|Exceptions]] were invented to keep a program running when simple errors are made and should not be improperly used.		As a general rule, well designed software projects contain very few [[corner case]]s.<ref>http://www.slideshare.net/ExigenServices/anti-patterns-part-2</ref> There are a variety of [[software development methodology\|software development methodologies]] that purport to help engineers develop software that avoid these corner cases. They typically address [[Dependency (computer science)\|dependency management]] issues. [[Design pattern (computer science)\|Design patterns]] are another tool for arriving at less of a 'one-off' solution. As a simple solution, programmers should avoid writing code to specifically handle an error and instead use a more generalized solution. [[exception handling\|Exceptions]] were invented to keep a program running when simple errors are made and should not be improperly used.

	==Accidental ~~Complexity~~==		==Accidental complexity==
	[[Accidental complexity]] is that complexity which arises in computer programs or the development process which is deemed not essential to the problem being solved. Coding by exception is an example of [[accidental complexity]]. Where this issue arises from poor planning or programming, some complexity is an [[essential\| essential complexity]] and unavoidable. Here is a list<ref>http://www.slideshare.net/ExigenServices/anti-patterns-part-2</ref> of some programming accidental complexities:		[[Accidental complexity]] is that complexity which arises in computer programs or the development process which is deemed not essential to the problem being solved. Coding by exception is an example of [[accidental complexity]]. Where this issue arises from poor planning or programming, some complexity is an [[essential\| essential complexity]] and unavoidable. Here is a list<ref>http://www.slideshare.net/ExigenServices/anti-patterns-part-2</ref> of some programming accidental complexities:
	*Incorrect Exception Usage: see below		*Incorrect Exception Usage: see below
Line 24:		Line 24:
	*[[Shotgun surgery]]: Developer adds features to an application codebase which span a multiplicity of implementors or implementations in a single change.		*[[Shotgun surgery]]: Developer adds features to an application codebase which span a multiplicity of implementors or implementations in a single change.

	==Incorrect ~~Exception~~ ~~Usage~~==		==Incorrect exception usage==
	Often '''coding by exception''' can lead to further issues in the software with '''incorrect exception usage'''. In addition to using [[exception handling]] for a unique problem, '''incorrect exception usage''' takes this further by executing code even after the exception is raised. This poor programming method resembles the [[goto]] method in many software languages but only occurs after a problem in the software is detected.		Often '''coding by exception''' can lead to further issues in the software with '''incorrect exception usage'''. In addition to using [[exception handling]] for a unique problem, '''incorrect exception usage''' takes this further by executing code even after the exception is raised. This poor programming method resembles the [[goto]] method in many software languages but only occurs after a problem in the software is detected.

Robnormal: Removed source that was WP:CIRC

2014-10-11T00:56:53Z

Removed source that was WP:CIRC

← Previous revision		Revision as of 00:56, 11 October 2014
Line 1:		Line 1:
	'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions . When an issue arrises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability.~~<ref>http://www.encyclo.co.uk/define/Coding%20by%20exception</ref>~~		'''Coding by exception''' is an [[accidental complexity]] in a software system in which the program handles specific errors that arise with unique exceptions . When an issue arrises in a software system, an error is raised tracing the issue back to where it was caught and then where that problem came from, if applicable. Exceptions can be used to handle the error while the program is running and avoid crashing the system. Exceptions should be generalized and cover numerous errors that arise. Using these exceptions to handle specific errors that arise to continue the program is called '''coding by exception'''. This [[anti-pattern]] can quickly degrade software in performance and maintainability.

	==How to Avoid==		==How to Avoid==