When developers use Application Programming Interfaces (APIs), they often rely on documentation to assist their tasks. In previous studies, we reported evidence indicating that static type systems acted as a form of implicit documentation, benefiting developer productivity. Such implicit documentation is easier to maintain, given it is enforced by the compiler, but previous experiments tested users without any explicit documentation. In this paper, we report on a controlled experiment and an exploratory study comparing the impact of using documentation and a static or dynamic type system on a development task. Results of our study both confirm previous findings and show that the benefits of static typing are strengthened with explicit documentation, but that this was not as strongly felt with dynamically typed languages.

Aspect-oriented programming (AOP) is commonly assumed to be a technique which improves the resulting software with respect to modularity. However, previous empirical experiments suggest that AOP is with respect to development or maintenance time either a technique without a measurable benefit or a technique with a measurable negative effect. A possible reason why previous experiments were not able to show such a benefit is, that those experiments did not consider situations where AOP has its strength: situations where modules need to be frequently changed. In those situations AOP might be able to compensate a possible higher initial development effort. This paper describes an empirical, socio-technical study with Java and AspectJ where developers needed to perform changes on their code base multiple times. It shows that frequent changes in the crosscutting code which do not change the concern's underlying structure compensate an initial higher development time for those concerns. But it also shows that changes, which do alter the concern's structure again result in higher development times when using AOP.