DOCSLIB.ORG

Symbolics Common Lisp Language Concepts Requesting User: Genera Billing Info: {Job-Billing}

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Symbolics Common Lisp Language Concepts Requesting User: Genera Billing Info: {Job-Billing} Job ID: printopdf-20 Title: Symbolics Common Lisp Language Concepts Requesting User: genera Billing Info: {job-billing} UNIX asy Printing E System S oftware C P roducts SymbolicsCommonLispLanguageConcepts OrganizationofSymbolicsCommonLispDocumentation Symbolics Common Lisp (SCL) is the Symbolics implementation of the Lisp lan guage. Lisp is a powerful and complex tool that can be used at many levels, by people with widely varying programming experience. SCL is therefore intended to serve a user spectrum that ranges from the novice programmer to the experienced Lisp developer.These two factsmotivate the organization of this documentation in toseveralparts,eachreflectingadifferentstageoffamiliaritywithLisp. For an overview of Symbolics Common Lisp, see the section "Overview of Symbol ics Common Lisp". This section is intended primarily as a learning aid to give the new user an introduction to key SCL concepts. The Overview does not present topics in any detail. Rather, it is aimed at giving the new user a general sense of each topic, including definitions of basic terms and simple examples of important concepts.Itisdesignedtobereadsequentially,inasinglesittingifdesired. If you are unfamiliar with the Symbolics notation conventions for Lisp documenta tion,seethesection"UnderstandingNotationConventions". Your reference guide to Symbolics Common Lisp (SCL), the Symbolics implementa tionoftheLisplanguage,consistsofthefollowingvolumes: SymbolicsCommonLispLanguageConcepts Documents the basic language concepts of Lisp, including data types, type specifiers, functions and dynamic closures, inline functions and macros, eval uation,scoping,flowofcontrol,declarations,andcompatibilityissues. SymbolicsCommonLispProgrammingConstructs Documents the higherlevel programming constructs of Lisp, including structures, CLOS, Flavors, conditions, packages, and input/output facilities (including the reader, printed representation, input and output functions, andstreams). SymbolicsCommonLispDictionary An alphabetic dictionary of all Lisp objects documented in the previous two volumes. The first two volumes give a conceptual presentation of Symbolics Common Lisp, and provide indepth coverage of topics presented in the Overview. The Dictionary is the most detailed part of the documentation. This is a true dictionary of refer ence entries for all Symbolics Common Lisp symbols. Each entry provides a com plete description of a single Lisp object. For example, the entry for a given SCL function would include its syntax, what it returns, examples of its use and cross references to related functions or topics. The entries are alphabetized and thumb tabs are provided for rapid access to information about an individual symbol when you need it. Because the dictionary entries appear in alphabetical order, this vol ume of Symbolics Common Lisp is not indexed; the other volumes are fully in dexed. Page 6 UnderstandingNotationConventions You should understand several notation conventions before reading the documenta tion. LispObjects Functions AtypicaldescriptionofaLispfunctionlookslikethis: functionname arg1arg2&optionalarg3(arg4(foo3)) function Adds together arg1 and arg2, and then multiplies the result by arg3. If arg3 is not provided, the multiplication is not done. functionname returns a list whose first element is this result and whose second element is arg4. Exam ples: (functionname34)=>(74) (functionname122’bar)=>(6bar) The word "&optional" in the list of arguments tells you that all of the arguments past this point are optional. The default value of an argument can be specified ex plicitly, as with arg4, whose default value is the result of evaluating the form (foo 3). If no default value is specified, it is the symbol nil. This syntax is used in lambdalists in the language. (For more information on lambdalists, see the sec tion "Evaluating a Function Form".) Argument lists can also contain "&rest", whichispartofthesamesyntax. Note that the documentation uses several fonts, or typefaces. In a function de scription, for example, the name of the function isin boldface in the first line, and the arguments are in italics. Within the text, printed representations of Lisp ob jects are in the same boldface font, such as (+ foo 56), and argument references areitalicized,suchasarg1andarg2. Otherfontsareusedasfollows: "Typein"or"example"font(functionname) Indicates something you are expected to type. This font is also used for Lisp examples that are set off from the text and in some cases for information, such as a prompt, that appears on thescreen. "Key"font(RETURN,c-L) Forkeystrokesmentionedinrunningtext. MacrosandSpecialForms The descriptions of special forms and macros look like the descriptions of these imaginaryones: Page 7 dothreetimes form SpecialForm Evaluatesformthreetimesandreturnstheresultofthethirdevaluation. withfooboundtonil form... Macro Evaluatestheformswiththesymbolfooboundtonil.Itexpandsasfollows: (withfooboundtonil form1 form2...)==> (let((foonil)) form1 form2...) Since special forms and macros are the mechanism by which the syntax of Lisp is extended, their descriptions must describe both their syntax and their semantics; unlike functions, which follow a simple consistent set of rules, each special form is idiosyncratic. The syntax is displayed on the first line of the description using the followingconventions. • Italicized words are names of parts of the form that are referred to in the de scriptive text. They are not arguments, even though they resemble the italicized wordsinthefirstlineofafunctiondescription. • Parentheses("( )")standforthemselves. • Brackets("[ ]")indicatethatwhattheyencloseisoptional. • Ellipses ("...") indicate that the subform (italicized word or parenthesized list) that precedes them can be repeated any number of times (possibly no times at all). • Braces followed by ellipses ("{ }...") indicate that what they enclose can be re peated any number of times. Thus, the first line of the description of a special form is a "template" for what an instance of that special form would look like, withthesurroundingparenthesesremoved. The syntax of some special forms is too complicated to fit comfortably into this style; the first line of the description of such a special form contains only the name,andthesyntaxisgivenbyexampleinthebodyofthedescription. The semantics of a special form includes not only its contract, but also which sub forms are evaluated and what the returned value is. Usually this is clarified with oneormoreexamples. A convention used by many special forms is that all of their subforms after the first few are described as "body...". This means that the remaining subforms con stitute the "body" of this special form; they are Lisp forms that are evaluated one afteranotherinsomeenvironmentestablishedbythespecialform. Thisimaginaryspecialformexhibitsallofthesyntacticfeatures: Page 8 twiddlefrob [(froboption...)]{parametervalue}... SpecialForm Twiddles the parameters of frob, which defaults to defaultfrob if not speci fied. Each parameter is the name of one of the adjustable parameters of a frob; each value is what value to set that parameter to. Any number of parameter/value pairs can be specified. If any options are specified, they are keywords that select which safety checks to override while twiddling the pa rameters. If neither frob nor any options are specified, the list of them can beomittedandtheformcanbegindirectlywiththefirstparametername. frob and the values are evaluated; the parameters and options are syntactic keywords and are not evaluated. The returned value is the frob whose pa rameterswereadjusted.Anerrorissignalledifanysafetycheckisviolated. Flavors,FlavorOperations,andInitOptions Flavorsthemselvesaredocumentedbythenameoftheflavor. Flavor operations are described in three ways: as methods, as generic functions, and as messages. When it is important to show the exact flavor for which the method is defined, methods are described by their function specs. Init options are documentedbythefunctionspecofthemethod. When a method is implemented for a set of flavors (such as all streams), it is doc umentedbythenameofmessageorgenericfunctionitimplements. Thefollowingexamplesaretakenfromthedocumentation. sys:networkerror Flavor This set includes errors signalled by networks. These are generic network errors thatareuseduniformlyforanysupportednetworks.Thisflavorisbuiltonerror. (flavor:method:clearwindowtv:sheet) Method Erases the whole window and move the cursor position to the upper left corner of thewindow. :tyo char Message Puts the char into the stream. For example, if s is bound to a stream, then the followingformwilloutputa"B"tothestream: (sends:tyo#\B) For binary output streams, the argument is a nonnegative number rather than specificallyacharacter. dbg:specialcommandp conditionspecialcommand Function Page 9 Returns t if commandtype is a valid Debugger special command for this condition object;otherwise,returnsnil. Thecompatiblemessagefordbg:specialcommandpis: :specialcommandp For a table of related items,see the section "Basic Condition Methods and Init Op tions". (flavor:method:bottomtv:sheet) bottomedge InitOption Specifiestheycoordinateofthebottomedgeofthewindow. Variables Descriptionsofvariables("special"or"global"variables)looklikethis: *typicalvariable* Variable Thevariable*typicalvariable*hasatypicalvalue.... MacroCharacters Macro characters are explained in detail in the documentation. See the section "HowtheReaderRecognizesMacroCharacters". The single quote character (’) and semicolon (;)
Load more

Recommended publications
  • 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]
  • 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]
  • Genera Workbook Using This Book Preface This Is the Document To
    Genera Workbook Using This Book Preface This is the document to read when you’re ready to sit down at your Symbol- ics computer. It teaches you the initial skills you need to use the Genera system effectively. We present concepts you need to know, as well as providing exercises andactivitiesthatturnthoseconceptsintopracticalskills. The material covered in the first group of chapters in this workbook is a pre- requisite for all Symbolics Education Services Courses. However, you can com plete the second and third sections after taking your first course. Practicing the material helpsyou learn it faster. Bring this workbook to all courses you take with Symbolics. We expect that you have used a computer before; we do not expect that you have used a Symbolics computer before. You need to learn this material whether or not you are a programmer. This is not a programming textbook. We make no assumptions about your programming background or future; this work bookisforbothprogrammersandnonprogrammers. Every time we use a term for the first time, we put it in italics. If you see a term you don’t recognize, be sure to check the glossary at the end of the work book. This workbook uses Symbolics documentation conventions and a few of its own. If you see a word or phrase enclosed in brackets, like [Help], it is a menu item.We use two different conventions withrespect to Symbolics keyboard keys: in text,thekeylabelledHELPlookslikethis: HELP butinexamplesitlookslikethis: <HELP> todifferentiateitasasinglekeystrokefromthetextaroundit. It is very important to have a Symbolics computer available so that you can work through the hands-on activities, called walk-throughs.
    [Show full text]
  • Document Number Scco24
    Stanford University Libraries Dept. of Special Cr*l!«ctkjns &>W Title Box Series I Fol 5C Fo<. Title " LISP/360 REFERENCE MANUAL FOURTH EDITION # CAMPUS COMPUTER FACILITY STANFORD COMPUTATION CENTER STANFORD UNIVERSITY STANFORD, CALIFORNIA DOCUMENT NUMBER SCCO24 " ■ " PREFACE This manual is intended to provide the LISP 1.5 user with a reference manual for the LISP 1.5 interpreter, assembler, and compiler on the Campus Facility 360/67. It assumes that the reader has a working knowledge by of LISP 1.5 as described in the LISP_I.is_Primer Clark Weissman, and that the reader has a general knowledge of the operating environment of OS 360. Beginning users of LISP will find the sections The , Functions, LI SRZIi O_Syst em , Organiz ation_of_St orage tlSP_Job_Set-]i£» and t.tsp/360 System Messages Host helpful in obtaining a basic understanding of the LISP system. Other sections of the manual are intended for users desiring a more extensive knowledge of LISP. The particular implementation to which this reference manual is directed was started by Mr. J. Kent while he was at the University of Waterloo. It is modeled after his implemention of LISP 1.5 for the CDC 3600. Included in this edition is information on the use of the time-shared LISP system available on the 360/67 which was implemented by Mr. Robert Berns of the " Computer staff. Campus Facility " II TABLE OF CONTENTS Section PREFACE " TABLE OF CONTENTS xxx 1. THE LISP/360 SYSTEM 1 2. ORGANIZATION OF STORAGE 3 2.1 Free Cell Storage (FCS) 3 2.1.1 Atoms 5 2.1.2 Numbers 8 2.1.3 Object List 9 2.2 Push-down Stack (PDS) 9 2.3 System Functions 9 2.4 Binary Program Space (BPS) 9 W 2.5 Input/Output Buffers 9 10 3.
    [Show full text]
  • The Evolution of Lisp
    1 The Evolution of Lisp Guy L. Steele Jr. Richard P. Gabriel Thinking Machines Corporation Lucid, Inc. 245 First Street 707 Laurel Street Cambridge, Massachusetts 02142 Menlo Park, California 94025 Phone: (617) 234-2860 Phone: (415) 329-8400 FAX: (617) 243-4444 FAX: (415) 329-8480 E-mail: [email protected] E-mail: [email protected] Abstract Lisp is the world’s greatest programming language—or so its proponents think. The structure of Lisp makes it easy to extend the language or even to implement entirely new dialects without starting from scratch. Overall, the evolution of Lisp has been guided more by institutional rivalry, one-upsmanship, and the glee born of technical cleverness that is characteristic of the “hacker culture” than by sober assessments of technical requirements. Nevertheless this process has eventually produced both an industrial- strength programming language, messy but powerful, and a technically pure dialect, small but powerful, that is suitable for use by programming-language theoreticians. We pick up where McCarthy’s paper in the first HOPL conference left off. We trace the development chronologically from the era of the PDP-6, through the heyday of Interlisp and MacLisp, past the ascension and decline of special purpose Lisp machines, to the present era of standardization activities. We then examine the technical evolution of a few representative language features, including both some notable successes and some notable failures, that illuminate design issues that distinguish Lisp from other programming languages. We also discuss the use of Lisp as a laboratory for designing other programming languages. We conclude with some reflections on the forces that have driven the evolution of Lisp.
    [Show full text]
  • Implementing a Vau-Based Language with Multiple Evaluation Strategies
    Implementing a Vau-based Language With Multiple Evaluation Strategies Logan Kearsley Brigham Young University Introduction Vau expressions can be simply defined as functions which do not evaluate their argument expressions when called, but instead provide access to a reification of the calling environment to explicitly evaluate arguments later, and are a form of statically-scoped fexpr (Shutt, 2010). Control over when and if arguments are evaluated allows vau expressions to be used to simulate any evaluation strategy. Additionally, the ability to choose not to evaluate certain arguments to inspect the syntactic structure of unevaluated arguments allows vau expressions to simulate macros at run-time and to replace many syntactic constructs that otherwise have to be built-in to a language implementation. In principle, this allows for significant simplification of the interpreter for vau expressions; compared to McCarthy's original LISP definition (McCarthy, 1960), vau's eval function removes all references to built-in functions or syntactic forms, and alters function calls to skip argument evaluation and add an implicit env parameter (in real implementations, the name of the environment parameter is customizable in a function definition, rather than being a keyword built-in to the language). McCarthy's Eval Function Vau Eval Function (transformed from the original M-expressions into more familiar s-expressions) (define (eval e a) (define (eval e a) (cond (cond ((atom e) (assoc e a)) ((atom e) (assoc e a)) ((atom (car e)) ((atom (car e)) (cond (eval (cons (assoc (car e) a) ((eq (car e) 'quote) (cadr e)) (cdr e)) ((eq (car e) 'atom) (atom (eval (cadr e) a))) a)) ((eq (car e) 'eq) (eq (eval (cadr e) a) ((eq (caar e) 'vau) (eval (caddr e) a))) (eval (caddar e) ((eq (car e) 'car) (car (eval (cadr e) a))) (cons (cons (cadar e) 'env) ((eq (car e) 'cdr) (cdr (eval (cadr e) a))) (append (pair (cadar e) (cdr e)) ((eq (car e) 'cons) (cons (eval (cadr e) a) a)))))) (eval (caddr e) a))) ((eq (car e) 'cond) (evcon.
    [Show full text]
  • Obstacles to Compilation of Rebol Programs
    Obstacles to Compilation of Rebol Programs Viktor Pavlu TU Wien Institute of Computer Aided Automation, Computer Vision Lab A-1040 Vienna, Favoritenstr. 9/183-2, Austria [email protected] Abstract. Rebol’s syntax has no explicit delimiters around function arguments; all values in Rebol are first-class; Rebol uses fexprs as means of dynamic syntactic abstraction; Rebol thus combines the advantages of syntactic abstraction and a common language concept for both meta-program and object-program. All of the above are convenient attributes from a programmer’s point of view, yet at the same time pose severe challenges when striving to compile Rebol into reasonable code. An approach to compiling Rebol code that is still in its infancy is sketched, expected outcomes are presented. Keywords: first-class macros, dynamic syntactic abstraction, $vau calculus, fexpr, Ker- nel, Rebol 1 Introduction A meta-program is a program that can analyze (read), transform (read/write), or generate (write) another program, called the object-program. Static techniques for syntactic abstraction (macro systems, preprocessors) resolve all abstraction during compilation, so the expansion of abstractions incurs no cost at run-time. Static techniques are, however, conceptionally burdensome as they lead to staged systems with phases that are isolated from each other. In systems where different syntax is used for the phases (e. g., C++), it results in a multitude of programming languages following different sets of rules. In systems where the same syntax is shared between phases (e. g., Lisp), the separa- tion is even more unnatural: two syntactically largely identical-looking pieces of code cannot interact with each other as they are assigned to different execution stages.
    [Show full text]
  • Directly Reflective Meta-Programming
    Directly Reflective Meta-Programming ∗ Aaron Stump Computer Science and Engineering Washington University in St. Louis St. Louis, Missouri, USA [email protected] Abstract Existing meta-programming languages operate on encodings of pro- grams as data. This paper presents a new meta-programming language, based on an untyped lambda calculus, in which structurally reflective pro- gramming is supported directly, without any encoding. The language fea- tures call-by-value and call-by-name lambda abstractions, as well as novel reflective features enabling the intensional manipulation of arbitrary pro- gram terms. The language is scope safe, in the sense that variables can neither be captured nor escape their scopes. The expressiveness of the language is demonstrated by showing how to implement quotation and evaluation operations, as proposed by Wand. The language's utility for meta-programming is further demonstrated through additional represen- tative examples. A prototype implementation is described and evaluated. Keywords: lambda calculus, reflection, meta-programming, Church en- coding, Mogensen-Scott encoding, Wand-style fexprs, alpha equivalence, language implementation. 1 Introduction This paper presents a new meta-programming language called Archon, in which programs can operate directly on other programs as data. Existing meta- programming languages suffer from defects such as encoding programs at too low a level of abstraction, or in a way that bloats the encoded program terms. Other issues include the possibility for variables either to be captured or escape their static scopes. Archon rectifies these defects by trading the complexity of the reflective encoding for additional programming constructs. We adopt ∗This work is supported by funding from the U.S.
    [Show full text]
  • Symbolics Architecture
    Symbolics Architecture David A. Moon Symbolics, Inc. W hat is an architecture? In com- languages, user interface, and operating This architecture puter systems, an architecture system. System architecture defines the rapid is a specification of an inter- product that people actually use; the other enables face. To be dignified by the name architec- levels of architecture define the mecha- development and ture, an interface should be designed for a nism underneath that implements it. Sys- long lifespan and should connect system tem architecture is implemented by soft- efficient execution of components maintained by different orga- ware; hardware only sets bounds on what large, ambitious nizations. Often an architecture is part ofa is possible. System architecture defines the product definition and defines character- motivation for most of the design choices applications. An istics on which purchasers of that product at the other levels ofarchitecture. This sec- rely, but this is not true of everything that tion is an overview of Symbolics system unconventional design is called an architecture. An architecture is architecture. avoids trading off more formal than an internal interface be- The Symbolics system presents itself to tween closely-related system components, the user through a high-resolution bitmap safety for speed. and has farther-reaching effects on system display. In addition to text and graphics, characteristics and performance. the display contains presentations of ob- A computer system typically contains jects. The user operates on the objects by many levels and types ofarchitecture. This manipulating the presentations with a article discusses three architectures de- mouse. The display includes a continuous- fined in Symbolics computers: ly updated reminder of the mouse com- (1) System architecture-defines how mands applicable to the current context.
    [Show full text]
  • CONS Y X)))) Which Sets Z to Cdr[X] If Cdr[X] Is Not NIL (Without Recomputing the Value As Woirld Be Necessary in LISP 1.5
    NO. 1 This first (long delayed) LISP Bulletin contains samples of most of those types of items which the editor feels are relevant to this publication. These include announcements of new (i.e. not previously announced here) implementations of LISP !or closely re- lated) systems; quick tricks in LISP; abstracts o. LISP related papers; short writeups and listings of useful programs; and longer articles on problems of general interest to the entire LISP com- munity. Printing- of these last articles in the Bulletin does not interfere with later publications in formal journals or books. Short write-ups of new features added to LISP are of interest, preferably upward compatible with LISP 1.5, especially if they are illustrated by programming examples. -A NEW LISP FEATURE Bobrow, Daniel G., Bolt Beranek and Newman Inc., 50 oulton Street, Cambridge, Massachusetts 02138. An extension of ro 2, called progn is very useful. Tht ralue of progn[el;e ; ,..;e Y- is the value of e . In BBN-LISP on t .e SDS 940 we ha6e extenaed -cond to include $n implicit progn in each clause, putting It In the general form (COND (ell e ) . (e21 . e 2n2) (ekl e )) In1 ... ... kn,_ where nl -> 1. This form is identical to the LISP 1.5 form if n ni = 2. If n > 2 then each expression e in a clause is evaluated (in order) whh e is the first true (nohkN1~)predicate found. The value of the &And Is the value of the last clause evaluated. This is directly Gapolated to the case where n, = 1, bxre the value of the cond is the value of this first non-~ILprewcate.
    [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]
  • Free As in Freedom (2.0): Richard Stallman and the Free Software Revolution
    Free as in Freedom (2.0): Richard Stallman and the Free Software Revolution Sam Williams Second edition revisions by Richard M. Stallman i This is Free as in Freedom 2.0: Richard Stallman and the Free Soft- ware Revolution, a revision of Free as in Freedom: Richard Stallman's Crusade for Free Software. Copyright c 2002, 2010 Sam Williams Copyright c 2010 Richard M. Stallman Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled \GNU Free Documentation License." Published by the Free Software Foundation 51 Franklin St., Fifth Floor Boston, MA 02110-1335 USA ISBN: 9780983159216 The cover photograph of Richard Stallman is by Peter Hinely. The PDP-10 photograph in Chapter 7 is by Rodney Brooks. The photo- graph of St. IGNUcius in Chapter 8 is by Stian Eikeland. Contents Foreword by Richard M. Stallmanv Preface by Sam Williams vii 1 For Want of a Printer1 2 2001: A Hacker's Odyssey 13 3 A Portrait of the Hacker as a Young Man 25 4 Impeach God 37 5 Puddle of Freedom 59 6 The Emacs Commune 77 7 A Stark Moral Choice 89 8 St. Ignucius 109 9 The GNU General Public License 123 10 GNU/Linux 145 iii iv CONTENTS 11 Open Source 159 12 A Brief Journey through Hacker Hell 175 13 Continuing the Fight 181 Epilogue from Sam Williams: Crushing Loneliness 193 Appendix A { Hack, Hackers, and Hacking 209 Appendix B { GNU Free Documentation License 217 Foreword by Richard M.
    [Show full text]