Well-Typed Programs Can Go Wrong: A Study of Typing-Related Bugs in JVM Compilers

Despite the substantial progress in compiler testing, research endeavors have mainly focused on detecting compiler crashes and subtle miscompilations caused by bugs in the implementation of compiler optimizations. Surprisingly, this growing body of work neglects other compiler components, most notably the front-end. In statically-typed programming languages with rich and expressive type systems and modern features, such as type inference or a mix of object-oriented with functional programming features, the process of static typing in compiler front-ends is complicated by a high-density of bugs. Such bugs can lead to the acceptance of incorrect programs (breaking code portability or the type system's soundness), the rejection of correct (e.g. well-typed) programs, and the reporting of misleading errors and warnings. We conduct, what is to the best of our knowledge, the first empirical study for understanding and characterizing typing-related compiler bugs. To do so, we manually study 320 typing-related bugs (along with their fixes and test cases) that are randomly sampled from four mainstream JVM languages, namely Java, Scala, Kotlin, and Groovy. We evaluate each bug in terms of several aspects, including their symptom, root cause, bug fix's size, and the characteristics of the bug-revealing test cases. Some representative observations indicate that: (1) more than half of the typing-related bugs manifest as unexpected compile-time errors: the buggy compiler wrongly rejects semantically correct programs, (2) the majority of typing-related bugs lie in the implementations of the underlying type systems and in other core components related to operations on types, (3) parametric polymorphism is the most pervasive feature in the corresponding test cases, (4) one third of typing-related bugs are triggered by non-compilable programs. We believe that our study opens up a new research direction by driving future researchers to build appropriate methods and techniques for a more holistic testing of compilers

Well-typed programs can go wrong: A study of typing-related bugs in JVM compilers

Despite the substantial progress in compiler testing, research endeavors have mainly focused on detecting compiler crashes and subtle miscompilations caused by bugs in the implementation of compiler optimizations. Surprisingly, this growing body of work neglects other compiler components, most notably the front-end. In statically-typed programming languages with rich and expressive type systems and modern features, such as type inference or a mix of object-oriented with functional programming features, the process of static typing in compiler front-ends is complicated by a high-density of bugs. Such bugs can lead to the acceptance of incorrect programs (breaking code portability or the type system's soundness), the rejection of correct (e.g. well-typed) programs, and the reporting of misleading errors and warnings. We conduct, what is to the best of our knowledge, the first empirical study for understanding and characterizing typing-related compiler bugs. To do so, we manually study 320 typing-related bugs (along with their fixes and test cases) that are randomly sampled from four mainstream JVM languages, namely Java, Scala, Kotlin, and Groovy. We evaluate each bug in terms of several aspects, including their symptom, root cause, bug fix's size, and the characteristics of the bug-revealing test cases. Some representative observations indicate that: (1) more than half of the typing-related bugs manifest as unexpected compile-time errors: the buggy compiler wrongly rejects semantically correct programs, (2) the majority of typing-related bugs lie in the implementations of the underlying type systems and in other core components related to operations on types, (3) parametric polymorphism is the most pervasive feature in the corresponding test cases, (4) one third of typing-related bugs are triggered by non-compilable programs. We believe that our study opens up a new research direction by driving future researchers to build appropriate methods and techniques for a more holistic testing of compilers. Software Engineerin

Prevalence of comorbidities in systemic sclerosis versus rheumatoid arthritis: a comparative, multicenter, matched-cohort study

Abstract Background Comorbidities are common in chronic systemic connective tissue diseases and are associated with adverse outcomes, increased morbidity and mortality. Although the prevalence of comorbidities has been well-studied in isolated diseases, comparative studies between different autoimmune diseases are limited. In this study, we compared the prevalence of common comorbidities between patients with systemic sclerosis (SSc) and patients with rheumatoid arthritis (RA). Methods Between 2016 and 2017, 408 consecutive patients with SSc, aged 59 ± 13 years (87% women), were matched 1:1 for age and gender with 408 patients with RA; mean disease duration was 10 ± 8 and 9 ± 8 years, respectively. Rates of cardiovascular risk factors, coronary artery disease, stroke, chronic obstructive pulmonary disease (COPD), osteoporosis, neoplasms and depression were compared between the two cohorts. Results The prevalence of dyslipidemia (18.4% vs 30.1%, p = 0.001) and diabetes mellitus (5.6% vs 11.8%, p = 0.007) and body mass index (p = 0.001) were lower in SSc compared to RA, while there was no difference in arterial hypertension or smoking. While there was a trend for lower prevalence of ischemic stroke in SSc than in RA (1.1% vs 3.2%, p = 0.085), coronary artery disease was comparable (2.7% vs 3.7%). No differences were found between patients with SSc and patients with RA in the prevalence of COPD (5.2% vs 3.7%), osteoporosis (24% vs 22%) or neoplasms overall (1.1% vs 1.7%); however lung cancer was the most prevalent cancer in SSc (7/17, 41%), whereas hematologic malignancies (7/19, 36%) and breast cancer (7/19, 36%) predominated in RA. Depression was more prevalent in SSc (22% vs 12%, p = 0.001), especially in diffuse SSc. Conclusions Despite the prevalence of dyslipidemia and diabetes mellitus in SSc being almost half that in RA, the cardiovascular comorbidity burden appears to be similar in both. The overall prevalence of neoplasms is no higher in SSc than in RA, but SSc has a more negative impact on quality of life, as clearly, more SSc patients develop depression compared to patients with RA

Well-typed programs can go wrong: a study of typing-related bugs in JVM compilers

Summarization: Despite the substantial progress in compiler testing, research endeavors have mainly focused on detecting compiler crashes and subtle miscompilations caused by bugs in the implementation of compiler optimizations. Surprisingly, this growing body of work neglects other compiler components, most notably the front-end. In statically-typed programming languages with rich and expressive type systems and modern features, such as type inference or a mix of object-oriented with functional programming features, the process of static typing in compiler front-ends is complicated by a high-density of bugs. Such bugs can lead to the acceptance of incorrect programs (breaking code portability or the type system's soundness), the rejection of correct (e.g. well-typed) programs, and the reporting of misleading errors and warnings. We conduct, what is to the best of our knowledge, the first empirical study for understanding and characterizing typing-related compiler bugs. To do so, we manually study 320 typing-related bugs (along with their fixes and test cases) that are randomly sampled from four mainstream JVM languages, namely Java, Scala, Kotlin, and Groovy. We evaluate each bug in terms of several aspects, including their symptom, root cause, bug fix's size, and the characteristics of the bug-revealing test cases. Some representative observations indicate that: (1) more than half of the typing-related bugs manifest as unexpected compile-time errors: the buggy compiler wrongly rejects semantically correct programs, (2) the majority of typing-related bugs lie in the implementations of the underlying type systems and in other core components related to operations on types, (3) parametric polymorphism is the most pervasive feature in the corresponding test cases, (4) one third of typing-related bugs are triggered by non-compilable programs. We believe that our study opens up a new research direction by driving future researchers to build appropriate methods and techniques for a more holistic testing of compilers.Presented on: Proceedings of the ACM on Programming Language