DOCSLIB.ORG

Evalua Ng Clojure Spec

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Evalua Ng Clojure Spec Linköping University | Department of Computer and Information Science Master thesis, 30 ECTS | Computer Science 2017 | LIU-IDA/LITH-EX-A--17/043--SE Evaluang Clojure Spec Utvärdering av Clojure Spec Chrisan Luckey Supervisor : Bernhard Thiele Examiner : Christoph Kessler External supervisor : Rasmus Svensson Linköpings universitet SE–581 83 Linköping +46 13 28 10 00 , www.liu.se Upphovsrä Dea dokument hålls llgängligt på Internet – eller dess framda ersäare – under 25 år från pub- liceringsdatum under förutsäning a inga extraordinära omständigheter uppstår. Tillgång ll doku- mentet innebär llstånd för var och en a läsa, ladda ner, skriva ut enstaka kopior för enskilt bruk och a använda det oförändrat för ickekommersiell forskning och för undervisning. Överföring av upphovsräen vid en senare dpunkt kan inte upphäva dea llstånd. All annan användning av doku- mentet kräver upphovsmannens medgivande. För a garantera äktheten, säkerheten och llgäng- ligheten finns lösningar av teknisk och administrav art. Upphovsmannens ideella rä innefaar rä a bli nämnd som upphovsman i den omfaning som god sed kräver vid användning av dokumentet på ovan beskrivna sä samt skydd mot a dokumentet ändras eller presenteras i sådan form eller i så- dant sammanhang som är kränkande för upphovsmannenslierära eller konstnärliga anseende eller egenart. För yerligare informaon om Linköping University Electronic Press se förlagets hemsida hp://www.ep.liu.se/. Copyright The publishers will keep this document online on the Internet – or its possible replacement – for a period of 25 years starng from the date of publicaon barring exceponal circumstances. The online availability of the document implies permanent permission for anyone to read, to download, or to print out single copies for his/hers own use and to use it unchanged for non-commercial research and educaonal purpose. Subsequent transfers of copyright cannot revoke this permission. All other uses of the document are condional upon the consent of the copyright owner. The publisher has taken technical and administrave measures to assure authencity, security and accessibility. According to intellectual property law the author has the right to be menoned when his/her work is accessed as described above and to be protected against infringement. For addional informaon about the Linköping University Electronic Press and its procedures for publicaon and for assurance of document integrity, please refer to its www home page: hp://www.ep.liu.se/. © Chrisan Luckey ABSTRACT The objective of this thesis is to evaluate whether or not Clojure Spec meets the goals it sets out to meet with regards to easy data validation, performance and automatically generated tests in comparison to existing specification systems in the Clojure ecosystem. A specification for a real-world data format was implemented in the three currently popular spec- ification systems used in Clojure. They were then compared on merits in terms of performance, code size and additional capabilities. The results show that Spec shines with complex data, both in expressivity and validation perfor- mance, but has an API more complex than its competitors. For complex enough use cases where expressing regular data structures and generative testing is desired the time investment of learn- ing Spec pays off, in simpler situations an assertions library like Truss can be recommended. iv I want to thank my mother and father without whom I wouldn’t be here. v Contents Abstract iii Acknowledgments v Contents vi List of Figures viii List of Tables ix 1 Introduction 3 1.1 The objectives of Spec . 3 1.2 Aim . 4 1.3 Questions . 4 1.4 Scope . 5 2 Background 7 2.1 Definitions . 7 2.2 Code complexity and quality . 9 2.3 Related work . 11 2.4 Introduction to Clojure . 12 2.5 Introduction to Spec, Schema and Truss . 15 3 Method 23 3.1 Pre-study . 23 3.2 Data selection . 25 3.3 Filtering test data . 27 3.4 Writing specifications . 27 3.5 Benchmarking . 27 3.6 Effort reduction . 28 3.7 Edge cases . 28 4 Results 29 4.1 Effort reduction . 29 4.2 Performance . 30 vi 4.3 Edge cases . 33 4.4 Criteria comparison . 33 4.5 Generating data from Clojure Spec . 34 5 Discussion 37 5.1 Method . 37 5.2 Results . 39 5.3 Writing specifications . 41 5.4 In a wider context . 52 6 Conclusion 53 Bibliography 56 A Statistical results from generating data with Spec 57 B Validation time broken down by keyword per system 61 C Validation time broken down by keyword grouped by system 67 vii List of Figures 4.1 Project file validation time summary . 31 4.2 Validation time broken down by whether the tested data is valid or not. 32 5.1 Validation time comparison for boolean value in a map. 40 5.2 Validation time for a dependency vector. 40 5.3 Validation time for a value with multiple options. 40 B.1 Validation time broken down by keyword for Truss . 62 B.2 Validation time broken down by keyword for Spec . 63 B.3 Validation time broken down by keyword for Schema . 64 B.4 Validation time broken down by keyword for plain Clojure validation . 65 C.1 Validation time by all systems for keys :aliases to :exclusions . 68 C.2 Validation time by all systems for keys :filespecs to :main . 69 C.3 Validation time by all systems for keys :managed-dependencies to :release-tasks . 70 C.4 Validation time by all systems for keys :repl-options to :warn-on-reflection . 71 viii List of Tables 3.1 Downloads from Clojars per library. 25 3.2 Number of projects on Clojars that depend on the given library. 25 4.1 SLOC per specification implementation. 29 4.2 Statistical measures in ms for validation of project files. 31 4.3 Criteria comparison: Xmeans full, d partial and 7 no support. 34 4.4 Generation time in milliseconds from spec. 35 5.1 Feature comparison: Xmeans full, d partial and 7 no support. 41 ix 1 Introduction Clojure Spec is an upcoming standard library of the programming language Clojure [48] for specifying the functionality of programs and the nature of data. It allows the programmer to describe the structure and contents of data held in any combination of Closure’s data structures as well as that given to and returned from functions and macros. It also allows for the relation between the data given to and returned from a function or macro to be expressed. These specifications can then be used for data validation, higher level parsing, generative testing as well as to provide improved documentation and error messaging. This work seeks to evaluate Clojure Spec in comparison to other competing specification systems as well as plain, normal Clojure code. 1.1 The objectives of Spec Introduced in May 2016, but as of July 2017 yet to see a stable release, Spec seeks [10] to fill a lot of gaps in the Clojure ecosystem by: • Documenting functions, macros, keywords, lists, arrays, maps and sets for both program- matic and human consumption. • Reporting errors1 on the parsing and destructuring of data. • Providing run time data validation. • Automatic destructuring and parsing. • Generating property based tests. 1Error messages being hard to understand has been the prime reason given by potential users of Clojure as to why they are not currently using Clojure, according to the Clojure survey. [44] [45] 3 1. Introduction • Generating test data for these tests. Some of the terms used above are described further in the Definitions section. The specifications themselves are available at application run time, including test time. They are not intended as mathematical proofs like those which type systems provide [10], although such applications exist2; instead the intention is to provide an environment where arbitrary validation of run time data is not only possible but easy to perform. 1.2 Aim The aim of this thesis is to try to evaluate whether Clojure Spec succeeds in achieving some of the goals outlined in section 1.1. We do this partly through a measurement of time consumed in validating a real-world data set but also through measures of code quality and criteria based evaluation. 1.2.1 Classifying this study Stol and Fitzgerald write in their “Holistic Overview of Software Engineering Research Strategies” [46] that “terminology is a challenge in research methodology, that there is no commonly adopted taxonomy to describe such”. Nevertheless, some key words as defined in their paper describes the approach of this study. This thesis describes primary, quantitative and qualitative, desk research. It is a field study, an exploratory case study. The target of the study is the common ways of implementing specifications in the Clojure ecosystem. 1.3 Questions The question asked in this paper is: To what degree and at what cost are the goals of Spec achieved? Specifically: (1) How does the code of Spec specifications compare to equivalent code in competing systems, both in terms of plain SLOC and convenience of expression? (2) How does Spec perform in real-world benchmarks compared to competing systems? (3) To which degree does Spec expose issues in data or functions not found by competing systems, if at all? The competing systems to Clojure Spec were deemed to be the existing data specification or assertion systems Schema [39] and Truss [5], and to not use any library at all. A specification for the project declaration file of the highly popular build, project and depen- dency management tool Leiningen was produced using each system and compared to each other with regards to the research questions. A comparison was also made using the criteria of related work. 2The third party library Spectrum [43] uses Spec as the basis for a static type system.
Load more

Recommended publications
  • Programming Languages
    Programming Languages Recitation Summer 2014 Recitation Leader • Joanna Gilberti • Email: [email protected] • Office: WWH, Room 328 • Web site: http://cims.nyu.edu/~jlg204/courses/PL/index.html Homework Submission Guidelines • Submit all homework to me via email (at [email protected] only) on the due date. • Email subject: “PL– homework #” (EXAMPLE: “PL – Homework 1”) • Use file naming convention on all attachments: “firstname_lastname_hw_#” (example: "joanna_gilberti_hw_1") • In the case multiple files are being submitted, package all files into a ZIP file, and name the ZIP file using the naming convention above. What’s Covered in Recitation • Homework Solutions • Questions on the homeworks • For additional questions on assignments, it is best to contact me via email. • I will hold office hours (time will be posted on the recitation Web site) • Run sample programs that demonstrate concepts covered in class Iterative Languages Scoping • Sample Languages • C: static-scoping • Perl: static and dynamic-scoping (use to be only dynamic scoping) • Both gcc (to run C programs), and perl (to run Perl programs) are installed on the cims servers • Must compile the C program with gcc, and then run the generated executable • Must include the path to the perl executable in the perl script Basic Scope Concepts in C • block scope (nested scope) • run scope_levels.c (sl) • ** block scope: set of statements enclosed in braces {}, and variables declared within a block has block scope and is active and accessible from its declaration to the end of the block
    [Show full text]
  • Preview Objective-C Tutorial (PDF Version)
    Objective-C Objective-C About the Tutorial Objective-C is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. This is the main programming language used by Apple for the OS X and iOS operating systems and their respective APIs, Cocoa and Cocoa Touch. This reference will take you through simple and practical approach while learning Objective-C Programming language. Audience This reference has been prepared for the beginners to help them understand basic to advanced concepts related to Objective-C Programming languages. Prerequisites Before you start doing practice with various types of examples given in this reference, I'm making an assumption that you are already aware about what is a computer program, and what is a computer programming language? Copyright & Disclaimer © Copyright 2015 by Tutorials Point (I) Pvt. Ltd. All the content and graphics published in this e-book are the property of Tutorials Point (I) Pvt. Ltd. The user of this e-book can retain a copy for future reference but commercial use of this data is not allowed. Distribution or republishing any content or a part of the content of this e-book in any manner is also not allowed without written consent of the publisher. We strive to update the contents of our website and tutorials as timely and as precisely as possible, however, the contents may contain inaccuracies or errors. Tutorials Point (I) Pvt. Ltd. provides no guarantee regarding the accuracy, timeliness or completeness of our website or its contents including this tutorial. If you discover any errors on our website or in this tutorial, please notify us at [email protected] ii Objective-C Table of Contents About the Tutorial ..................................................................................................................................
    [Show full text]
  • Chapter 5 Names, Bindings, and Scopes
    Chapter 5 Names, Bindings, and Scopes 5.1 Introduction 198 5.2 Names 199 5.3 Variables 200 5.4 The Concept of Binding 203 5.5 Scope 211 5.6 Scope and Lifetime 222 5.7 Referencing Environments 223 5.8 Named Constants 224 Summary • Review Questions • Problem Set • Programming Exercises 227 CMPS401 Class Notes (Chap05) Page 1 / 20 Dr. Kuo-pao Yang Chapter 5 Names, Bindings, and Scopes 5.1 Introduction 198 Imperative languages are abstractions of von Neumann architecture – Memory: stores both instructions and data – Processor: provides operations for modifying the contents of memory Variables are characterized by a collection of properties or attributes – The most important of which is type, a fundamental concept in programming languages – To design a type, must consider scope, lifetime, type checking, initialization, and type compatibility 5.2 Names 199 5.2.1 Design issues The following are the primary design issues for names: – Maximum length? – Are names case sensitive? – Are special words reserved words or keywords? 5.2.2 Name Forms A name is a string of characters used to identify some entity in a program. Length – If too short, they cannot be connotative – Language examples: . FORTRAN I: maximum 6 . COBOL: maximum 30 . C99: no limit but only the first 63 are significant; also, external names are limited to a maximum of 31 . C# and Java: no limit, and all characters are significant . C++: no limit, but implementers often impose a length limitation because they do not want the symbol table in which identifiers are stored during compilation to be too large and also to simplify the maintenance of that table.
    [Show full text]
  • Introduction to Programming in Lisp
    Introduction to Programming in Lisp Supplementary handout for 4th Year AI lectures · D W Murray · Hilary 1991 1 Background There are two widely used languages for AI, viz. Lisp and Prolog. The latter is the language for Logic Programming, but much of the remainder of the work is programmed in Lisp. Lisp is the general language for AI because it allows us to manipulate symbols and ideas in a commonsense manner. Lisp is an acronym for List Processing, a reference to the basic syntax of the language and aim of the language. The earliest list processing language was in fact IPL developed in the mid 1950’s by Simon, Newell and Shaw. Lisp itself was conceived by John McCarthy and students in the late 1950’s for use in the newly-named field of artificial intelligence. It caught on quickly in MIT’s AI Project, was implemented on the IBM 704 and by 1962 to spread through other AI groups. AI is still the largest application area for the language, but the removal of many of the flaws of early versions of the language have resulted in its gaining somewhat wider acceptance. One snag with Lisp is that although it started out as a very pure language based on mathematic logic, practical pressures mean that it has grown. There were many dialects which threaten the unity of the language, but recently there was a concerted effort to develop a more standard Lisp, viz. Common Lisp. Other Lisps you may hear of are FranzLisp, MacLisp, InterLisp, Cambridge Lisp, Le Lisp, ... Some good things about Lisp are: • Lisp is an early example of an interpreted language (though it can be compiled).
    [Show full text]
  • Algorithms and Data Structures Lecture 11: Symbol Table ADT
    cs2010: algorithms and data structures Lecture 11: Symbol Table ADT Vasileios Koutavas School of Computer Science and Statistics Trinity College Dublin Algorithms ROBERT SEDGEWICK | KEVIN WAYNE 3.1 SYMBOL TABLES ‣ API ‣ elementary implementations Algorithms ‣ ordered operations FOURTH EDITION ROBERT SEDGEWICK | KEVIN WAYNE http://algs4.cs.princeton.edu 3.1 SYMBOL TABLES ‣ API ‣ elementary implementations Algorithms ‣ ordered operations ROBERT SEDGEWICK | KEVIN WAYNE http://algs4.cs.princeton.edu Symbol tables Key-value pair abstraction. ・Insert a value with specified key. ・Given a key, search for the corresponding value. Ex. DNS lookup. ・Insert domain name with specified IP address. ・Given domain name, find corresponding IP address. domain name IP address www.cs.princeton.edu 128.112.136.11 www.princeton.edu 128.112.128.15 www.yale.edu 130.132.143.21 www.harvard.edu 128.103.060.55 www.simpsons.com 209.052.165.60 key value 3 Symbol table applications application purpose of search key value dictionary find definition word definition book index find relevant pages term list of page numbers file share find song to download name of song computer ID financial account process transactions account number transaction details web search find relevant web pages keyword list of page names compiler find properties of variables variable name type and value routing table route Internet packets destination best route DNS find IP address domain name IP address reverse DNS find domain name IP address domain name genomics find markers DNA string known positions file system find file on disk filename location on disk 4 Symbol tables: context Also known as: maps, dictionaries, associative arrays.
    [Show full text]
  • Scope in Fortran 90
    Scope in Fortran 90 The scope of objects (variables, named constants, subprograms) within a program is the portion of the program in which the object is visible (can be use and, if it is a variable, modified). It is important to understand the scope of objects not only so that we know where to define an object we wish to use, but also what portion of a program unit is effected when, for example, a variable is changed, and, what errors might occur when using identifiers declared in other program sections. Objects declared in a program unit (a main program section, module, or external subprogram) are visible throughout that program unit, including any internal subprograms it hosts. Such objects are said to be global. Objects are not visible between program units. This is illustrated in Figure 1. Figure 1: The figure shows three program units. Main program unit Main is a host to the internal function F1. The module program unit Mod is a host to internal function F2. The external subroutine Sub hosts internal function F3. Objects declared inside a program unit are global; they are visible anywhere in the program unit including in any internal subprograms that it hosts. Objects in one program unit are not visible in another program unit, for example variable X and function F3 are not visible to the module program unit Mod. Objects in the module Mod can be imported to the main program section via the USE statement, see later in this section. Data declared in an internal subprogram is only visible to that subprogram; i.e.
    [Show full text]
  • Programming Language Concepts/Binding and Scope
    Programming Language Concepts/Binding and Scope Programming Language Concepts/Binding and Scope Onur Tolga S¸ehito˘glu Bilgisayar M¨uhendisli˘gi 11 Mart 2008 Programming Language Concepts/Binding and Scope Outline 1 Binding 6 Declarations 2 Environment Definitions and Declarations 3 Block Structure Sequential Declarations Monolithic block structure Collateral Declarations Flat block structure Recursive declarations Nested block structure Recursive Collateral Declarations 4 Hiding Block Expressions 5 Static vs Dynamic Scope/Binding Block Commands Static binding Block Declarations Dynamic binding 7 Summary Programming Language Concepts/Binding and Scope Binding Binding Most important feature of high level languages: programmers able to give names to program entities (variable, constant, function, type, ...). These names are called identifiers. Programming Language Concepts/Binding and Scope Binding Binding Most important feature of high level languages: programmers able to give names to program entities (variable, constant, function, type, ...). These names are called identifiers. definition of an identifier ⇆ used position of an identifier. Formally: binding occurrence ⇆ applied occurrence. Programming Language Concepts/Binding and Scope Binding Binding Most important feature of high level languages: programmers able to give names to program entities (variable, constant, function, type, ...). These names are called identifiers. definition of an identifier ⇆ used position of an identifier. Formally: binding occurrence ⇆ applied occurrence. Identifiers are declared once, used n times. Programming Language Concepts/Binding and Scope Binding Binding Most important feature of high level languages: programmers able to give names to program entities (variable, constant, function, type, ...). These names are called identifiers. definition of an identifier ⇆ used position of an identifier. Formally: binding occurrence ⇆ applied occurrence. Identifiers are declared once, used n times.
    [Show full text]
  • Names, Scopes, and Bindings (Cont.)
    Chapter 3:: Names, Scopes, and Bindings (cont.) Programming Language Pragmatics Michael L. Scott Copyright © 2005 Elsevier Review • What is a regular expression ? • What is a context-free grammar ? • What is BNF ? • What is a derivation ? • What is a parse ? • What are terminals/non-terminals/start symbol ? • What is Kleene star and how is it denoted ? • What is binding ? Copyright © 2005 Elsevier Review • What is early/late binding with respect to OOP and Java in particular ? • What is scope ? • What is lifetime? • What is the “general” basic relationship between compile time/run time and efficiency/flexibility ? • What is the purpose of scope rules ? • What is central to recursion ? Copyright © 2005 Elsevier 1 Lifetime and Storage Management • Maintenance of stack is responsibility of calling sequence and subroutine prolog and epilog – space is saved by putting as much in the prolog and epilog as possible – time may be saved by • putting stuff in the caller instead or • combining what's known in both places (interprocedural optimization) Copyright © 2005 Elsevier Lifetime and Storage Management • Heap for dynamic allocation Copyright © 2005 Elsevier Scope Rules •A scope is a program section of maximal size in which no bindings change, or at least in which no re-declarations are permitted (see below) • In most languages with subroutines, we OPEN a new scope on subroutine entry: – create bindings for new local variables, – deactivate bindings for global variables that are re- declared (these variable are said to have a "hole" in their
    [Show full text]
  • Class 15: Implementing Scope in Function Calls
    Class 15: Implementing Scope in Function Calls SI 413 - Programming Languages and Implementation Dr. Daniel S. Roche United States Naval Academy Fall 2011 Roche (USNA) SI413 - Class 15 Fall 2011 1 / 10 Implementing Dynamic Scope For dynamic scope, we need a stack of bindings for every name. These are stored in a Central Reference Table. This primarily consists of a mapping from a name to a stack of values. The Central Reference Table may also contain a stack of sets, each containing identifiers that are in the current scope. This tells us which values to pop when we come to an end-of-scope. Roche (USNA) SI413 - Class 15 Fall 2011 2 / 10 Example: Central Reference Tables with Lambdas { new x := 0; new i := -1; new g := lambda z{ ret :=i;}; new f := lambda p{ new i :=x; i f (i>0){ ret :=p(0); } e l s e { x :=x + 1; i := 3; ret :=f(g); } }; w r i t e f( lambda y{ret := 0}); } What gets printed by this (dynamically-scoped) SPL program? Roche (USNA) SI413 - Class 15 Fall 2011 3 / 10 (dynamic scope, shallow binding) (dynamic scope, deep binding) (lexical scope) Example: Central Reference Tables with Lambdas The i in new g := lambda z{ w r i t e i;}; from the previous program could be: The i in scope when the function is actually called. The i in scope when g is passed as p to f The i in scope when g is defined Roche (USNA) SI413 - Class 15 Fall 2011 4 / 10 Example: Central Reference Tables with Lambdas The i in new g := lambda z{ w r i t e i;}; from the previous program could be: The i in scope when the function is actually called.
    [Show full text]
  • Javascript Scope Lab Solution Review (In-Class) Remember That Javascript Has First-Class Functions
    C152 – Programming Language Paradigms Prof. Tom Austin, Fall 2014 JavaScript Scope Lab Solution Review (in-class) Remember that JavaScript has first-class functions. function makeAdder(x) { return function (y) { return x + y; } } var addOne = makeAdder(1); console.log(addOne(10)); Warm up exercise: Create a makeListOfAdders function. input: a list of numbers returns: a list of adders function makeListOfAdders(lst) { var arr = []; for (var i=0; i<lst.length; i++) { var n = lst[i]; arr[i] = function(x) { return x + n; } } return arr; } Prints: 121 var adders = 121 makeListOfAdders([1,3,99,21]); 121 adders.forEach(function(adder) { 121 console.log(adder(100)); }); function makeListOfAdders(lst) { var arr = []; for (var i=0; i<lst.length; i++) { arr[i]=function(x) {return x + lst[i];} } return arr; } Prints: var adders = NaN makeListOfAdders([1,3,99,21]); NaN adders.forEach(function(adder) { NaN console.log(adder(100)); NaN }); What is going on in this wacky language???!!! JavaScript does not have block scope. So while you see: for (var i=0; i<lst.length; i++) var n = lst[i]; the interpreter sees: var i, n; for (i=0; i<lst.length; i++) n = lst[i]; In JavaScript, this is known as variable hoisting. Faking block scope function makeListOfAdders(lst) { var i, arr = []; for (i=0; i<lst.length; i++) { (function() { Function creates var n = lst[i]; new scope arr[i] = function(x) {return x + n;} })(); } return arr; } A JavaScript constructor name = "Monty"; function Rabbit(name) { this.name = name; } var r = Rabbit("Python"); Forgot new console.log(r.name);
    [Show full text]
  • First-Class Functions
    Chapter 6 First-Class Functions We began Section 4 by observing the similarity between a with expression and a function definition applied immediately to a value. Specifically, we observed that {with {x 5} {+ x 3}} is essentially the same as f (x) = x + 3; f (5) Actually, that’s not quite right: in the math equation above, we give the function a name, f , whereas there is no identifier named f anywhere in the WAE program. We can, however, rewrite the mathematical formula- tion as f = λ(x).x + 3; f (5) which we can then rewrite as (λ(x)x + 3)(5) to get rid of the unnecessary name ( f ). That is, with effectively creates a new anonymous function and immediately applies it to a value. Because functions are useful in their own right, we may want to separate the act of function declaration or definition from invocation or application (indeed, we might want to apply the same function multiple times). That is what we will study now. 6.1 A Taxonomy of Functions The translation of with into mathematical notation exploits two features of functions: the ability to cre- ate anonymous functions, and the ability to define functions anywhere in the program (in this case, in the function position of an application). Not every programming language offers one or both of these capabili- ties. There is, therefore, a standard taxonomy that governs these different features, which we can use when discussing what kind of functions a language provides: first-order Functions are not values in the language. They can only be defined in a designated portion of the program, where they must be given names for use in the remainder of the program.
    [Show full text]
  • A History of Clojure
    A History of Clojure RICH HICKEY, Cognitect, Inc., USA Shepherd: Mira Mezini, Technische Universität Darmstadt, Germany Clojure was designed to be a general-purpose, practical functional language, suitable for use by professionals wherever its host language, e.g., Java, would be. Initially designed in 2005 and released in 2007, Clojure is a dialect of Lisp, but is not a direct descendant of any prior Lisp. It complements programming with pure functions of immutable data with concurrency-safe state management constructs that support writing correct multithreaded programs without the complexity of mutex locks. Clojure is intentionally hosted, in that it compiles to and runs on the runtime of another language, such as the JVM. This is more than an implementation strategy; numerous features ensure that programs written in Clojure can leverage and interoperate with the libraries of the host language directly and efficiently. In spite of combining two (at the time) rather unpopular ideas, functional programming and Lisp, Clojure has since seen adoption in industries as diverse as finance, climate science, retail, databases, analytics, publishing, healthcare, advertising and genomics, and by consultancies and startups worldwide, much to the career-altering surprise of its author. Most of the ideas in Clojure were not novel, but their combination puts Clojure in a unique spot in language design (functional, hosted, Lisp). This paper recounts the motivation behind the initial development of Clojure and the rationale for various design decisions and language constructs. It then covers its evolution subsequent to release and adoption. CCS Concepts: • Software and its engineering ! General programming languages; • Social and pro- fessional topics ! History of programming languages.
    [Show full text]