research-article

Static vs. dynamic type systems: an empirical study about the relationship between type casts and development time

Authors:

Andreas Stuchlik,

Stefan HanenbergAuthors Info & Claims

DLS '11: Proceedings of the 7th symposium on Dynamic languages

Pages 97 - 106

https://doi.org/10.1145/2047849.2047861

Published: 24 October 2011 Publication History

Abstract

Static type systems are essential in computer science. However, there is hardly any knowledge about the impact of type systems on the resulting piece of software. While there are authors that state that static types increase the development speed, other authors argue the other way around. A previous experiment suggests that there are multiple factors that play a role for a comparison of statically and dynamically typed language. As a follow-up, this paper presents an empirical study with 21 subjects that compares programming tasks performed in Java and Groovy - programming tasks where the number of expected type casts vary in the statically typed language. The result of the study is, that the dynamically typed group solved the complete programming tasks significantly faster for most tasks - but that for larger tasks with a higher number of type casts no significant difference could be found.

References

[1]

Jürgen Bortz. Statistik: für Human- und Sozialwissenschaftler. Springer, 6., vollst. überarb. u. aktualisierte aufl. edition, September 2005.

[2]

Ruven E. Brooks. Studying programmer behavior experimentally: the problems of proper methodology. Commun. ACM, 23:207--213, April 1980.

Digital Library

[3]

Kim B. Bruce. Foundations of object-oriented languages: types and semantics. MIT Press, Cambridge, MA, USA, 2002.

Digital Library

[4]

Luca Cardelli. Type systems. In Allen B. Tucker, editor, The Computer Science and Engineering Handbook, chapter 103, pages 2208--2236. CRC Press, 1997.

[5]

B. Curtis. Five paradigms in the psychology of programming. In M. Helander, editor, Handbook of Human-Computer Interaction, pages 87--106. Elsevier (North-Holland), 1988.

[6]

Mark T. Daly, Vibha Sazawal, and Jeffrey S. Foster. Work in progress: an empirical study of static typing in ruby. Workshop on Evaluation and Usability of Programming Languages and Tools (PLATEAU), Orlando, Florida, October 2009, 2009.

[7]

Steve M. Easterbrook, J. Singer, M. Storey, and D. Damian. Selecting empirical methods for software engineering research. In F. Shull, J. Singer, and D. Sjøberg, editors, Guide to Advanced Empirical Software Engineering. Springer, 2007.

Digital Library

[8]

J. D. Gannon. An experimental evaluation of data type conventions. Commun. ACM, 20(8):584--595, 1977.

Digital Library

[9]

Stefan Hanenberg. Doubts about the positive impact of static type systems on programming tasks in single developer projects - an empirical study. In ECOOP 2010 - Object-Oriented Programming, 24th European Conference, Maribor, Slovenia, June 21-25, 2010. Proceedings, LNCS 6183, pages 300--303. Springer, 2010.

Digital Library

[10]

Stefan Hanenberg. An experiment about static and dynamic type systems: Doubts about the positive impact of static type systems on development time. In Proceedings of the ACM international conference on Object oriented programming systems languages and applications, OOPSLA '10, pages 22--35, New York, NY, USA, 2010. ACM.

Digital Library

[11]

Stefan Hanenberg. A chronological experience report from an initial experiment series on static type systems. In 2nd Workshop on Empirical Evaluation of Software Composition Techniques (ESCOT), Lancaster, UK, 2011.

[12]

Stefan Hanenberg, Sebastian Kleinschmager, and Manuel Josupeit-Walter. Does aspect-oriented programming increase the development speed for crosscutting code? an empirical study. In Proceedings of Empirical Software Engineering and Measurement, pages 156--167, 2009.

Digital Library

[13]

Martin Höst, Björn Regnell, and Claes Wohlin. Using students as subjects - a comparative study of students and professionals in lead-time impact assessment. Empirical Softw. Engg., 5(3):201--214, 2000.

Digital Library

[14]

Natalie Juristo and Ana M. Moreno. Basics of Software Engineering Experimentation. Springer, 2001.

Digital Library

[15]

Barbara Kitchenham, Hiyam Al-Khilidar, Muhammad Ali Babar, Mike Berry, Karl Cox, Jacky Keung, Felicia Kurniawati, Mark Staples, He Zhang, and Liming Zhu. Evaluating guidelines for empirical software engineering studies. In ISESE '06: Proceedings of the 2006 ACM/IEEE international symposium on Empirical software engineering, pages 38--47, New York, NY, USA, 2006. ACM.

Digital Library

[16]

Leslie Lamport and Lawrence C. Paulson. Should your specification language be typed. ACM Trans. Program. Lang. Syst., 21(3):502--526, 1999.

Digital Library

[17]

Clemens Mayer, Stefan Hanenberg, Romain Robbes, and Eric Tanter. An experiment about the impact of static type systems for the use of undocumented apis - unpublished work in progress. 2011.

[18]

Benjamin C. Pierce. Types and programming languages. MIT Press, Cambridge, MA, USA, 2002.

Digital Library

[19]

Lutz Prechelt. Kontrollierte Experimente in der Softwaretechnik. Springer, Berlin, March 2001.

[20]

Lutz Prechelt and Walter F. Tichy. A controlled experiment to assess the benefits of procedure argument type checking. IEEE Trans. Softw. Eng., 24(4):302--312, 1998.

Digital Library

[21]

Marvin Steinberg and Stefan Hanenberg. What is the impact of static type systems on debugging type errors and semantic errors? an empirical study of differences in debugging time using statically and dynamically typed languages - unpublished work in progress.

[22]

Laurence Tratt and Roel Wuyts. Guest editors' introduction: Dynamically typed languages. IEEE Software, 24(5):28--30, 2007.

Digital Library

[23]

Walter Bruce Walsh and Nancy E. Betz. Tests and Assessment. Prentice-Hall, Harlow, England, 2. edition, 1995.

[24]

Claes Wohlin, Per Runeson, Martin Höst, Magnus C. Ohlsson, Bjöorn Regnell, and Anders Wesslán. Experimentation in software engineering: an introduction. Kluwer Academic Publishers, Norwell, MA, USA, 2000.

Digital Library

Cited By

Oh WOh HFilkov VRay BZhou M(2024)Towards Effective Static Type-Error Detection for PythonProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering10.1145/3691620.3695545(1808-1820)Online publication date: 27-Oct-2024
https://dl.acm.org/doi/10.1145/3691620.3695545
Guo YChen ZChen LXu WLi YZhou YXu B(2024)Generating Python Type Annotations from Type Inference: How Far Are We?ACM Transactions on Software Engineering and Methodology10.1145/365215333:5(1-38)Online publication date: 3-Jun-2024
https://dl.acm.org/doi/10.1145/3652153
Hanenberg SMorzeck JGruhn V(2024)Indentation and reading time: a randomized control trial on the differences between generated indented and non-indented if-statementsEmpirical Software Engineering10.1007/s10664-024-10531-y29:5Online publication date: 9-Aug-2024
https://doi.org/10.1007/s10664-024-10531-y
Show More Cited By

Index Terms

Static vs. dynamic type systems: an empirical study about the relationship between type casts and development time
1. Software and its engineering
  1. Software notations and tools
    1. General programming languages
      1. Language features

Recommendations

Static vs. dynamic type systems: an empirical study about the relationship between type casts and development time
DLS '11

Static type systems are essential in computer science. However, there is hardly any knowledge about the impact of type systems on the resulting piece of software. While there are authors that state that static types increase the development speed, other ...
The gradualizer: a methodology and algorithm for generating gradual type systems
POPL '16: Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

Many languages are beginning to integrate dynamic and static typing. Siek and Taha offered gradual typing as an approach to this integration that provides a coherent and full-span migration between the two disciplines. However, the literature lacks a ...
Type inference, principal typings, and let-polymorphism for first-class mixin modules
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming

A mixin module is a programming abstraction that simultaneously generalizes λ-abstractions, records, and mutually recursive definitions. Although various mixin module type systems have been developed, no one has investigated principal typings or ...

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image ACM Conferences

DLS '11: Proceedings of the 7th symposium on Dynamic languages

October 2011

114 pages

ISBN:9781450309394

DOI:10.1145/2047849

General Chair:
Theo D'Hondt
Vrije Universiteit Brussel, Belgium

ACM SIGPLAN Notices Volume 47, Issue 2
DLS '11
February 2012
103 pages
ISSN:0362-1340
EISSN:1558-1160
DOI:10.1145/2168696
Issue’s Table of Contents

Copyright © 2011 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Sponsors

SIGPLAN: ACM Special Interest Group on Programming Languages

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 24 October 2011

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Conference

SPLASH '11

Sponsor:

SIGPLAN

SPLASH '11: Conference on Systems, Programming, and Applications: Software for Humanity

October 24, 2011

Oregon, Portland, USA

Acceptance Rates

Overall Acceptance Rate 32 of 77 submissions, 42%

Upcoming Conference

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

43
Total Citations
View Citations
1,045
Total Downloads

Downloads (Last 12 months)72
Downloads (Last 6 weeks)24

Reflects downloads up to 26 Nov 2024

Other Metrics

View Author Metrics

Citations

Cited By

Oh WOh HFilkov VRay BZhou M(2024)Towards Effective Static Type-Error Detection for PythonProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering10.1145/3691620.3695545(1808-1820)Online publication date: 27-Oct-2024
https://dl.acm.org/doi/10.1145/3691620.3695545
Guo YChen ZChen LXu WLi YZhou YXu B(2024)Generating Python Type Annotations from Type Inference: How Far Are We?ACM Transactions on Software Engineering and Methodology10.1145/365215333:5(1-38)Online publication date: 3-Jun-2024
https://dl.acm.org/doi/10.1145/3652153
Hanenberg SMorzeck JGruhn V(2024)Indentation and reading time: a randomized control trial on the differences between generated indented and non-indented if-statementsEmpirical Software Engineering10.1007/s10664-024-10531-y29:5Online publication date: 9-Aug-2024
https://doi.org/10.1007/s10664-024-10531-y
Jesse KDevanbu PSawant A(2023)Learning to Predict User-Defined TypesIEEE Transactions on Software Engineering10.1109/TSE.2022.317894549:4(1508-1522)Online publication date: 1-Apr-2023
https://doi.org/10.1109/TSE.2022.3178945
Lin XHua BWang YPan Z(2023)Towards a Large-Scale Empirical Study of Python Static Type Annotations2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)10.1109/SANER56733.2023.00046(414-425)Online publication date: Mar-2023
https://doi.org/10.1109/SANER56733.2023.00046
Xu WChen LSu CGuo YLi YZhou YXu B(2023)How Well Static Type Checkers Work with Gradual Typing? A Case Study on Python2023 IEEE/ACM 31st International Conference on Program Comprehension (ICPC)10.1109/ICPC58990.2023.00039(242-253)Online publication date: May-2023
https://doi.org/10.1109/ICPC58990.2023.00039
Mir ALatoškinas EProksch SGousios GDwyer MDamian DZeller A(2022)Type4PyProceedings of the 44th International Conference on Software Engineering10.1145/3510003.3510124(2241-2252)Online publication date: 21-May-2022
https://dl.acm.org/doi/10.1145/3510003.3510124
Ore JDetweiler CElbaum S(2021)An Empirical Study on Type AnnotationsACM Transactions on Software Engineering and Methodology10.1145/343977530:2(1-29)Online publication date: 10-Feb-2021
https://dl.acm.org/doi/10.1145/3439775
Jin WZhong DDing ZFan MLiu T(2021)Where to Start: Studying Type Annotation Practices in Python2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE)10.1109/ASE51524.2021.9678947(529-541)Online publication date: Nov-2021
https://doi.org/10.1109/ASE51524.2021.9678947
Hanenberg SMehlhorn N(2021)Two N-of-1 self-trials on readability differences between anonymous inner classes (AICs) and lambda expressions (LEs) on Java code snippetsEmpirical Software Engineering10.1007/s10664-021-10077-327:2Online publication date: 20-Dec-2021
https://doi.org/10.1007/s10664-021-10077-3
Show More Cited By

View Options

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Media

Figures

Other

Tables

View Table of Contents