Exception handling is a programming language construct or computer hardware mechanism designed to handle the occurrence of exceptions - special conditions that change the normal flow of execution.
Signal programming is often used in the same sense as Event-driven programming.The word signal is used instead of the word event in documentation of such Programming library as Qt, GTK+ and libsigc++.... and event handler
Event handler
In computer programming, an event handler is an asynchronous callback subroutine that handles inputs received in a program. Each event is a piece of application-level information from the underlying framework, typically the GUI toolkit.... s that are part of the normal program flow, exceptions are typically used to signal that something went wrong (e.g. a division by zero occurred or a required file was not found).
Discussion
Ask a question about 'Exception handling'
Start a new discussion about 'Exception handling'
Answer questions from other users
Full Discussion Forum
Encyclopedia
Exception handling is a programming language construct or computer hardware mechanism designed to handle the occurrence of exceptions - special conditions that change the normal flow of execution.
Signal programming is often used in the same sense as Event-driven programming.The word signal is used instead of the word event in documentation of such Programming library as Qt, GTK+ and libsigc++.... and event handler
Event handler
In computer programming, an event handler is an asynchronous callback subroutine that handles inputs received in a program. Each event is a piece of application-level information from the underlying framework, typically the GUI toolkit.... s that are part of the normal program flow, exceptions are typically used to signal that something went wrong (e.g. a division by zero occurred or a required file was not found). Exceptions are raised or thrown (initiated) by either the hardware or the program itself by using a special command.
In general, an exception is handled (resolved) by saving the current state of execution in a predefined place and switching the execution to a specific subroutine
Subroutine
In computer science, a subroutine or subprogram is a portion of computer code within a larger computer program, which performs a specific task and is relatively independent of the remaining code.... - an exception handler. Depending on the situation, the handler may later resume the execution at the original location using the saved information. For example, a page fault
Page fault
In computer storage technology, a page is a fixed-length block of memory that is used as a unit of transfer between physical memory and external storage like a hard disk, and a page fault is an interrupt to the software raised by the hardware, when a program accesses a page that is mapped in address space, but not loaded in physical memory.... will usually allow the program to be resumed, while a division by zero
Division by zero
In mathematics, a division is called a division by zero if the divisor is 0 . Such a division can be formally expressed as a/0 where a is the dividend.... might not be resolvable transparently.
From the processing point of view, hardware interrupt
Interrupt
In computing, an interrupt is an asynchronous communication signal from hardware indicating the need for attention or a synchronous event in software indicating the need for a change in execution.... s are similar to resumable exceptions, though they are typically unrelated to the user's program flow.
Routine may refer to:* Routine, as a course of normative, standardized actions or procedures that are followed regularly, often repetition;... , raising an exception is a useful way to signal that a routine could not execute normally. For example, when an input argument is invalid (a zero denominator in division) or when a resource it relies on is unavailable (like a missing file, or a hard disk error). In systems without exceptions, routines would need to return some special error code
Error code
In Programming language, error codes are enumerated messages that correspond to faults in a specific software application. They are typically used to identify faulty hardware, software, or incorrect user input in programming languages that lack exception handling, although they are sometimes also be used in conjunction with exception handling... . However, this is sometimes complicated by the semipredicate problem
Semipredicate problem
In computer programming, a semipredicate problem occurs when a subroutine intended to return a useful value can fail, but the signalling of failure uses an otherwise valid return value.... , in which users of the routine need to write extra code to distinguish normal return values from erroneous ones.
Java is a programming language originally developed by James Gosling at Sun Microsystems and released in 1995 as a core component of Sun Microsystems' Java .... or .NET
.NET Framework
The Microsoft .NET Framework is a software framework that is available with several Microsoft Windows operating systems. It includes a large Library of coded solutions to prevent common programming problems and a virtual machine that manages the execution of programs written specifically for the Software framework.... , there exist tools that attach to the runtime engine and every time that an exception of interest occurs, they record debugging information that existed in memory at the time the exception was thrown (call stack
Call stack
In computer science, a call stack is a dynamic Stack data structure that stores information about the active subroutines of a computer program.... and heap
Heap
Heap may refer to:In computer science:* heap , a tree-like data structure* The heap is the area of memory used for dynamic memory allocation... values). These tools are called Automated Exception Handling
Automated Exception Handling
Automated Exception Handling is a computing term referring to the computerized handling of errors. Runtime engines such as those for the Java language or Microsoft .Net lend themselves to an automated mode of exception or error handling.... or Error Interception tools and provide 'root-cause' information for exceptions.
Contemporary applications face many design challenges when considering exception handling strategies. Particularly in modern enterprise level applications, exceptions must often cross process boundaries and machine boundaries. Part of designing a solid exception handling strategy is recognizing when a process has failed to the point where it cannot be economically handled by the software portion of the process. At such times, it is very important to present exception information to the appropriate stakeholders.
Exception safety
A piece of code is said to be exception-safe, if run-time failures within the code will not produce ill effects, such as memory leak
Memory leak
In computer science, a memory leak is a particular type of unintentional memory consumption by a computer program where the program fails to release dynamic memory when no longer needed.... s, garbled stored data, or invalid output. Exception-safe code must satisfy invariant
Invariant (computer science)
In Computer science, a predicate that, if true, will remain true throughout a specific sequence of Operation , is called invariant to that sequence.... s placed on the code even if exceptions occur. There are several levels of exception safety:
Failure transparency, also known as the no throw guarantee: Operations are guaranteed to succeed and satisfy all requirements even in presence of exceptional situations. If an exception occurs, it will not throw the exception further up. (Best level of exception safety.)
Commit or rollback semantics, also known as strong exception safety or no-change guarantee: Operations can fail, but failed operations are guaranteed to have no side effects so all data retain original values.
Basic exception safety: Partial execution of failed operations can cause side effects, but invariants on the state are preserved. Any stored data will contain valid values even if data has different values now from before the exception.
Minimal exception safety also known as no-leak guarantee: Partial execution of failed operations may store invalid data but will not cause a crash, and no resources get leaked.
No exception safety: No guarantees are made. (Worst level of exception safety)
For instance, consider a smart vector type, such as C++'s stdvector or Java's ArrayList. When an item x is added to a vector v, the vector must actually add x to the internal list of objects and also update a count field that says how many objects are in v. It may also need to allocate new memory if the existing capacity isn't large enough. This memory allocation may fail and throw an exception. Because of this, a vector that provides failure transparency would be very difficult or impossible to write. However, the vector may be able to offer the strong exception guarantee fairly easily; in this case, either the insertion of x into v will succeed, or v will remain unchanged. If the vector provides only the basic exception safety guarantee, if the insertion fails, v may or may not contain x, but at least it will be in a consistent state. However, if the vector makes only the minimal guarantee, it's possible that the vector may be invalid. For instance, perhaps the size field of v was incremented but x wasn't actually inserted, making the state inconsistent. Of course, with no guarantee, the program may crash; perhaps the vector needed to expand but couldn't allocate the memory and blindly ploughs ahead as if the allocation succeeded, touching memory at an invalid address.
Usually at least basic exception safety is required. Failure transparency is difficult to implement, and is usually not possible in libraries where complete knowledge of the application is not available.
Verification of Exception Handling
The point of exception handling routines is to ensure that the code can handle error conditions. In order to establish that exception handling routines are sufficiently robust, it is necessary to present the code with a wide spectrum of invalid or unexpected inputs, such as can be created via software fault injection
Fault injection
In software testing, fault injection is a technique for improving the Code coverage of a test by introducing faults in order to test code paths, in particular error handling code paths, that might otherwise rarely be followed.... and mutation testing (which is also sometimes referred to as fuzz testing
Fuzz testing
Fuzz testing, fuzzing, Robustness Testing or Negative Testing is a software testing technique that provides random data to the inputs of a computer program.... ). One of the most difficult types of software for which to write exception handling routines is protocol software, since a robust protocol implementation must be prepared to receive input that does not comply with the relevant specification(s).
A software development process is a structure imposed on the development of a software product. Synonyms include Software_Lifecycle_Processes and software process.... , any exception handling verification should be highly automated, and the test cases must be generated in a scientific, repeatable fashion. Several commercially available systems exist that perform such testing, including the Service Assurance Platform from Mu Dynamic which can verify exception handling for many common protocol implementation.
The Microsoft .NET Framework is a software framework that is available with several Microsoft Windows operating systems. It includes a large Library of coded solutions to prevent common programming problems and a virtual machine that manages the execution of programs written specifically for the Software framework.... languages, Actionscript
ActionScript
ActionScript is a scripting language based on ECMAScript. ActionScript is used primarily for the development of websites and software using the Adobe Flash Player platform , but is also used in some database applications , and in basic robotics, as with the Make Controller Kit.... , Ada, C++
C++
C++ is a general-purpose programming language. It is regarded as a middle-level language, as it comprises a combination of both high-level programming language and low-level programming language language features.... , D, ECMAScript
ECMAScript
ECMAScript is a scripting language, standardized by Ecma International in the ECMA-262 Specification . The language is widely used on the World Wide Web, and is often confused with JavaScript or JScript, the two major Programming language dialect from which ECMAScript was standardized.... , Eiffel
Eiffel (programming language)
Eiffel is an International Organization for Standardization-standardized, object-oriented programming language designed to enable programmers to efficiently develop extensible, reusable, reliable software.... , Java
Java (programming language)
Java is a programming language originally developed by James Gosling at Sun Microsystems and released in 1995 as a core component of Sun Microsystems' Java .... , ML
ML programming language
ML is a general-purpose functional programming language developed by Robin Milner and others in the late 1970s at the University of Edinburgh, whose syntax is inspired by ISWIM.... , Object Pascal
Object Pascal
Object Pascal refers to a branch of Object-oriented programming derivatives of Pascal , mostly known as the primary programming language of CodeGear Delphi.... (e.g. Delphi, Free Pascal
Free Pascal
Free Pascal is a free software, Portability , open source, Pascal programming language and Object Pascal compiler. The 32/64-bit multi-CPU architecture and cross-platform compiler implements the Borland Pascal programming language dialects as well as some MacPascal constructs, and is available for... , and the like), Objective-C
Objective-C
Objective-C is a Reflection , Object-oriented programming programming language which adds Smalltalk-style message passing to C .Today it is used primarily on Mac OS X, iPhone OS, and GNUstep, three environments based on the OpenStep standard, and is the primary language used for the NEXTSTEP, OpenStep#OPENSTEP, and Cocoa application framew... , Ocaml, PHP
PHP
PHP is a scripting language originally designed for producing dynamic web pages. It has evolved to include a command line interface capability and can be used in Standalone software Graphical user interface.... (as of version 5), PL/1, Prolog
Prolog
Prolog is a logic programming language. It is a general purpose language often associated with artificial intelligence and computational linguistics.... , Python
Python (programming language)
Python is a general-purpose high-level programming language. Its design philosophy emphasizes code readability. Python's core syntax and semantics are Minimalism , while the standard library is large and comprehensive.... , REALbasic
REALbasic
REALbasic is an object-oriented dialect of the BASIC programming language developed and commercially marketed by REAL Software, Inc in Austin, Texas for Mac OS X, Microsoft Windows, and Linux.... , Ruby
Ruby (programming language)
Ruby is a dynamic programming language, reflection , general purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features.... , Visual Prolog
Visual Prolog
Visual Prolog, also formerly known as PDC Prolog and Turbo Prolog, is a strongly typed object-oriented extension of Prolog. As Turbo Prolog it was marketed by Borland, but it is now developed and marketed by the Danish firm Prolog Development Center that originally developed it.... , have built-in support for exceptions and exception handling. In those languages, the advent of an exception (more precisely, an exception handled by the language) unwinds the stack
Call stack
In computer science, a call stack is a dynamic Stack data structure that stores information about the active subroutines of a computer program.... of function calls until an exception handler is found. That is, if function f contains a handler H for exception E, calls function g, which in turn calls function h, and an exception E occurs in h, then functions h and g will be terminated, and H in f will handle E.
Excluding minor syntactic differences, there are only a couple of exception handling styles in use. In the most popular style, an exception is initiated by a special statement (throw, or raise) with an exception object (e.g. with Java or Object Pascal) or a value of a special extendable enumerated type (e.g. with Ada). The scope for exception handlers starts with a marker clause (try, or the language's block starter such as begin) and ends in the start of the first handler clause (catch, except, rescue). Several handler clauses can follow, and each can specify which exception types it handles and what name it uses for the exception object.
A few languages also permit a clause (else) that is used in case no exception occurred before the end of the handler's scope was reached. More common is a related clause (finally, or ensure) that is executed whether an exception occurred or not, typically to release resources acquired within the body of the exception-handling block. Notably, C++ does not need and does not provide this construct, and the Resource-Acquisition-Is-Initialization
Resource Acquisition Is Initialization
Resource Acquisition Is Initialization, often referred to by the acronym RAII, is a popular design pattern in several Object-oriented_programming_language like C++, D and Ada .... technique is used to free such resources instead.
In its whole, exception handling code might look like this (in Java
Java (programming language)
Java is a programming language originally developed by James Gosling at Sun Microsystems and released in 1995 as a core component of Sun Microsystems' Java .... -like pseudocode
Pseudocode
Pseudocode is a compact and informal high-level description of a computer programming algorithm that uses the structural conventions of some programming language, but is intended for human reading rather than machine reading.... ; note that an exception type called EmptyLineException would need to be declared somewhere):
try catch (EmptyLineException e) catch (Exception e) finally
As a minor variation, some languages use a single handler clause, which deals with the class of the exception internally.
Languages such as Perl and C don't use the term exception handling, but include facilities that allow implementing similar functionality.
Embedded C++ is a programming language dialect of the C++ programming language for embedded systems. It was defined by an industry group led by major Japanese CPU manufacturers, including NEC Corporation, Hitachi, Ltd., Fujitsu, and Toshiba, to address the shortcomings of C++ for embedded applications.... excludes exception handling support as it can
substantially increase the size of the object code.
Exception handling based on Design by Contract
A different view of exceptions is based on the principles of Design by Contract
Design by contract
Design by Contract or Programming by Contract is an approach to designing computer software. It prescribes that software designers should define Formal methods, precise and verifiable interface specifications for Component-based software engineering#Software component based upon the theory of abstract data types and the conceptual metaph... and is supported in particular by the Eiffel language
Eiffel (programming language)
Eiffel is an International Organization for Standardization-standardized, object-oriented programming language designed to enable programmers to efficiently develop extensible, reusable, reliable software.... . The idea is to provide a more rigorous basis for exception handling by defining precisely what is "normal" and "abnormal" behavior. Specifically, the approach is based on two concepts:
Failure: the inability of an operation to fulfill its contract. For example an addition may produce an arithmetic overflow (it does not fulfill its contract of computing a good approximation to the mathematical sum); or a routine may fail to meet its postcondition.
Exception: an abnormal event occurring during the execution of a routine (that routine is the "recipient" of the exception) during its execution. Such an abnormal event results from the failure of an operation called by the routine.
Object-Oriented Software Construction is the title of a book by Bertrand Meyer, widely considered a foundational text of object-oriented programming.... then holds that there are only two meaningful ways a routine can react when an exception occurs:
Failure, or "organized panic": the routine fails, triggering an exception in its caller (so that the abnormal event is not ignored!), after fixing the object's state by re-establishing the invariant (the "organized" part).
Retry: try the algorithm again, usually after changing some values so that the next attempt will have a better chance to succeed.
Here is an example expressed in Eiffel syntax. It assumes that a routine send_fast is normally the better way to send a message, but it may fail, triggering an exception; if so, the algorithm next uses send_slow, which will fail less often. If send_slow fails, the routine send as a whole should fail, causing the caller to get an exception.
send (m: MESSAGE) is
-- Send m through fast link if possible, otherwise through slow link.
local
tried_fast, tried_slow: BOOLEAN
do
if tried_fast then
tried_slow := True
send_slow (m)
else
tried_fast := True
send_fast (m)
end
rescue
if not tried_slow then
retry
end
end
The boolean local variables are initialized to False at the start. If send_fast fails, the body (do clause) will be executed again, causing execution of send_slow. If this execution of send_slow fails, the rescue clause will execute to the end with no retry (no else clause in the final if), causing the routine execution as a whole to fail.
This approach has the merit of defining clearly what a "normal" and "abnormal" cases are: an abnormal case, causing an exception, is one in which the routine is unable to fulfill its contract.
It defines a clear distribution of roles: the do clause (normal body) is in charge of achieving, or attempting to achieve, the routine's contract; the rescue clause is in charge of reestablishing the context and restarting the process if this has a chance of succeeding, but not of performing any actual computation.
Checked exceptions
The designers of Java devised checked exceptions, which are a special set of exceptions. The checked exceptions that a method may raise are part of the method's signature. For instance, if a method might throw an IOException, it must declare this fact explicitly in its method signature. Failure to do so raises a compile-time error.
This is related to exception checkers that exist at least for OCaml. The external tool for OCaml is both transparent (i.e. it does not require any syntactic annotations) and facultative (i.e. it is possible to compile and run a program without having checked the exceptions, although this is not suggested for production code).
CLU is a programming language created at Massachusetts Institute of Technology by Barbara Liskov and her students between 1974 and 1975. It was notable for its use of constructors for abstract data types that included the code that operated on them, a key step in the direction of object-oriented programming .... had a feature with the interface closer to what Java has introduced later. A function could raise only exceptions listed in its type, but any leaking exceptions from called functions would automatically be turned into the sole runtime exception, failure, instead of resulting in compile-time error. Later, Modula-3
Modula-3
In Computer science, Modula-3 is a programming language conceived as a successor to an upgraded version of Modula-2. While it has been influential in research circles it has not been adopted widely in industry.... had a similar feature. These features don't include the compile time checking which is central in the concept of checked exceptions, and hasn't (as of 2006) been incorporated into major programming languages other than Java.
In computer science, compile time refers to either the operations performed by a compiler , programming language requirements that must be met by source code for it to be successfully compiled , or properties of the program that can be reasoned about at compile time.... , greatly reduce (but not entirely eliminate) the incidence of unhandled exceptions surfacing at runtime
Runtime
In computer science, runtime or run time describes the operation of a computer program, the duration of its execution, from beginning to termination .... in a given application; the unchecked exceptions (RuntimeExceptions and Errors) can still go unhandled.
However, some see checked exceptions as a nuisance, syntactic salt that either requires large throws declarations, often revealing implementation details and reducing encapsulation
Encapsulation (computer science)
In computer science, Encapsulation is the hiding of the internal mechanisms and data structures of a software component behind a defined interface, in such a way that users of the component only need to know what the component does, and cannot make themselves dependent on the details of how it does it.... , or encourages the (ab)use of poorly-considered try/catch blocks that can potentially hide legitimate exceptions from their appropriate handlers. The problem is more evident considering what happens to code over time. An interface may be declared to throw exceptions X & Y. In a later version of the code, if one wants to throw exception Z, it would make the new code incompatible with the earlier uses. Furthermore, with the adapter pattern
Adapter pattern
In computer programming, the adapter design pattern translates one Interface for a Class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface.... , where one body of code declares an interface that is then implemented by a different body of code so that code can be plugged in and called by the first, the adapter code may have a rich set of exceptions to describe problems, but is forced to use the exception types declared in the interface.
Others do not consider this a nuisance as it is possible to reduce the number of declared exceptions by either declaring a superclass
Superclass (computer science)
In computer science, a superclass is a class from which other classes are derived. A superclass is also called a parent class. The classes that are derived from a superclass are known as child classes, derived classes, or subclass .... of all potentially thrown exceptions or by defining and declaring exception types that are suitable for the level of abstraction of the called method, and mapping lower level exceptions to these types, preferably wrapped using the exception chaining
Exception chaining
Exception chaining, or exception wrapping, is an object-oriented programming technique of exception handling by re-throwing a caught exception after wrapping it inside a new exception.... in order to preserve the root cause. In addition, it's very possible that in the example above of the changing interface that the calling code would need to be modified as well, since in some sense the exceptions a method may throw are part of the method's implicit interface anyway.
A simple throws Exception declaration or catch (Exception e) is always sufficient to satisfy the checking. While this technique is sometimes useful, it effectively circumvents the checked exception mechanism, so it should only be used after careful consideration. Additionally, throws Exception forces all calling code to do the same.
One prevalent view is that unchecked exception types should not be handled, except maybe at the outermost levels of scope, as they often represent scenarios that do not allow for recovery: RuntimeExceptions frequently reflect programming defects, and Errors generally represent unrecoverable JVM failures. The view is that, even in a language that supports checked exceptions, there are cases where the use of checked exceptions is not appropriate.
Exception synchronity
Somewhat related with the concept of checked exceptions is exception synchronity. Synchronous exceptions happen at a specific program statement whereas asynchronous exceptions can raise practically anywhere. It follows that asynchronous exception handling can't be required by the compiler. They are also difficult to program with. Examples of naturally asynchronous events include pressing Ctrl-C to interrupt a program, and receiving a signal
Signal (computing)
A signal is a limited form of inter-process communication used in Unix, Unix-like, and other POSIX-compliant operating systems. Essentially it is an asynchronous notification sent to a Process in order to notify it of an event that occurred.... such as "stop" or "suspend" from another thread of execution
Thread (computer science)
In computer science, a thread of execution is a Fork of a computer program into two or more Concurrency running task s. The implementation of threads and process es differs from one operating system to another, but in most cases, a thread is contained inside a process.... .
Programming languages typically deal with this by limiting asynchronity, for example Java has lost thread stopping and resuming. Instead, there can be semi-asynchronous exceptions that only raise in suitable locations of the program or synchronously.
Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, published in American National Standards Institute standard document Information Technology - Programming Language - Common Lisp, formerly X3.226-1994 .... , Dylan
Dylan programming language
The Dylan programming language is a multi-paradigm language that includes support for Functional programming and Object-oriented programming programming, and is dynamic programming language and Reflection while providing a programming model designed to support efficient machine code generation, including fine-grained control over dynamic and... and Smalltalk
Smalltalk
Smalltalk is an Object-oriented programming, Type system, reflection computer programming programming language. Smalltalk was created as the language to underpin the "new world" of computing exemplified by "human?computer symbiosis." It was designed and created in part for educational use, more so for constructionist learning, at PARC by Al... have a Condition system which encompasses the aforementioned exception handling systems. In those languages or environments the advent of a condition (a "generalisation of an error" according to Kent Pitman
Kent Pitman
Kent M. Pitman is the President of and has been involved for many years in the design, implementation and use of Lisp programming language and Scheme systems.... ) implies a function call, and only late in the exception handler the decision to unwind the stack may be taken.
Conditions are a generalization of exceptions. When a condition arises, an appropriate condition handler is searched for and selected, in stack order, to handle the condition. Conditions which do not represent errors may safely go unhandled entirely; their only purpose may be to propagate hints or warnings toward the user.
Continuable exceptions
This is related to the so-called resumption model of exception handling, in which some exceptions are said to be continuable: it is permitted to return to the expression that signaled an exception, after having taken corrective action in the handler. The condition system is generalized thus: within the handler of a non-serious condition (a.k.a. continuable exception), it is possible to jump to predefined restart points (a.k.a. restarts) that lie between the signaling expression and the condition handler. Restarts are functions closed over some lexical environment, allowing the programmer to repair this environment before exiting the condition handler completely or unwinding the stack even partially.
Restarts separate mechanism from policy
Condition handling moreover provides a separation of mechanism from policy. Restarts provide various possible mechanisms for recovering from error, but do not select which mechanism is appropriate in a given situation. That is the province of the condition handler, which (since it is located in higher-level code) has access to a broader view.
An example: Suppose there is a library function whose purpose is to parse a single syslog
Syslog
syslog is a standard for forwarding Data logging in an Internet Protocol Computer network. The term "syslog" is often used for both the actual syslog network protocol, as well as the application or library sending... file entry. What should this function do if the entry is malformed? There is no one right answer, because the same library could be deployed in programs for many different purposes. In an interactive log-file browser, the right thing to do might be to return the entry unparsed, so the user can see it -- but in an automated log-summarizing program, the right thing to do might be to supply null values for the unreadable fields, but abort with an error if too many entries have been malformed.
That is to say, the question can only be answered in terms of the broader goals of the program, which are not known to the general-purpose library function. Nonetheless, exiting with an error message is only rarely the right answer. So instead of simply exiting with an error, the function may establish restarts offering various ways to continue -- for instance, to skip the log entry, to supply default or null values for the unreadable fields, to ask the user for the missing values, or to unwind the stack and abort processing with an error message. The restarts offered constitute the mechanism
Mechanism
Mechanism may refer to:*Mechanism , explaining how a feature is created.*Reaction_mechanism , explaining a reaction pathway.*Mechanism , a theory that all natural phenomena can be explained by physical causes... s available for recovering from error; the selection of restart by the condition handler supplies the policy
Policy
A policy is typically described as a deliberate plan of action to guide decisions and achieve rational outcome. However, the term may also be used to denote what is actually done, even though it is unplanned.... .
Exception guarantees, also known as the Abrahams guarantees after David Abrahams who formalized the guidelines, are a set of contractual guidelines that class library implementors and clients use when reasoning about exception safety in C++ programs....
A triple fault is a special kind of Exception handling generated by the Central processing unit when an exception occurs while the CPU is trying to invoke the double fault exception handler, which itself handles exceptions occurring while trying to invoke a regular exception handler....
Microsoft Vectored Exception Handling is an exception handling mechanism that complements the Structured Exception Handling mechanism. It is available on the Windows NT family of operating systems, starting with Windows XP.... (VEH)
Christopher Hill may refer to:*Christopher Hill , English bishop*Christopher J. Hill, International Relations scholar, Professor and Director of the Cambridge Centre of International Studies...
Article ""
Article "" by Gigi Sayfan
Article "[https://db.usenix.org/events/wiess2000/full_papers/dinechin/dinechin.pdf C++ Exception Handling]" by Christophe de Dinechin
Article "" by Graham Hutton and Joel Wright
Joel Wright
Joel Wright is a Canadian football Safety for the Montreal Alouettes of the Canadian Football League. He was drafted by the Alouettes in the third round of the 2004 CFL Draft....
Article "" by Brian Goetz
Article "" by Kyle Loudon
Article "" by Arun Udaya Shankar
Article ""
Article "" by Tom Schotland and Peter Petersen
Article "" by Vadim Kokielov
Article "" by James "Jim" Wilcox
Article "" by John M. Dlugosz
Paper "" by Gert Faustmann and Dietmar Wikarski
Paper ""
by Matt Pietrek
Matt Pietrek
Matt Pietrek is a computer specialist and author specializing in MS Windows.Pietrek has written several books on the subject and, for eight years, wrote the column "Under the Hood" in MSJ MSDN Magazine.... - Microsoft Systems Journal (1997)
- a conversation with Anders Hejlsberg
Anders Hejlsberg
Anders Hejlsberg is a prominent Denmark software engineer who co-designed several popular and commercially successful programming languages and development tools....
- Jakob Jenkov
- Danny Kalev
Visual Prolog (wiki article)
