Julia: dynamism and performance reconciled by design

Abstract

Julia is a programming language for the scientific community that combines features of productivity languages, such as Python or MATLAB, with characteristics of performance-oriented languages, such as C++ or Fortran. Julia's productivity features include: dynamic typing, automatic memory management, rich type annotations, and multiple dispatch. At the same time, Julia allows programmers to control memory layout and leverages a specializing just-in-time compiler to eliminate much of the overhead of those features. This paper details the design choices made by the creators of Julia and reflects on the implications of those choices for performance and usability.

References

1. Alexander Aiken and Edward L. Wimmers. 1993. Type Inclusion Constraints and Type Inference. In Conference on Functional Programming Languages and Computer Architecture (FPCA).
2. Eric Allen, Justin Hilburn, Scott Kilpatrick, Victor Luchangco, Sukyoung Ryu, David Chase, and Guy Steele. 2011. Type Checking Modular Multiple Dispatch with Parametric Polymorphism and Multiple Inheritance. In Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA).
3. Todd A. Anderson, Hai Liu, Lindsey Kuper, Ehsan Totoni, Jan Vitek, and Tatiana Shpeisman. 2017. Parallelizing Julia with a Non-Invasive DSL. In European Conference on Object-Oriented Programming (ECOOP).
4. Jeff Bezanson, Alan Edelman, Stefan Karpinski, and Viral B. Shah. 2017. Julia: A Fresh Approach to Numerical Computing. SIAM Rev. 59, 1 (2017).
5. Bard Bloom, John Field, Nathaniel Nystrom, Johan Östlund, Gregor Richards, Rok Strnisa, Jan Vitek, and Tobias Wrigstad. 2009. Thorn: Robust, Concurrent, Extensible Scripting on the JVM. In Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA).
6. Daniel G. Bobrow, Kenneth Kahn, Gregor Kiczales, Larry Masinter, Mark Stefik, and Frank Zdybel. 1986. CommonLoops: Merging Lisp and Object-oriented Programming. In Conference on Object-oriented Programming Systems, Languages and Applications (OOPSLA).
7. John Chambers. 2014. Object-Oriented Programming, Functional Programming and R. Statist. Sci. 2 (2014). Issue 29.
8. Philippe Charles, Christian Grothoff, Vijay Saraswat, Christopher Donawa, Allan Kielstra, Kemal Ebcioglu, Christoph von Praun, and Vivek Sarkar. 2005. X10: An Object-oriented Approach to Non-uniform Cluster Computing. (2005).
9. Avik Chaudhuri, Panagiotis Vekris, Sam Goldman, Marshall Roch, and Gabriel Levi. 2017. Fast and Precise Type Checking for JavaScript. Proc. ACM Program. Lang. 1, OOPSLA, Article 48 (Oct. 2017),
10. Maxime Chevalier-Boisvert, Laurie J. Hendren, and Clark Verbrugge. 2010. Optimizing Matlab through Just-In-Time Specialization. In Conference on Compiler Construction (CC).
11. Benjamin Chung and Paley Li. 2017. Towards Typing Julia. In The -2th Workshop on New Object-Oriented Languages (NOOL).
12. Luiz De Rose and David Padua. 1999. Techniques for the Translation of MATLAB Programs into Fortran 90. ACM Trans. Program. Lang. Syst. 21, 2 (March 1999).
13. Linda DeMichiel and Richard Gabriel. 1987. The Common Lisp Object System: An Overview. In European Conference on Object-Oriented Programming (ECOOP).
14. Facebook. 2016. Hack. (2016). http://hacklang.org .
15. Mike Fagan. 1991. Soft typing: an approach to type checking for dynamically typed languages. Ph.D. Dissertation. Rice University.
16. Alain Frisch, Giuseppe Castagna, and Véronique Benzaken. 2002. Semantic Subtyping. In Symposium on Logic in Computer Science (LICS).
17. Miguel Garcia, Francisco Ortin, and Jose Quiroga. 2016. Design and Implementation of an Efficient Hybrid Dynamic and Static Typing Language. Softw. Pract. Exper. 46, 2 (Feb. 2016),
18. Isaac Gouy. 2018. The Computer Language Benchmarks Game. (2018). https://benchmarksgame-team.pages.debian.net/ benchmarksgame
19. Brian Hackett and Shu-yu Guo. 2012. Fast and Precise Hybrid Type Inference for JavaScript. (2012),
20. Urs Hölzle and David Ungar. 1994. Optimizing Dynamically-dispatched Calls with Run-time Type Feedback. In Conference on Programming Language Design and Implementation (PLDI).
21. Tomas Kalibera, Petr Maj, Floreal Morandat, and Jan Vitek. 2014. A Fast Abstract Syntax Tree Interpreter for R. In Conference on Virtual Execution Environments (VEE).
22. Chris Lattner and Vikram Adve. 2004. LLVM: A Compilation Framework for Lifelong Program Analysis and Transformation. In Symposium on Code Generation and Optimization (CGO).
23. Vassily Litvinov. 1998. Constraint-based Polymorphism in Cecil: Towards a Practical and Static Type System. In Addendum to Conference on Object-oriented Programming, Systems, Languages, and Applications (OOPSLA Addendum).
24. Francesco Logozzo and Herman Venter. 2010. RATA: Rapid Atomic Type Analysis by Abstract Interpretation – Application to JavaScript Optimization. In Compiler Construction (CC),
25. Miles Lubin and Iain Dunning. 2013. Computing in Operations Research using Julia. In INFORMS Journal on Computing.
26. MATLAB. 2018. version 9.4. The MathWorks Inc., Natick, Massachusetts.
27. Microsoft. 2016. TypeScript – Language Specification. (2016).
28. Radu Muschevici, Alex Potanin, Ewan Tempero, and James Noble. 2008. Multiple Dispatch in Practice. In Conference on Object-oriented Programming Systems Languages and Applications (OOPSLA).
29. Michael Paleczny, Christopher Vick, and Cliff Click. 2001. The Java HotSpot Server Compiler. In Symposium on Java Virtual Machine Research and Technology (JVM). http://dl.acm.org/citation.cfm?id=1267847.1267848
30. R Core Team. 2008. R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing. http://www.R-project.org
31. Allison Randal, Dan Sugalski, and Leopold Toetsch. 2003. Perl 6 and Parrot Essentials. O’Reilly.
32. Olin Shivers. 1990. Data-flow Analysis and Type Recovery in Scheme. In Topics in Advanced Language Implementation. MIT Press.
33. Jeremy Siek. 2006. Gradual Typing for Functional Languages. In Scheme and Functional Programming Workshop. http: //ecee.colorado.edu/~siek/pubs/pubs/2006/siek06_gradual.pdf .
34. Guy Steele, Eric Allen, David Chase, Christine Flood, Victor Luchangco, Jan-Willem Maessen, and Sukyoung Ryu. 2011. Fortress (Sun HPCS Language). In Encyclopedia of Parallel Computing.
35. Justin Talbot, Zachary DeVito and Pat Hanrahan. 2012. Riposte: A trace-driven compiler and parallel VM for vector code in R. In International Conference on Parallel Architectures and Compilation Techniques (PACT).
36. Sam Tobin-Hochstadt and Matthias Felleisen. 2006. Interlanguage migration: from scripts to programs. In Symposium on Dynamic languages (DLS).
37. Sam Tobin-Hochstadt and Matthias Felleisen. 2008. The design and implementation of typed Scheme. In Symposium on Principles of Programming Languages (POPL).
38. Andrew Wright and Robert Cartwright. 1994. A practical soft type system for Scheme. In ACM SIGPLAN Lisp Pointers, Vol. 7.
39. Thomas Würthinger, Christian Wimmer, Andreas Wöß, Lukas Stadler, Gilles Duboscq, Christian Humer, Gregor Richards, Doug Simon, and Mario Wolczko. 2013. One VM to Rule Them All. In Symposium on New Ideas, New Paradigms, and Reflections on Programming & Software (Onward!).
40. Francesco Zappa Nardelli, Julia Belyakova, Artem Pelenitsyn, Benjamin Chung, Jeff Bezanson, and Jan Vitek. 2018. Julia Subtyping: A Rational Reconstruction. Proc. ACM Program. Lang. 2, OOPSLA (2018).

Index Terms

• Software and its engineering

  • Software notations and tools

    • Compilers

      • Just-in-time compilers

    • General programming languages

      • Language features

      • Language types

        • Multiparadigm languages