NDLI: Accepting blame for safe tunneled exceptions

Please wait, while we are loading the content...

Into the depths of C: elaborating the de facto standards

Data-driven precondition inference with learned features

Coverage-directed differential testing of JVM implementations

Effective padding of multidimensional arrays to avoid cache conflict misses

Configuration synthesis for programmable analog devices with Arco

On the complexity and performance of parsing with derivatives

Stratified synthesis: automatically learning the x86-64 instruction set

Accepting blame for safe tunneled exceptions

MapReduce program synthesis

Event-driven network programming

Rehearsal: a configuration verification tool for puppet

Just-in-time static type checking for dynamic languages

Synthesizing transformations on hierarchically structured data

Higher-order and tuple-based massively-parallel prefix sums

Idle time garbage collection scheduling

Cardinalities and universal quantifiers for verifying parameterized systems

Precise, dynamic information flow for database-backed applications

Transactional data structure libraries

Living on the edge: rapid-toggling probes with cross-modification on x86

Cartesian hoare logic for verifying k-safety properties

Exposing errors related to weak memory in GPU applications

GreenWeb: language extensions for energy-efficient mobile web computing

From Datalog to flix: a declarative language for fixed points on lattices

Remix: online detection and repair of cache contention for the JVM

Occurrence typing modulo theories

Programmatic and direct manipulation, together at last

Temporal NetKAT

Toward compositional verification of interruptible OS kernels and device drivers

Types from data: making structured data first-class citizens in F#

Program synthesis from polymorphic refinement types

A distributed OpenCL framework using redundant computation and data replication

Assessing the limits of program-specific garbage collection performance

Ivy: safety verification by interactive generalization

End-to-end verification of information-flow security for C and assembly programs

FlexVec: auto-vectorization for irregular loops

Polymorphic type inference for machine code

Verifying bit-manipulations of floating-point

Lightweight computation tree tracing for lazy functional languages

Input responsiveness: using canary inputs to dynamically steer approximation

Latte: a language, compiler, and runtime for elegant and efficient deep neural networks

Statistical similarity of binaries

Refinement types for TypeScript

Fast synthesis of fast collections

SDNRacer: concurrency analysis for software-defined networks

Verified peephole optimizations for CompCert

Automatically learning shape specifications

A design and verification methodology for secure isolated regions

Verified lifting of stencil computations

Accepting blame for safe tunneled exceptions

Content Provider	ACM Digital Library
Author	Salvaneschi, Guido Beightol, Quinn Zhang, Yizhou Liskov, Barbara Myers, Andrew C.
Abstract	Unhandled exceptions crash programs, so a compile-time check that exceptions are handled should in principle make software more reliable. But designers of some recent languages have argued that the benefits of statically checked exceptions are not worth the costs. We introduce a new statically checked exception mechanism that addresses the problems with existing checked-exception mechanisms. In particular, it interacts well with higher-order functions and other design patterns. The key insight is that whether an exception should be treated as a "checked" exception is not a property of its type but rather of the context in which the exception propagates. Statically checked exceptions can "tunnel" through code that is oblivious to their presence, but the type system nevertheless checks that these exceptions are handled. Further, exceptions can be tunneled without being accidentally caught, by expanding the space of exception identifiers to identify the exception-handling context. The resulting mechanism is expressive and syntactically light, and can be implemented efficiently. We demonstrate the expressiveness of the mechanism using significant codebases and evaluate its performance. We have implemented this new exception mechanism as part of the new Genus programming language, but the mechanism could equally well be applied to other programming languages. .
Starting Page	281
Ending Page	295
Page Count	15
File Format	PDF
ISBN	9781450342612
DOI	10.1145/2908080.2908086
Language	English
Publisher	Association for Computing Machinery (ACM)
Publisher Date	2016-06-02
Publisher Place	New York
Access Restriction	Subscribed
Subject Keyword	Exception handling Genus Exception tunneling
Content Type	Text
Resource Type	Article

Sl.	Authority	Responsibilities	Communication Details
1	Ministry of Education (GoI), Department of Higher Education	Sanctioning Authority	https://www.education.gov.in/ict-initiatives
2	Indian Institute of Technology Kharagpur	Host Institute of the Project: The host institute of the project is responsible for providing infrastructure support and hosting the project	https://www.iitkgp.ac.in
3	National Digital Library of India Office, Indian Institute of Technology Kharagpur	The administrative and infrastructural headquarters of the project	Dr. B. Sutradhar bsutra@ndl.gov.in
4	Project PI / Joint PI	Principal Investigator and Joint Principal Investigators of the project	Dr. B. Sutradhar bsutra@ndl.gov.in Prof. Saswat Chakrabarti will be added soon
5	Website/Portal (Helpdesk)	Queries regarding NDLI and its services	support@ndl.gov.in
6	Contents and Copyright Issues	Queries related to content curation and copyright issues	content@ndl.gov.in
7	National Digital Library of India Club (NDLI Club)	Queries related to NDLI Club formation, support, user awareness program, seminar/symposium, collaboration, social media, promotion, and outreach	clubsupport@ndl.gov.in
8	Digital Preservation Centre (DPC)	Assistance with digitizing and archiving copyright-free printed books	dpc@ndl.gov.in
9	IDR Setup or Support	Queries related to establishment and support of Institutional Digital Repository (IDR) and IDR workshops	idr@ndl.gov.in

Accepting blame for safe tunneled exceptions

Safe Asynchronous Exceptions For Python (2002)

A brief outline ◮ exception handling: why? ◮ errors and error codes ◮ the need for exception handling ◮ exception handling in ruby: ◮ the exception class ◮ exception class heirarchy ◮ handling exceptions ◮ raising exceptions ◮ catch/throw clauses ◮ conclu (2004).

Making exceptions on exception handling

Designing robust Java programs with exceptions

Asynchronous exception propagation in blocked tasks

Exception handling in microprocessors using assertion libraries

Combining the robustness of checked exceptions with the flexibility of unchecked exceptions using anchored exception declarations

A semantics for execution levels with exceptions

Accepting blame for safe tunneled exceptions

Similar Documents

Accepting blame for safe tunneled exceptions

Safe Asynchronous Exceptions For Python (2002)

A brief outline ◮ exception handling: why? ◮ errors and error codes ◮ the need for exception handling ◮ exception handling in ruby: ◮ the exception class ◮ exception class heirarchy ◮ handling exceptions ◮ raising exceptions ◮ catch/throw clauses ◮ conclu (2004).

Making exceptions on exception handling

Designing robust Java programs with exceptions

Asynchronous exception propagation in blocked tasks

Exception handling in microprocessors using assertion libraries

Combining the robustness of checked exceptions with the flexibility of unchecked exceptions using anchored exception declarations

A semantics for execution levels with exceptions

Accepting blame for safe tunneled exceptions