To Type or Not to Type: Quantifying Detectable Bugs in JavaScript

By Zheng Gao, Christian Bird, Earl T. Barr. 2017

92 citations recorded by the source corpus.

Subfields: Information Systems, Software, Program Analysis & Verification, Software Engineering

How researchers see this paper

The researchers whose trusted networks rank it highest, strongest advocate first. Every researcher gets a different order.

In Information Systems

In Software

In Program Analysis & Verification

In Software Engineering

Citations in the corpus

TypeWriter: neural type prediction with search-based validation (2019, background): “Examples include type errors that remain unnoticed for a long time [9], suboptimal IDE support, and difficult to understand APIs [22].”
LambdaNet: Probabilistic Type Inference using Graph Neural Networks (2020, background): “…Ruby, and Javascript have gained enormous popularity over the last decade, yet their lack of a static type system comes with certain disadvantages in terms of maintainability (Hanenberg et al., 2013), the ability to catch errors at compile time, and code completion support (Gao et al., 2017).”
NL2Type: Inferring JavaScript Function Types from Natural Language Information (2019, background): “typed languages [5]–[8], which can help detecting otherwise missed bugs [33].”
Learning type annotation: is big data enough? (2021, unknown): “Type annotation promotes error-detection, [9, 19] while enabling more optimizations, and better IDE support.”
Type4Py: Practical Deep Similarity Learning-Based Type Inference for Python (2021, background): “It is known that statically-typed languages are less error-prone [54] and that static types improve important quality aspects of software [20], like the maintainability of software systems in terms of understandability, fixing type errors [23], and early bug detection [20].”
OptTyper: Probabilistic Type Inference by Optimising Logical and Natural Constraints (2020, background): “aranteeing constraints on program behaviour. A large scale user-study suggests that programmers benefit from type safety [Hanenberg et al. 2014]; use of type has also been show to prevent field bugs [Gao et al. 2017]. However, type safety comes at a cost: these languages often require explicit type ”
Learning to Predict User-Defined Types (2023, background): “The optionality of gradually typed languages is a double-edged sword wherein the convenience of not typing variables and functions may result in type errors that can be caught prior to deployment if properly labeled [4].”
Assessing the Type Annotation Burden (2018, background): “[12] found that type annotations help find 15% of bugs in open-source projects.”
Typilus: neural type hints (2020, background): “Though optional type checkers reason over only a partial context with respect to a fully-typed program and are generally unsound, their best-effort is reasonably effective in practice [26].”