The Machine that Builds Itself:How the Strengths of Lisp Family Languages Facilitate Building Complex and Flexible Bioinformatic Models

The Machine that Builds Itself:
How the Strengths of Lisp Family Languages Facilitate Building Complex and Flexible Bioinformatic Models

[    [    [ \orgnameCenter for Therapeutic Innovation and Department of Psychiatry and Behavioral Sciences, University of Miami Miller School of Medicine, \street1120 NW 14th ST, \cityMiami, FL, \cnyUSA \postcode33136 \orgnameHamburg University of Applied Sciences, \streetFinkenau 35, \city22081 Hamburg, \cnyGermany

We address the need for expanding the presence of the Lisp family of programming languages in bioinformatics and computational biology research. Languages of this family, like Common Lisp, Scheme, or Clojure, facilitate the creation of powerful and flexible software models that are required for complex and rapidly evolving domains like biology. We will point out several important key features that distinguish languages of the Lisp family from other programming languages and we will explain how these features can aid researchers in becoming more productive and creating better code. We will also show how these features make these languages ideal tools for artificial intelligence and machine learning applications. We will specifically stress the advantages of domain-specific languages (DSL): languages which are specialized to a particular area and thus not only facilitate easier research problem formulation, but also aid in the establishment of standards and best programming practices as applied to the specific research field at hand. DSLs are particularly easy to build in Common Lisp, the most comprehensive Lisp dialect, which is commonly referred to as the “programmable programming language.” We are convinced that Lisp grants programmers unprecedented power to build increasingly sophisticated artificial intelligence systems that may ultimately transform machine learning and AI research in bioinformatics and computational biology.


Opinion Note

addressref=aff1, corref=aff1, ]\initsBK\fnmBohdan B. \snmKhomtchouk addressref=aff2, ]\initsEW\fnmEdmund \snmWeitz addressref=aff1, ]\initsCW\fnmClaes \snmWahlestedt


Lisp \kwdsoftware engineering \kwdbioinformatics \kwdcomputational biology

Introduction and Background

The programming language Lisp is credited for pioneering fundamental computer science (CS) concepts that have influenced the development of nearly every modern programming language to date. Concepts such as tree data structures, automatic storage management, dynamic typing, conditionals, exception handling, higher-order functions, recursion, and more, have all shaped the foundations of today’s software engineering community. The name Lisp derives from “List processor” [1], since linked lists are one of Lisp’s major data structures, and Lisp source code is comprised of lists. As such, genome sequence analysis programs can be written naturally through the many convenient Lisp functions available for manipulating list data. Lists, which are a generalization of graphs, are extraordinarily well supported by Lisp. As such, programs that analyze sequence data (such as genomics), graph knowledge (such as pathways), and tabular data (such as that handled by R [2]), can be written easily, and can be made to work together naturally in Lisp. As a programming language, Lisp supports many different programming paradigms each of which can be employed exclusively or intermixed with others; this includes functional and procedural programming, object orientation, meta programming, and reflection. In the case of the latter, Lisp’s reflectivity allows the computer program to examine, introspect, and modify its own structure and behavior at runtime, making it ideal for artificial intelligence and machine learning applications [3].

In bioinformatics and computational biology, Lisp has successfully been applied to research in systems biology [4, 5], database curation [6, 7], drug discovery [8], network and pathway -omics analysis [9, 10, 11, 12, 13], single nucleotide polymorphism analysis [14, 15, 16], and RNA structure prediction [17, 18, 19]. In general, the Lisp family of programming languages (LFLs), which includes Common Lisp, Scheme, and Clojure, has powered multiple applications across fields as diverse as [20]: animation and graphics, AI, bioinformatics, B2B and e-commerce, data mining, electronic design automation/semiconductor applications, embedded systems, expert systems, finance, intelligent agents, knowledge management, mechanical computer-aided design (CAD), modeling and simulation, natural language, optimization, risk analysis, scheduling, telecommunications, and web authoring.

Programmers often test a language’s mettle by how successfully it has fared in commercial settings, where big money is often on the line. To this end, Lisp has been successfully adopted by commerical vendors such as the Roomba vacuuming robot [21, 22], Viaweb (acquired by Yahoo! Store) [23], ITA Software (acquired by Google Inc. and in use at Orbitz, Bing Travel, United Airlines, US Airways, etc) [24], Mirai (used to model the Gollum character for the Lord of the Rings movies) [25], Boeing [26], AutoCAD [27], among others. Lisp has also been the driving force behind open source applications like Emacs [28] and Maxima [29], which both have existed for decades and continue to be used worldwide.

Amongst the LFLs, Common Lisp has been described as the most powerful and accessible modern language for advanced biomedical concept representation and manipulation [30]. Scheme [31] is an elegant and compact subset of Common Lisp that supports a minimalistic core language and an excellent suite of language extensions tools. However, Scheme has traditionally mainly been used in teaching and CS research and its implementors have thus prioritized small size, the functional programming paradigm, and a certain kind of “cleanliness” over more pragmatic features. As such, Scheme is considered far less popular than Common Lisp for building large-scale applications [21].

The third most common LFL, Clojure [32, 33], is a rising star language in the modern software development community. Clojure specializes in the parallel processing of big data through the Java Virtual Machine (JVM), recently making its debut in bioinformatics and computational biology research [34, 35, 36]. Most recently, Clojure was used to parallelize the processing and analysis of SAM/BAM files [35]. Furthermore, the BioClojure project provides seeds for the bioinformatics community that can be used as building blocks for writing LFL applications. As of now, BioClojure consists of parsers for various kinds of file formats (UniProtXML, Genbank XML, FASTA, and FASTQ), as well as wrappers of select data analysis programs (BLAST, SignalP, TMHMM, and InterProScan) [35]. Such projects may also soon find their way into bioinformatics and computational biology applications.

As a whole, Lisp continues to develop new offshoots. A relatively recent addition to the family is Julia [37]. Although it is sometimes touted “C for scientists” and caters to a different community due to its syntactical proximity to Python, it is a Lisp at heart and certainly worth watching.

Macros and domain-specific languages

Lisp is a so-called homoiconic language, which means that Lisp code is represented as a data structure of the language itself. In more technical terms, a Lisp program has direct access to (and can modify) its abstract syntax tree. This property enables Lisp to have a macro system that remains undisputed in the programming language world [38]. While “macros” in languages like C have the same name, they are essentially just text substitutions performed on the source code before it is compiled and they can’t always reliably preserve the lexical structure of the code. Lisp macros, on the other hand, operate at the syntactic level. They transform the program structure itself and, as opposed to C macros, are written in the same language they work on and have the full language available all the time. Lisp macros are thus not only used for moderately simple “find and replace” chores, but can apply extensive structural changes to a program. This includes tasks that are impossible in other languages, like the introduction of new control structures or pattern matching capabilities or the integration of code with markup languages [39, 40]. In addition to that, Common Lisp even offers access to its “reader” which means that code can be manipulated (in Lisp) before it is parsed [41]. This enables Lisp programs to completely change their surface syntax if necessary [42, 43, 44].

These features make Lisp an ideal tool for the creation of domain-specific languages: languages that are custom-tailored to a specific problem domain but can still have access to all of Lisp. A striking example is Common Prolog [45], a professional Prolog system implemented and embedded in Common Lisp. In bioinformatics, the Biolingua [5] project (now called BioBIKE) built a cloud-based general symbolic biocomputing DSL entirely in Common Lisp. The system, which could be programmed entirely through the browser, was its own complete biocomputing language, which included a built-in deductive reasoner, called BioDeducta [46]. Biolingua programs, guided by the reasoner, would invisibly call tools such as Blast [47] and Bioconductor [48] on the server-side, as needed. Symbolic biocomputing has also previously been used to create user-friendly visual tools for interactive data analysis and exploration [49].

Other Unique Strengths

In addition to homoiconicity, Lisp has several other features which set it apart from mainstream languages:

  • In Lisp, programmers usually work in a special incremental interactive programming environment called the read-eval-print loop (REPL) [50, 51]. The REPL enables a paradigm that allows the programmer to continually interact with their program as it is developed. This is similar to the way Smalltalk “images” evolve [41] and very different from the usual edit-compile-link-execute cycle of C-like languages. This approach lends itself very well to explorative programming and rapid prototyping. The REPL enables the programmer to write a function, test it, change it, try a different approach, etc., while never having to stop for any lengthy compilation cycles [21].

  • Common Lisp was designed from the ground up to create large, complex, and long-running applications and thus supports software “hot swapping”: the code of a running program can be changed without the need to interrupt it. This includes features like the ability of CLOS (Common Lisp’s object system) to change the classes of existing objects.

  • Lisp invented exception handling, and Common Lisp in particular has an error handling facility (the “condition system” [21]) that goes far beyond most other languages: it doesn’t necessarily unwind the stack if an exception occurs and instead offers so-called restarts to programmatically continue “where the error happened.” This system makes it easy to write robust software, which is an essential ingredient to building industry-strength fault-tolerant systems capable of handling a variety of conditions, a trait especially useful for artificial intelligence and machine learning applications.

  • Common Lisp implementations usually come with a sophisticated “foreign function interface” (FFI) [21] which allows direct access from Lisp to code written in C or C++ and sometimes also to Java code. This enables Lisp programmers to make use of libraries written in other languages, making those libraries a direct strength of Lisp. For instance, it is simple to call Bioconductor from Lisp, just as Python and other programming languages do [52, 53]. Likewise, Clojure runs on the Java Virtual Machine and, thus, has immediate access to all of Java’s libraries.

It has been shown that these features, together with other amenities like powerful debugging tools that Lisp programmers take for granted, offer a significant productivity boost to programmers [54, 55]. Lisp also gives programmers the ability to implement complex data operations and mathematical constructs in an expressive and natural idiom [56].

As a whole, LFLs are known to attract a strong audience [57, 58] and to be popular with many historical CS figures and other prolific and extremely productive programmers. Much speculation has arisen to explain this phenomenon, namely why “super programmers” are so drawn to and cater to Lisp, but so far the results have been inconclusive and generally interspersed across website posts, blogs, and miscellaneous comment sections.

Speed considerations

The interactivity and flexibility of Lisp languages is something that can usually only be found (if at all) in interpreted languages. This might be the origin of the old myth that Lisp is interpreted and must thus be slow. But this is not true. Compilers for Lisp have existed since 1959 and all major Common Lisp implementations nowadays can compile directly to machine code which is often on par with C code [59] or only slightly slower. (Some also offer an interpreter in addition to the compiler, but examples like Clozure Common Lisp demonstrate that you can have a compiler-only Common Lisp.) For example, CL-PPCRE, a regular expression library written in Common Lisp, runs faster than Perl’s regular expression engine on some benchmarks, even though Perl’s engine is written in highly tuned C [21].

While programmers who use interpreted languages like Python or Perl for their convenience and flexibility will have to resort to writing in C for time-critical portions of their code, Lisp programmers can usually have their cake and eat it too. And not only will the code created by Lisp compilers be quite efficient by default, Common Lisp in particular offers unique features to optimize those parts of the code (usually only a tiny fraction) which really need to be as fast as possible [41]. This includes so-called compiler macros, which can transform function calls into more efficient code at runtime, and a mandatory disassembler which enables programmers to fine-tune time-critical functions until the compiled code matches their expectations.

It should also be emphasized that while the C or Java compiler is ”history” once the compiled program is started, the Lisp compiler is always present and can thus generate new, fast code while the program is already running.

To further debunk the popular misconception that Lisp languages are slow, Clojure was used to process and analyze SAM/BAM files [35] with significantly less lines of code and almost identical speeds as SAMTools [60], which is written in the C programming language.

Rewards and Challenges

In general, early adopters of a language framework are better poised to reap the scientific benefits, as they are the first to set out building the critical libraries, ultimately attracting and retaining a growing share of the research and developer community. Since library support for bioinformatics tasks in the Lisp family of programming languages (Clojure, Common Lisp, and Scheme) is yet in its early stages and on the rise, and there is (as of yet) no officially established bioinformatics Lisp community, there is plenty of opportunity for high-impact work in this direction.

It is well-known that the best language to choose from should be the one that is best suited to the job at hand. Yet, in practice, few programmers may consider a non-mainstream programming language for a project, unless it offers strong, community-tested benefits over its popular contenders for the specific task at hand. Often times, the choice comes down to library support: does language X already offer well-written, optimized code to help solve my research problem, as opposed to language Y (or perhaps language Z)? In general, new language adoption boils down to a chicken-and-egg problem: without a large user-base it is difficult to create and maintain large-scale, reproducible tools and libraries. But without these tools and libraries, there can never be a large user-base. Hence, a new language must have a big advantage over the existing ones and/or a powerful corporate sponsorship behind it to compete [61]. Most often, a positive feedback loop is generated by repositories of useful libraries attracting users, who, in turn, add more functional libraries, thereby raising a programming language’s popularity, rather than reflecting its theoretical potential.

With mainstream languages like R [2] and Python [62] dominating the bioinformatics and computational biology scene for years, large-scale software development and community support for other less popular language frameworks has weened to relative obscurity. Consequently, languages winning over increasingly growing proportions of a steadily expanding user-base have the effect of shaping research paradigms and influencing modern research trends. For example, R programming generally promotes research that frequently leads to the deployment of R packages to Bioconductor [48], which has steadily grown into the largest bioinformatics package ecosystem in the world, whose package count is considerably ahead of BioPython [63], BioClojure [34], BioPerl [64], BioJava [65], BioRuby [66], BioJulia [67], or SCABIO [68]. As a community repository of bioinformatics packages, BioLisp does not yet exist as such, albeit its name currently denotes the native language of BioBIKE [4, 46], a large-scale bioinformatics Lisp application.

Likewise, given the choice, R programmers interested in deploying large-scale applications are more likely to branch out to releasing web applications (e.g., Shiny [69]) than to GUI binary executables, which are generally more popular with lower-level languages like C/C++ [70]. As such, language often dictates research direction, output, and funding. Questions like “who will be able to read my code?”, “is it portable?”, “does it already have a library for that?”, or “can I hire someone?” are pressing questions, often inexorably shaping the course and productivity of a project.

Perspectives and Outlook

Historically speaking, Lisp is the second oldest (second only to Fortran) programming language still in use and has influenced nearly every major programming language to date with its constructs [71]. For example, it may be surprising to learn that R is written atop of Scheme [72]. In fact, R borrows directly from its Lisp roots for creating embedded domain specific languages within R’s core language set [73]. For instance, ggplot2 [74], dplyr [75], and plyr [76] are all examples of DSLs in R. This highlights the importance and relevance of Lisp as a programmable programming language, namely the ability to be user-extensible beyond the core language set. Given the wide spectrum of domains and subdomains in bioinformatics and computational biology research, it follows that similar applications tailored to genomics, proteomics, metabolomics, or other research fields may also be developed as extensible macros in Common Lisp. By way of analogy, perhaps a genomics equivalent of ggplot2 or dplyr is in store in the not-so-distant future. Advice for when such pursuits are useful is readily available [77].


New programming language adoption in a scientific community is both a challenging and rewarding process. Here we advocate for and propose a greater inclusion of the Lisp family of programming languages (LFLs) into large-scale bioinformatics research, outlining the benefits and opportunities of the adoption process. We provide historical perspective on the influence of language choice on research trends and community standards, and emphasize Lisp’s unparalleled support for homoiconicity, domain-specific languages, extensible macros, and error handling, as well as their significance to future bioinformatics research. We forecast that the current state of Lisp research in bioinformatics and computational biology is highly conducive to a timely establishment of robust community standards and support centered around not only the development of bioinformatic domain-specific libraries, but also the rise of highly customizable and efficient machine learning and AI applications written in languages like Common Lisp, Clojure, and Scheme.

Key Points

  • Lisp’s treatment of code as data and data as code (a property called homoiconicity), as well as the ability of Lisp programs to examine, introspect, and modify their own structure and behavior at runtime (a property called reflectivity), permits flexible software engineering practices that are conducive to producing unparalleled AI and machine learning applications in bioinformatics and computational biology.

  • The Lisp family of programming languages (Common Lisp, Scheme, Clojure) makes it easy to create extensible macros, which facilitate the creation of modularized extensions to help bioinformaticians easily create plug-ins for their software. This, in turn, paves the way for creating enterprise-level, fault-tolerant domain-specific languages in any research area or specialization.

  • The current state of Lisp research in bioinformatics and computational biology is at a point where an official BioLisp community is likely to be established soon.


Author information

Center for Therapeutic Innovation and Department of Psychiatry and Behavioral Sciences, University of Miami Miller School of Medicine, 1120 NW 14th ST, Miami, FL, USA 33136. Correspondence:

Competing interests

The authors declare that they have no competing interests.

Author’s contributions

BBK conceived the study. BBK and EW wrote the paper. BBK, EW, and CW planned the study. All authors read and approved the final manuscript.


BBK dedicates this work to the memory of his uncle, Taras Khomchuk. BBK wishes to acknowledge the financial support of the United States Department of Defense (DoD) through the National Defense Science and Engineering Graduate Fellowship (NDSEG) Program: this research was conducted with Government support under and awarded by DoD, Army Research Office (ARO), National Defense Science and Engineering Graduate (NDSEG) Fellowship, 32 CFR 168a. CW thanks Jeff Shrager for critical review and helpful comments on the manuscript.


  • [1] Jones R, Maynard C, and Stewart I. The Art of Lisp Programming. Springer Science+Business Media, 1990.
  • [2] R Core Team. R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing, Vienna, Austria, 2016.
  • [3] Peter Norvig. Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp. Morgan Kaufmann, 1st edition, 1992.
  • [4] Elhai J, Taton A, Massar JP, et al. BioBIKE: A Web-based, programmable, integrated biological knowledge base. Nucleic Acids Research, 37 (Web Server issue):W28–W32, 2009.
  • [5] Massar JP, Travers M, Elhai J, et al. Biolingua: a programmable knowledge environment for biologists. Bioinformatics, 21:199–207, 2005.
  • [6] Karp PD, Riley M, Paley SM, et al. EcoCyc: Enyclopedia of Escherichia coli Genes and Metabolism. Nucleic Acids Research, 25(1):43–50, 1997.
  • [7] Keseler IM, Mackie A, Peralta-Gil M, et al. EcoCyc: fusing model organism databases with systems biology. Nucleic Acids Research, 41:D605–D612, 2013.
  • [8] Franz Inc. MDL Information Systems, Inc.: Exploring molecule space., 2016.
  • [9] Karp P, Paley S, Krummenacker M, et al. Pathway Tools version 13.0: Integrated Software for Pathway/Genome Informatics and Systems Biology. Brief Bioinform, 11:40–79, 2010.
  • [10] Paley S and Karp P. The Pathway Tools Cellular Overview Diagram and Omics Viewer. Nucleic Acids Research, 34:3771–8, 2006.
  • [11] Karp P, Paley S, and Romero P. The Pathway Tools Software. Bioinformatics, 18:S225– S232, 2002.
  • [12] Karp P and Paley S. Integrated Access to Metabolic and Genomic Data. Journal of Computational Biology, (3):191–212, 1996.
  • [13] Karp P, Latendresse M, Paley S, et al. Pathway Tools version 19.0 update: Software for Pathway/Genome Informatics and Systems Biology. Brief Bioinform, pages 1–14, 2015.
  • [14] Riva A and Kohane IS. A SNP-centric database for the investigation of the human genome. BMC Bioinformatics, 5(33), 2004.
  • [15] Riva A and Kohane IS. SNPper: retrieval and analysis of human SNPs. Bioinformatics, 18:1681–1685, 2002.
  • [16] Riva A and Kohane IS. A Web-Based Tool to Retrieve Human Genome Polymorphisms from Public Databases. In Proc. AMIA Symp., pages 558–562, 2001.
  • [17] Shapiro BA and Kasprzak W. STRUCTURELAB: a heterogeneous bioinformatics system for RNA structure analysis. J Mol Graph, 14(4):194–205, 222–4, 1996.
  • [18] Kasprzak W and Shapiro BA. Stem Trace: an interactive visual tool for comparative RNA structure analysis. Bioinformatics, 15(1):16–31, 1999.
  • [19] Shapiro BA, Kasprzak W, Grunewald C, et al. Graphical exploratory data analysis of RNA secondary structure dynamics predicted by the massively parallel genetic algorithm. J Mol Graph Model, 25(4):514–531, 2006.
  • [20] Franz Inc. Allegro Common Lisp, Customer Success Stories.
  • [21] Peter Seibel. Practical Common Lisp. Apress, 2005.
  • [22] Brooks RA and Rosenberg C. L - a Common Lisp for Embedded Systems. In Association of Lisp Users Meeting and Workshop, 1995.
  • [23] Paul Graham. Beating the Averages., April 2003.
  • [24] Franz Inc. ITA Software: Airfare Shopping Engine.
  • [25] Izware. Mirai.
  • [26] Tanner S, Carnes R, Williams G, et al. AI Research and Application Development at Boeing’s Huntsville Laboratories. AI Magazine, 14(2), 1993.
  • [27] Trevor Bousfield. A Practical Guide to AutoCAD AutoLISP. Addison-Wesley, 1999.
  • [28] Free Software Foundation. GNU Emacs., 2016.
  • [29] Maxima. Maxima, a Computer Algebra System. Version 5.34.1., 2014.
  • [30] Kalet IJ. Principles of Biomedical Informatics. Academic Press, 2nd edition, 2013.
  • [31] Hanson C and MIT Scheme Team. MIT/GNU Scheme Reference Manual., May 2014.
  • [32] Hickey R. Clojure.
  • [33] Hickey R. The clojure programming language. In Proceedings of the 2008 symposium on Dynamic languages. ACM New York, NY, USA, 2008.
  • [34] Plieskatt J, Rinaldi G, Brindley PJ, et al. Bioclojure: a functional library for the manipulation of biological sequences. Bioinformatics, 30(17):2537–2539, 2014.
  • [35] Takeuchi T, Yamada A, Aoki T, et al. cljam: a library for handling DNA sequence alignment/map (SAM) with parallel processing. Source Code for Biology and Medicine, 11(12), 2016.
  • [36] Blue Collar Bioinformatics., September 2016.
  • [37] Bezanson J, Karpinski S, Shah VB, et al. Julia: A Fast Dynamic Language for Technical Computing. arXiv:1209.5145 [cs.PL], 2012.
  • [38] What makes lisp macros so special.
  • [39] CLiki the common lisp wiki. cl-markup.
  • [40] CLiki the common lisp wiki. cl-who.
  • [41] Edmund Weitz. Common Lisp Recipes. Apress, 2016.
  • [42] CLiki the common lisp wiki. XMLisp.
  • [43] CLiki the common lisp wiki. cl-interpol.
  • [44] CLiki the common lisp wiki. Infix.
  • [45] LispWorks. A Common Prolog.
  • [46] Shrager J, Waldinger R, Stickel M, et al. Deductive Biocomputing. PLoS One, 2(4):e339, 2007.
  • [47] Altschul SF, Gish W, Miller W, et al. Basic local alignment search tool. J. Mol. Biol., 215:403–410, 1990.
  • [48] Gentleman RC, Carey VJ, Bates DM, et al. Bioconductor: open software development for computational biology and bioinformatics. Genome Biology, 5(10):R80, 2004.
  • [49] Shrager J Holland TA Karp PD Travers M, Paley SM. Groups: knowledge spreadsheets for symbolic biocomputing. Database (Oxford), 2013.
  • [50] Pitman KM. Accelerating Hindsight: Lisp as a Vehicle for Rapid Prototyping., 1994.
  • [51] Stack Overflow. How is Lisp’s read-eval-print loop different than Python’s?, 2012.
  • [52] L. Gautier. An intuitive Python interface for Bioconductor libraries demonstrates the utility of language translators. BMC Bioinformatics, 11(Suppl 12)(S11), 2010.
  • [53] Prins P, Goto N, Yates A, et al. Sharing Programming Resources Between Bio* Projects Through Remote Procedure Call and Native Call Stack Strategies. Evolutionary Genomics (Methods in Molecular Biology), 856:513–527, 2012.
  • [54] E. Gat. Point of view: Lisp as an alternative to Java. Intelligence: New Visions of AI in Practice, 11(4):21–4, 2000.
  • [55] Peter Norvig. Lisp as an Alternative to Java.
  • [56] Fenwick M, Sesanker C, Schiller MR, et al. An open-source sandbox for increasing the Accessibility of Functional Programming to the Bioinformatics and Scientific Communities. Proc Int Conf Inf Technol New Gener, pages 89–94, 2012.
  • [57] John D. Cook. The myth of the Lisp genius., April 2011.
  • [58] Mark Tarver. The Bipolar Lisp Programmer., 2007.
  • [59] Verna D. How to make Lisp go faster than c. IAENG International Journal of Computer Science, 32(4), 2006.
  • [60] Li H, Handsaker B, Wysoker A, et al. The Sequence Alignment/Map format and SAMtools. Bioinformatics, 25(16):2078–2079, 2009.
  • [61] Garud R, Jain S, and Kumaraswamy A. Institutional Entrepreneurship in the Sponsorship of Common Technological Standards: The Case of Sun Microsystems and Java. The Academy of Management Journal, 45(1):196–214, 2002.
  • [62] Python Software Foundation. Python Language Reference.
  • [63] Cock PJA, Antao T, Chang JT, et al. Biopython: freely available Python tools for computational molecular biology and bioinformatics. Bioinformatics, 25(11):1422–1423, 2009.
  • [64] Stajich JE, Block D, Boulez K, et al. The Bioperl Toolkit: Perl Modules for the Life Sciences. Genome Research, 12(10):1611–1618, 2002.
  • [65] Holland RCG, Down TA, Pocock M, et al. BioJava: an open-source framework for bioinformatics. Bioinformatics, 24(18):2096–2097, 2008.
  • [66] Goto N, Prins P, Nakao M, et al. BioRuby: bioinformatics software for the Ruby programming language. Bioinformatics, 26(20):2617–2619, 2010.
  • [67] BioJulia: Bioinformatics and Computational Biology in Julia.
  • [68] SCABIO – a framework for bioinformatics algorithms in Scala.
  • [69] Winston Chang, Joe Cheng, JJ Allaire, Yihui Xie, and Jonathan McPherson. shiny: Web Application Framework for R, r package version 0.13.2 edition, 2016.
  • [70] Geneva Switzerland: International Organization for Standardization (ISO). ISO International Standard ISO/IEC 14882:2016(E) – Programming Language C++., 2016.
  • [71] Paul Graham. What made Lisp different., May 2002.
  • [72] Ihaka R and Gentleman R. R: A Language for Data Analysis and Graphics. Journal of Computational and Graphical Statistics, 5(3):299–314, 1996.
  • [73] Hadley Wickham. Advanced R. CRC Press (Taylor & Francis Group), 2014.
  • [74] Hadley Wickham. ggplot2: Elegant Graphics for Data Analysis. Springer-Verlag New York, 2009.
  • [75] Hadley Wickham and Romain Francois. dplyr: A Grammar of Data Manipulation. R package version 0.5.0, 2016.
  • [76] Hadley Wickham. The Split-Apply-Combine Strategy for Data Analysis. Journal of Statistical Software, 40(1):1–29, 2011.
  • [77] Mernik M, Heering J, and Sloane AM. When and how to develop domain-specific languages. ACM Computing Surveys (CSUR), 37(4):316–344, December 2005.

Abbreviations used

LFL: Lisp family of languages
DSL: domain specific language(s)
AI: artificial intelligence
CS: computer science
PCA: principal component analysis
CAD: computer-aided design
JVM: Java Virtual Machine
API: application programming interface
REPL: read-eval-print loop
CLOS: Common Lisp Object System
FFI: Foreign Function Interface
REPL: read-eval-print loop

Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
Add comment
Loading ...
This is a comment super asjknd jkasnjk adsnkj
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test description