Models and languages for parallel computation
ACM Computing Surveys (CSUR)
An algorithm for design rule checking on a multiprocessor
DAC '85 Proceedings of the 22nd ACM/IEEE Design Automation Conference
Effective Java programming language guide
Effective Java programming language guide
Parallel Programmer Productivity: A Case Study of Novice Parallel Programmers
SC '05 Proceedings of the 2005 ACM/IEEE conference on Supercomputing
Software engineering for multicore systems: an experience report
Proceedings of the 1st international workshop on Multicore software engineering
Patterns for parallel programming
Patterns for parallel programming
Guidelines for conducting and reporting case study research in software engineering
Empirical Software Engineering
The Art of Multiprocessor Programming
The Art of Multiprocessor Programming
ECOOP'07 Proceedings of the 2007 conference on Object-oriented technology
Using functional programming within an industrial product group: perspectives and perceptions
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
ACM SIGPLAN Commercial Users of Functional Programming
Guide to Advanced Empirical Software Engineering
Guide to Advanced Empirical Software Engineering
Basics of Software Engineering Experimentation
Basics of Software Engineering Experimentation
A study of transactional memory vs. locks in practice
Proceedings of the twenty-third annual ACM symposium on Parallelism in algorithms and architectures
Does adding manpower also affect quality?: an empirical, longitudinal analysis
Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering
A note on rigour and replicability
ACM SIGSOFT Software Engineering Notes
Reactive behavior in object-oriented applications: an analysis and a research roadmap
Proceedings of the 12th annual international conference on Aspect-oriented software development
LAMBDAFICATOR: from imperative to functional programming through automated refactoring
Proceedings of the 2013 International Conference on Software Engineering
Crossing the gap from imperative to functional programming through refactoring
Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering
Why do scala developers mix the actor model with other concurrency models?
ECOOP'13 Proceedings of the 27th European conference on Object-Oriented Programming
Hi-index | 0.00 |
Recent multi-paradigm programming languages combine functional and imperative programming styles to make software development easier. Given today's proliferation of multicore processors, parallel programmers are supposed to benefit from this combination, as many difficult problems can be expressed more easily in a functional style while others match an imperative style. Due to a lack of empirical evidence from controlled studies, however, important software engineering questions are largely unanswered. Our paper is the first to provide thorough empirical results by using Scala and Java as a vehicle in a controlled comparative study on multicore software development. Scala combines functional and imperative programming while Java focuses on imperative shared-memory programming. We study thirteen programmers who worked on three projects, including an industrial application, in both Scala and Java. In addition to the resulting 39 Scala programs and 39 Java programs, we obtain data from an industry software engineer who worked on the same project in Scala. We analyze key issues such as effort, code, language usage, performance, and programmer satisfaction. Contrary to popular belief, the functional style does not lead to bad performance. Average Scala run-times are comparable to Java, lowest run-times are sometimes better, but Java scales better on parallel hardware. We confirm with statistical significance Scala's claim that Scala code is more compact than Java code, but clearly refute other claims of Scala on lower programming effort and lower debugging effort. Our study also provides explanations for these observations and shows directions on how to improve multi-paradigm languages in the future.