Jan Vitek

Jan Vitek

Auto-generated profile, based on publicly available information

Jan Vitek

Charles University, Prague, Czech Republic and Czech Technical University Prague, Czech Republic

Research Focus & Metrics

Academic Career Length

28Years (1999-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
12 October 2019 in ACM Transactions on Programming Languages and Systems
Verified
Journal Article
Open access
EBEmery D. Berger
Emery D. Berger
CHCeleste Hollenbeck
Celeste Hollenbeck
PMPetr Maj
Petr Maj
OVOlga Vitek
Olga Vitek
JVJan Vitek
Jan Vitek
In a 2014 article, Ray, Posnett, Devanbu, and Filkov claimed to have uncovered a statistically significant association between 11 programming languages and software defects in 729 projects hosted on GitHub. Specifically, their work answered four research questions relating to software defects and programming languages. With data and code provided by the authors, the present article first attempts to conduct an experimental repetition of the original study. The repetition is only partially successful, due to missing code and issues with the classification of languages. The second part of this work focuses on their main claim, the association between bugs and languages, and performs a complete, independent reanalysis of the data and of the statistical modeling steps undertaken by Ray et al. in 2014. This reanalysis uncovers a number of serious flaws that reduce the number of languages with an association with defects down from 11 to only 4. Moreover, the practical effect size is exceedingly small. These results thus undermine the conclusions of the original study. Correcting the record is important, as many subsequent works have cited the 2014 article and have asserted, without evidence, a causal link between the choice of programming language for a given task and the number of software defects. Causation is not supported by the data at hand; and, in our opinion, even after fixing the methodological flaws we uncovered, too many unaccounted sources of bias remain to hope for a meaningful comparison of bug rates across languages.

1 October 1999
Verified
Conference Paper
Open access
PDF file
JVJan Vitek
Jan Vitek
BBBoris Bokowski
Boris Bokowski

13 November 2020 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
OFOlivier Flückiger
Olivier Flückiger
GCGuido Chari
Guido Chari
MYMing-Ho Yee
Ming-Ho Yee
JJJan Ječmen
Jan Ječmen
JHJakob Hain
Jakob Hain
JVJan Vitek
Jan Vitek
In order to generate efficient code, dynamic language compilers often need information, such as dynamic types, not readily available in the program source. Leveraging a mixture of static and dynamic information, these compilers speculate on the missing information. Within one compilation unit, they specialize the generated code to the previously observed behaviors, betting that past is prologue. When speculation fails, the execution must jump back to unoptimized code. In this paper, we propose an approach to further the specialization, by disentangling classes of behaviors into separate optimization units. With contextual dispatch, functions are versioned and each version is compiled under different assumptions. When a function is invoked, the implementation dispatches to a version optimized under assumptions matching the dynamic context of the call. As a proof-of-concept, we describe a compiler for the R language which uses this approach. Our implementation is, on average, 1.7× faster than the GNU R reference implementation. We evaluate contextual dispatch on a set of benchmarks and measure additional speedup, on top of traditional speculation with deoptimization techniques. In this setting contextual dispatch improves the performance of 18 out of 46 programs in our benchmark suite.

22 March 2010
Verified
Conference Paper
Open access
PDF file
MSMartin Schoeberl
Martin Schoeberl
FBFlorian Brandner
Florian Brandner
JVJan Vitek
Jan Vitek

20 February 2019 in Journal of Functional Programming
Verified
Journal Article
Closed access
PDF file
BGBEN Greenman
BEN Greenman
ATAsumu Takikawa
Asumu Takikawa
MNMax S. New
Max S. New
DFDaniel Feltey
Daniel Feltey
RFRobert Bruce Findler
Robert Bruce Findler
MFMatthias Felleisen
Matthias Felleisen
A sound gradual type system ensures that untyped components of a program can never break the guarantees of statically typed components. This assurance relies on runtime checks, which in turn impose performance overhead in proportion to the frequency and nature of interaction between typed and untyped components. The literature on gradual typing lacks rigorous descriptions of methods for measuring the performance of gradual type systems. This gap has consequences for the implementors of gradual type systems and developers who use such systems. Without systematic evaluation of mixed-typed programs, implementors cannot precisely determine how improvements to a gradual type system affect performance. Developers cannot predict whether adding types to part of a program will significantly degrade (or improve) its performance. This paper presents the first method for evaluating the performance of sound gradual type systems. The method quantifies both the absolute performance of a gradual type system and the relative performance of two implementations of the same gradual type system. To validate the method, the paper reports on its application to 20 programs and 3 implementations of Typed Racket.

1 January 2007
Verified
Conference Paper
Open access
PDF file
MSMartin Schoeberl
Martin Schoeberl
JVJan Vitek
Jan Vitek