An Empirical Study about the Use of Optional Typing in Software - PowerPoint PPT Presentation

An Empirical Study about the Use of Optional Typing in Software Systems Carlos Souza Eduardo Figueiredo carlosgsouza@gmail.com figueiredo@dcc.ufmg.br

Java JavaScript

dynamically typed languages are becoming more popular

30% 15%

python php python php +javascript +javascript +javascript +javascript php python ASP.net ASP.net +javascript +javascript +javascript +javascript

dynamically typed languages are becoming more popular

x Untyped Typed

What is the best type system?

"If someone claims to have the perfect programming language, he is either a fool or a salesman or both." (Bjarne Stroustrup)

How do programmers use different typing paradigms?

An Empirical Study about the Use of Optional Typing in Software Systems Carlos Souza Eduardo Figureido carlosgsouza@gmail.com figueiredo@dcc.ufmg.br

Introduction Type Systems Study Settings Results and Discussion Conclusion and Future Work

Introduction Type Systems Study Settings Results and Discussion Conclusion and Future Work

Typed Untyped

Typed type checking String s = new File(); documentation tool integration

Typed type checking documentation int sum(Integer[] list) tool integration

Typed public final class Integer extends Number type checking implements Comparable<Integer> The Integer class wraps a value of the primitive type int in an object. An documentation object of type Integer contains a single field whose type is int. tool integration int sum(Integer[] list)

Untyped def sum(v) { def result v.each { simplicity result += it } return result flexibility }

Untyped simplicity def byteValue(number) { return number.byteValue() flexibility } ... println byteValue(new Integer (1)) println byteValue(new Double (1.0)) println byteValue(new CarlosInt ("1"))

Typed Untyped x type checking simplicity documentation flexibility tool integration

How do programmers use different typing paradigms?

Introduction Type Systems Study Settings Results and Discussion Conclusion and Future Work

A large scale empirical study with the goal of finding how programmers use optional typing

int sum(int a, int b) def sum(a,b) { { int result = a+b def result = a+b return result return result } } int sum(a, int b) { def result = a+b return result }

Where Groovy programmers like to use types and where they don't

Q1: Do programmers use types more often in the interface of their modules ? Q2: Do programmers use types less often in test classes and scripts ? Q3: Does the experience of programmers with other languages influence their choice for typing their code? Q4: Does the size, age or level of activity of a project have any influence on the usage of types? Q5: In frequently changed code, do developers prefer typed or untyped declarations?

Dataset

Dataset 6638 projects 1.5M declarations 60GB of data 9.8M lines of code 4481 programmers

Dataset

Static code analyzer kind visibility context typed or untyped

Dataset Relative ? Use of Types

Introduction Type Systems Study Settings Results and Discussion Conclusion and Future Work

Q1 Do programmers use types more often in the interface of their modules ?

The interface of a module is composed by fields, methods and constructors which are public or protected

The interface of a module is NOT composed by local variables or private declarations

Relative Usage of Types by Declaration Kind Relative Usage of Types by Declaration Visibility

Are these results significantly different?

There is no difference H 0 : in how programmers type different kinds of declarations

ANOVA + Tukey Honestly Significant Differences

α = 0.001

confidence = 99.9%

ANOVA reported p = 0

Relative Usage of Types by Declaration Kind Relative Usage of Types by Declaration Visibility

Relative Usage of Types by Declaration Kind Relative Usage of Types by Declaration Visibility

Q1 Yes , programmers use types more often in the interface of their modules

programmers use types to document their modules

documentation is not so necessary in local variables and private methods and fields

Why are fields mostly untyped? Relative Usage of Types by Declaration Kind

private protected public

Why are constructor and protected declarations typed so often? Relative Usage of Types by Declaration Kind Relative Usage of Types by Declaration Visibility

constructors are important elements of a module definition

protected declarations establish complex contracts

Q2 Do programmers use types less often in test classes and scripts?

Q2.a Do programmers use types less often in test classes?

Factorial ANOVA + Tukey Honestly Significant Differences

Q2.a Yes , programmers use types less often in test classes

Q2.b Do programmers use types less often in scripts?

Q2.b Yes , programmers use types less often in scripts

maintainability is not a concern in these scenarios

Q3 Does the experience of programmers with other languages influence their choice for typing their code?

Static only Dynamic Only Static and Dynamic

Q3 Yes , programmers of the static only group use types more often than others

programmers get used to the lack of types

Q4 Does the size, age or level of activity of a project have any influence on the usage of types?

Spearman Correlation Ranking Type age (days) size (LoC) Usage activity (commits)

Do we see any influence on mature projects?

a project is considered mature if it has more than 100 days 2000 lines of code 100 commits

we have 223 mature projects

ANOVA reported p = 0.05

Q4 No , the size, age and level of activity have no influence on the usage of types

Q5 In frequently changed code, do developers prefer typed or untyped declarations?

Spearman Correlation Ranking Type commits Usage in of a file that file

Type File Commits Usage Car.groovy 10 0.1 Wheel.groovy 15 0.2 Engine.groovy 16 0.21 Transmission.groovy 17 0.23 Radio.groovy 38 0.44 Spearman Ranking = 1.0

Type File Commits Usage Car.groovy 10 0.9 Wheel.groovy 15 0.82 Engine.groovy 16 0.21 Transmission.groovy 17 0.14 Radio.groovy 38 0.04 Spearman Ranking = -1.0

12% 30%

Q5 In most cases, developers prefer untyped declarations in frequently changed code

Introduction Type Systems Study Settings Results and Discussion Conclusion and Future Work

Groovy programmers types more often in declarations that define the interface of modules Types are used less frequently in test classes and script files Programmer’s who only developed in statically typed languages type more often than other programmers There is no influence of the size, age or level of activity of a project on how programmers use types In frequently changed files, untyped declarations are more popular

Provides real data which can be used by developers of programming languages and tools Helps on the understanding of the tradeoffs between different typing paradigms Complements experimental studies with a different point of view Raises new questions that can inspire other researchers

Future Work

Measuring the impact of compile, runtime and unit test error messages on maintenance time