Technical dimensions of programming programs

Technical dimensions break down dialogue about
programming programs alongside varied particular “axes”. The scale establish
a variety of doable design selections, characterised by two excessive factors
within the design area.

The scale aren’t quantitative, however they permit comparability.
The acute factors don’t symbolize “good” and “unhealthy” designs, merely totally different trade-offs.
The set of dimensions gives a map of the design area of programming programs (see diagram).
Previous and current programs function landmarks, however the map additionally reveals unexplored
or missed potentialities.

The 23 technical dimensions are grouped into 7 clusters or subjects of curiosity.
Every cluster consists of particular person dimensions, examples that seize a selected
well-known worth (or a mix of values), remarks and relations to different dimensions.
We don’t count on {the catalogue} to be exhaustive for all elements of programming programs,
previous and future, and welcome follow-up work increasing the listing.

Illustration of technical dimensions. The diagram reveals a variety of pattern programming
programs, positioned in response to two hypothetical dimensions. Seen as programming programs,
text-based programming languages with debugger, editor and construct instruments are grouped
in a single area.

by Joel Jakubovic, Jonathan Edwards and Tomas Petricek

Programming is completed in a stateful surroundings, by interacting with a system via a
graphical person interface. The stateful, interactive and graphical surroundings is extra
necessary than the programming language(s) used via it. But, most analysis focuses on evaluating and
finding out programming languages and solely little has been mentioned about programming programs.

Technical dimensions is a framework that captures the traits of programming
programs. It makes it doable to check programming programs, higher perceive them,
and to seek out fascinating new factors within the design area of programming programs.
We created technical dimensions to assist designers of programming programs to judge,
evaluate and information their work and, finally, stand on the shoulders of giants.

The place to begin to be taught extra

Associated papers and paperwork

Smalltalk 76 programming surroundings. An instance of a stateful programming surroundings with
wealthy graphical person interface. In Smalltalk, the developer surroundings is part of an executing
program and the state of this system may be edited via object browser.

The matrix reveals the variations between good old programming systems
alongside the scale recognized by our framework. For conciseness, the desk reveals just one
row for every cluster of dimensions, which consists of a number of separate dimensions every.

The header colours are used to mark programs which might be related (in a casual sense)
for a given dimension. Icons point out a speficic traits and will allow you to
discover connections between programs. You’ll be able to click on on the header to go to a related
paper part, however be aware that not all instances are mentioned within the paper.

Choose programs and dimensions to check within the desk

1. 1 Ankerson, Megan Sapnar. 2018. Dot-Com Design: The Rise of a Usable,Social, Industrial Net. NYU Press.
2. 2 Basman, Antranig, Clayton Lewis, and Colin Clark. 2018. “The OpenAuthorial Precept: Supporting Networks of Authors in CreatingExternalisable Designs.” In Proceedings of the 2018 ACM SIGPLANInternational Symposium on New Concepts, New Paradigms, and Reflections onProgramming and Software program, 29–43.
3. 3 Basman, Antranig, L. Church, C. Klokmose, and Colin B. D. Clark. 2016.“Software program and How It Lives on: Embedding Reside Applications within the WorldAround Them.” In PPIG.
4. 4 Basman, Antranig. 2016. “Constructing Software program Is Not (but) a Craft.” InProceedings of the twenty seventh Annual Workshop of the Psychology ofProgramming Curiosity Group, PPIG 2016, Cambridge, UK, September 7-10,2016, edited by Luke Church, 32. Psychology of Programming InterestGroup. http://ppig.org/library/paper/building-software-not-yet-craft.
5. 5 Basman, Antranig. 2021. “Infusion Framework and Parts.” 2021.https://fluidproject.org/infusion.html.
6. 6 Bloch, Joshua. 2007. “Easy methods to Design a Good API and Why It Issues.”2007.http://www.cs.bc.edu/~muller/teaching/cs102/s06/lib/pdf/api-design.
7. 7 Borowski, Marcel, Luke Murray, Rolf Bagge, Janus Bager Kristensen,Arvind Satyanarayan, and Clemens Nylandsted Klokmose. 2022. “Varv:Reprogrammable Interactive Software program as a Declarative Knowledge Construction.” InCHI Convention on Human Components in Computing Methods. CHI ’22. NewYork, NY, USA: Affiliation for Computing Equipment.https://doi.org/10.1145/3491102.3502064.
8. 8 Brooks, FP. 1995. “Aristocracy, Democracy and System Design.” In TheMythical Man Month: Essays on Software program Engineering. Addison-Wesley.
9. 9 Brooks, Frederick P. 1978. The Legendary Man-Month: Essays on Softw.1st ed. USA: Addison-Wesley Longman Publishing Co., Inc.
10. 10 Chang, Hasok. 2004. Inventing Temperature: Measurement and ScientificProgress. Oxford: Oxford College Press.
11. 11 Chang, Michael Alan, Bredan Tschaen, Theophilus Benson, and Laurent Vanbever. 2015a. “Chaos Monkey: Rising SDN Reliability ThroughSystematic Community Destruction.” In Proceedings of the 2015 ACMConference on Particular Curiosity Group on Knowledge Communication, 371–72.SIGCOMM ’15. New York, NY, USA: Affiliation for Computing Equipment.https://doi.org/10.1145/2785956.2790038.
12. 12 Chang, Michael Alan, Bredan Tschaen, Theophilus Benson, and Laurent Vanbever. 2015b. “Chaos Monkey: Rising SDN Reliability By means of SystematicNetwork Destruction.” SIGCOMM Comput. Commun. Rev. 45 (4): 371–72.https://doi.org/10.1145/2829988.2790038.
13. 13 Chisa, Ellen. 2020. “Introduction: Error Rail and Match with DB::get.”2020. https://youtu.be/NRMmy9ZzA-o.
14. 14 Coda. 2022. “Coda: The Doc That Brings It All Collectively.”https://coda.io.
15. 15 Czaplicki, Evan. 2018. 2018.https://www.youtube.com/watch?v=uGlzRt-FYto.
16. 16 Edwards, Jonathan, Stephen Kell, Tomas Petricek, and Luke Church. 2019.“Evaluating Programming Methods Design.” In Proceedings of thirtieth AnnualWorkshop of Psychology of Programming Curiosity Group. PPIG 2019.Newcastle, UK.
17. 17 Edwards, Jonathan. 2005a. “Subtext: Uncovering the Simplicity ofProgramming.” In Proceedings of the twentieth Annual ACM SIGPLAN Conferenceon Object-Oriented Programming, Methods, Languages, and Purposes,505–18. OOPSLA ’05. New York, NY, USA: Affiliation for ComputingMachinery. https://doi.org/10.1145/1094811.1094851.
18. 18 Edwards, Jonathan. 2005b. “Subtext: Uncovering the Simplicity of Programming.”SIGPLAN Not. 40 (10): 505–18.https://doi.org/10.1145/1103845.1094851.
19. 19 Felleisen, Matthias, Robert Bruce Findler, Matthew Flatt, ShriramKrishnamurthi, Eli Barzilay, Jay McCarthy, and Sam Tobin-Hochstadt.2018. “A Programmable Programming Language.” Commun. ACM 61 (3):62–71. https://doi.org/10.1145/3127323.
20. 20 Feyerabend, Paul. 2011. The Tyranny of Science, Cambridge: Polity Press. ISBN 0745651895
21. 21 Floridi, Luciano, Nir Fresco, and Giuseppe Primiero. 2015. “OnMalfunctioning Software program.” Synthese 192 (4): 1199–1220.
22. 22 Foderaro, John. 1991. “LISP: Introduction.” Commun. ACM 34 (9): 27.https://doi.org/10.1145/114669.114670.
23. 23 Fowler, Martin. 2010. Area-Particular Languages. Pearson Schooling.
24. 24 Fresco, Nir, and Giuseppe Primiero. 2013. “Miscomputation.” Philosophy& Expertise 26 (3): 253–72.
25. 25 Fry, Christopher. 1997. “Programming on an Already Full Mind.” Commun.ACM 40 (4): 55–64. https://doi.org/10.1145/248448.248459.
26. 26 Fuller, Matthew et al. 2008. Software program Research: A Lexicon. Mit Press.
27. 27 Gabriel, Richard P. 1991. “Worse Is Higher.” 1991.https://www.dreamsongs.com/WorseIsBetter.html.
28. 28 Gabriel, Richard P. 2008. “Designed as Designer.” In Proceedings of the twenty third ACMSIGPLAN Convention on Object-Oriented Programming Methods Languages andApplications, 617–32. OOPSLA ’08. New York, NY, USA: Affiliation forComputing Equipment. https://doi.org/10.1145/1449764.1449813.
29. 29 Gabriel, Richard P. 2012. “The Construction of a Programming Language Revolution.” InProceedings of the ACM Worldwide Symposium on New Concepts, NewParadigms, and Reflections on Programming and Software program, 195–214.Onward! 2012. New York, NY, USA: Affiliation for Computing Equipment.https://doi.org/10.1145/2384592.2384611.
30. 30 Gamma, Erich, Richard Helm, Ralph E. Johnson, and John Vlissides. 1995.Design Patterns: Components of Reusable Object-Oriented Software program.Studying, Mass: Addison-Wesley.
31. 31 Glide. 2022. “Glide: Create Apps and Web sites With out Code.”https://www.glideapps.com.
32. 32 Goodenough, John B. 1975. “Exception Dealing with: Points and a ProposedNotation.” Commun. ACM 18 (12): 683–96.https://doi.org/10.1145/361227.361230.
33. 33 Gosling, James, Invoice Pleasure, Man Steele, and Gilad Bracha. 2000. The JavaLanguage Specification. Addison-Wesley Skilled.
34. 34 Grad, Burton. 2007. “The Creation and the Demise of VisiCalc.” IEEEAnnals of the Historical past of Computing 29 (3): 20–31.https://doi.org/10.1109/MAHC.2007.4338439.
35. 35 Inexperienced, T. R. G., and M. Petre. 1996. “Usability Evaluation of VisualProgramming Environments: A ‘Cognitive Dimensions’ Framework.” JOURNALOF VISUAL LANGUAGES AND COMPUTING 7: 131–74.
36. 36 Gulwani, Sumit, William R Harris, and Rishabh Singh. 2012. “SpreadsheetData Manipulation Utilizing Examples.” Communications of the ACM 55 (8):97–105.
37. 37 Hancock, C., and M. Resnick. 2003. “Actual-Time Programming and the BigIdeas of Computational Literacy.” PhD thesis, Massachusetts Institute ofTechnology. https://dspace.mit.edu/handle/1721.1/61549.
38. 38 Hempel, Brian, Justin Lubin, and Ravi Chugh. 2019.“Sketch-n-Sketch: Output-DirectedProgramming for SVG.” In Proceedings of the thirty second Annual ACM Symposiumon Consumer Interface Software program and Expertise, 281–92. UIST ’19. New York,NY, USA: Affiliation for Computing Equipment.https://doi.org/10.1145/3332165.3347925.
39. 39 Hempel, Brian, and Roly Perera. 2020. “LIVE Workshop.” 2020.https://liveprog.org/live-2020/.
40. 40 Hempel, Brian, and Sam Lau. 2021. “LIVE Workshop.” 2021.https://liveprog.org/live-2021/.
41. 41 Hirschfeld, Robert, Hidehiko Masuhara, and Kim Rose, eds. 2010.Workshop on Self-Sustaining Methods, S3 2010, Tokyo, Japan, September27-28, 2010. ACM. https://doi.org/10.1145/1942793.
42. 42 Hirschfeld, Robert, and Kim Rose, eds. 2008. Self-Sustaining Methods,First Workshop, S3 2008, Potsdam, Germany, Could 15-16, 2008, RevisedSelected Papers. Vol. 5146. Lecture Notes in Laptop Science.Springer. https://doi.org/10.1007/978-3-540-89275-5.
43. 43 Ingalls, Daniel. 1981. “Design Ideas Behind Smalltalk.” 1981.https://archive.org/details/byte-magazine-1981-08/page/n299/mode/2up.
44. 44 Kay, A., and A. Goldberg. 1977. “Private Dynamic Media.” Laptop 10(3): 31–41. https://doi.org/10.1109/C-M.1977.217672.
45. 45 Kell, Stephen. 2009. “The Legendary Matched Modules: Overcoming theTyranny of Rigid Software program Development.” In OOPSLA Companion.
46. 46 Kell, Stephen. 2013. “The Working System: Ought to There Be One?” In Proceedingsof the Seventh Workshop on Programming Languages and Working Methods.PLOS ’13. New York, NY, USA: Affiliation for Computing Equipment.https://doi.org/10.1145/2525528.2525534.
47. 47 Kell, Stephen. 2017. “Some Have been Meant for C: The Endurance of an UnmanageableLanguage.” In Proceedings of the 2017 ACM SIGPLAN InternationalSymposium on New Concepts, New Paradigms, and Reflections on Programmingand Software program, 229–45. Onward! 2017. New York, NY, USA: Affiliation forComputing Equipment. https://doi.org/10.1145/3133850.3133867.
48. 48 Kiczales, Gregor, Erik Hilsdale, Jim Hugunin, Mik Kersten, Jeffrey Palm,and William G. Griswold. 2001. “An Overview of AspectJ.” In ECOOP2001 – Object-Oriented Programming, fifteenth European Convention, Budapest,Hungary, June 18-22, 2001, Proceedings, edited by Jørgen LindskovKnudsen, 2072:327–53. Lecture Notes in Laptop Science. Springer.https://doi.org/10.1007/3-540-45337-718.
49. 49 Klein, Ursula. 2003. Experiments, Fashions, Paper Instruments: Cultures ofOrganic Chemistry within the Nineteenth Century. Stanford, CA: StanfordUniversity Press. http://www.sup.org/books/title/?id=1917.
50. 50 Klokmose, Clemens N., James R. Eagan, Siemen Baader, Wendy Mackay, andMichel Beaudouin-Lafon. 2015. “Webstrates: Shareable Dynamic Media.” InProceedings of the twenty eighth Annual ACM Symposium on Consumer Interface Software program& Expertise, 280–90. UIST ’15. New York, NY, USA: Affiliation forComputing Equipment. https://doi.org/10.1145/2807442.2807446.
51. 51 Kluyver, Thomas, Benjamin Ragan-Kelley, Fernando Pérez, Brian Granger,Matthias Bussonnier, Jonathan Frederic, Kyle Kelley, et al. n.d.“Jupyter Notebooks—a Publishing Format for Reproducible ComputationalWorkflows.” Positioning and Energy in Educational Publishing: Gamers,Brokers and Agendas, 87.
52. 52 Knuth, Donald Ervin. 1984. “Literate Programming.” The ComputerJournal 27 (2): 97–111.
53. 53 Kodosky, Jeffrey. 2020. “LabVIEW.” Proc. ACM Program. Lang. 4 (HOPL).https://doi.org/10.1145/3386328.
54. 54 Kuhn, Thomas S. 1970. College of Chicago Press.
55. 55 Kumar, Ranjitha, and Michael Nebeling. 2021. “UIST 2021 – Writer Information.”2021. https://uist.acm.org/uist2021/author-guide.html.
56. 56 Lehman, Meir M. 1980. “Applications, Life Cycles, and Legal guidelines of SoftwareEvolution.” Proceedings of the IEEE 68 (9): 1060–76.
57. 57 Levy, Steven. 1984. Hackers: Heroes of the Laptop Revolution. USA:Doubleday.
58. 58 Lieberman, H. 2001. Your Want Is My Command:Programming by Instance. Morgan Kaufmann.
59. 59 Litt, Geoffrey, Daniel Jackson, Tyler Millis, and Jessica Quaye. 2020.“Finish-Consumer Software program Customization by Direct Manipulation of TabularData.” In Proceedings of the 2020 ACM SIGPLAN Worldwide Symposiumon New Concepts, New Paradigms, and Reflections on Programming andSoftware, 18–33. Onward! 2020. New York, NY, USA: Affiliation forComputing Equipment. https://doi.org/10.1145/3426428.3426914.
60. 60 Marlow, Simon, and Simon Peyton-Jones. 2012. The Glasgow HaskellCompiler. Edited by A. Brown and G. Wilson. The Structure of OpenSource Purposes. CreativeCommons. http://www.aosabook.org.
61. 61 McCarthy, John. 1962. LISP 1.5 Programmer’s Handbook. The MIT Press.
62. 62 Meyerovich, Leo A., and Ariel S. Rabkin. 2012. “Socio-PLT: Principlesfor Programming Language Adoption.” In Proceedings of the ACMInternational Symposium on New Concepts, New Paradigms, and Reflections onProgramming and Software program, 39–54. Onward! 2012. New York, NY, USA:Affiliation for Computing Equipment.https://doi.org/10.1145/2384592.2384597.
63. 63 Michel, Stephen L. 1989. Hypercard: The Full Reference. Berkeley:Osborne McGraw-Hill.
64. 64 Microsoft. 2022. “Language Server Protocol.”https://microsoft.github.io/language-server-protocol/.
65. 65 Monperrus, Martin. 2017. “Ideas of Antifragile Software program.” InCompanion to the First Worldwide Convention on the Artwork, Science andEngineering of Programming. Programming ’17. New York, NY, USA:Affiliation for Computing Equipment.https://doi.org/10.1145/3079368.3079412.
66. 66 Nelson, T. H. 1965. “Complicated Data Processing: A File Structurefor the Complicated, the Altering and the Indeterminate.” In Proceedings ofthe 1965 twentieth Nationwide Convention, 84–100. ACM ’65. New York, NY, USA:Affiliation for Computing Equipment.https://doi.org/10.1145/800197.806036.
67. 67 Noble, James, and Robert Biddle. 2004. “Notes on Notes on PostmodernProgramming.” SIGPLAN Not. 39 (12): 40–56.https://doi.org/10.1145/1052883.1052890.
68. 68 Norman, Donald A. 2002. The Design of On a regular basis Issues. USA: BasicBooks, Inc.
69. 69 Olsen, Dan R. 2007. “Evaluating Consumer Interface Methods Analysis.” InProceedings of the twentieth Annual ACM Symposium on Consumer Interface Softwareand Expertise, 251–58. UIST ’07. New York, NY, USA: Affiliation forComputing Equipment. https://doi.org/10.1145/1294211.1294256.
70. 70 Omar, Cyrus, Ian Voysey, Michael Hilton, Joshua Sunshine, Claire LeGoues, Jonathan Aldrich, and Matthew A. Hammer. 2017.“Towards Semantic Foundations for ProgramEditors.” In 2nd Summit on Advances in Programming Languages(SNAPL 2017), edited by Benjamin S. Lerner, Rastislav Bodík, andShriram Krishnamurthi, 71:11:1–12. Leibniz Worldwide Proceedings inInformatics (LIPIcs). Dagstuhl, Germany: SchlossDagstuhl–Leibniz-Zentrum fuer Informatik.https://doi.org/10.4230/LIPIcs.SNAPL.2017.11.
71. 71 Parnas, David Lorge. 1985. “Software program Elements of Strategic DefenseSystems.” http://web.stanford.edu/class/cs99r/readings/parnas1.pdf.
72. 72 Pawson, Richard. 2004. “Bare Objects.” PhD thesis, Trinity School,College of Dublin.
73. 73 Perlis, A. J., and Ok. Samelson. 1958. “Preliminary Report: InternationalAlgebraic Language.” Commun. ACM 1 (12): 8–22.https://doi.org/10.1145/377924.594925.
74. 74 Petit Emmanuel J. 2013. Irony: Irony or, the Self-Important Opacity of Postmodern Structure. Yale College Press
75. 75 Petricek, Tomas, and Joel Jakubovic. 2021. “Complementary Science ofInteractive Programming Methods.” In Historical past and Philosophy ofComputing.
76. 76 Petricek, Tomas. 2017. “Miscomputation in Software program: Studying to Livewith Errors.” Artwork Sci. Eng. Program. 1 (2): 14.https://doi.org/10.22152/programming-journal.org/2017/1/14.
77. 77 Piumarta, Ian. 2006. “Accessible Language-Primarily based Environments ofRecursive Theories.” 2006.http://www.vpri.org/pdf/rn2006001a_colaswp.pdf.
78. 78 Raymond, Eric S., and Bob Younger. 2001. The Cathedral & the Bazaar:Musings on Linux and Open Supply by an Unintended Revolutionary.O’Reilly.
79. 79 Purpose, James. 1990. Human Error. Cambridge college press.
80. 80 Ryder, Barbara G., Mary Lou Soffa, and Margaret Burnett. 2005. “TheImpact of Software program Engineering Analysis on Fashionable ProgrammingLanguages.” ACM Trans. Softw. Eng. Methodol. 14 (4): 431–77.https://doi.org/10.1145/1101815.1101818.
81. 81 Shneiderman. 1983. “Direct Manipulation: A Step Past ProgrammingLanguages.” Laptop 16 (8): 57–69.https://doi.org/10.1109/MC.1983.1654471.
82. 82 Sitaker, Kragen Javier. 2016. “The Reminiscence Fashions That UnderlieProgramming Languages.” 2016.http://canonical.org/~kragen/memory-models/.
83. 83 Smaragdakis, Yannis. 2019. “Subsequent-Paradigm Programming Languages: WhatWill They Look Like and What Adjustments Will They Carry?” In Proceedingsof the 2019 ACM SIGPLAN Worldwide Symposium on New Concepts, NewParadigms, and Reflections on Programming and Software program, 187–97. Onward!2019. New York, NY, USA: Affiliation for Computing Equipment.https://doi.org/10.1145/3359591.3359739.
84. 84 Smith, Brian Cantwell. 1982. “Procedural Reflection in ProgrammingLanguages.” PhD thesis, Massachusetts Institute of Expertise.https://dspace.mit.edu/handle/1721.1/15961.
85. 85 Smith, D. C. 1975. “Pygmalion: A Inventive Programming Atmosphere.” In.
86. 86 Steele, G., and S. E. Fahlman. 1990. Frequent LISP: The Language. HPTechnologies. Elsevier Science.https://books.google.cz/books?id=FYoOIWuoXUIC.
87. 87 Steele, Man L., and Richard P. Gabriel. 1993. “The Evolution of Lisp.”In The Second ACM SIGPLAN Convention on Historical past of ProgrammingLanguages, 231–70. HOPL-II. New York, NY, USA: Affiliation forComputing Equipment. https://doi.org/10.1145/154766.155373.
88. 88 Tanimoto, Steven L. 2013. “A Perspective on the Evolution of LiveProgramming.” In Proceedings of the first Worldwide Workshop on LiveProgramming, 31–34. LIVE ’13. San Francisco, California: IEEE Press.
89. 89 Tchernavskij, Philip. 2019. “Designing and Programming MalleableSoftware.” PhD thesis, Université Paris-Saclay, École doctorale nº580Sciences et Applied sciences de l’Data et de la Communication (STIC).
90. 90 Teitelman, Warren. 1966. “PILOT: A Step Towards Man-Laptop Symbiosis.”PhD thesis, MIT.
91. 91 Teitelman, Warren. 1974. “Interlisp Reference Handbook.” Xerox PARC. http://www.bitsavers.org/pdf/xerox/interlisp/Interlisp_Reference_Manual_1974.pdf
92. 92 Ungar, David, and Randall B. Smith. 2013. “The Factor on the Display IsSupposed to Be the Precise Factor.” 2013.http://davidungar.net/Live2013/Live_2013.html.
93. 93 Victor, Bret. 2012. “Learnable Programming.” 2012.http://worrydream.com/#!/LearnableProgramming.
94. 94 Wall, Larry. 1999. “Perl, the First Postmodern Laptop Language.” 1999.http://www.wall.org//~larry/pm.html.
95. 95 Winestock, Rudolf. 2011. “The Lisp Curse.” 2011.http://www.winestockwebdesign.com/Essays/Lisp_Curse.html.
96. 96 Wolfram, Stephen. 1991. Mathematica: A System for Doing Arithmetic byComputer (2nd Ed.). USA: Addison Wesley Longman Publishing Co., Inc.
97. 97 Zynda, Melissa Rodriguez. 2013. “The First Killer App: A Historical past ofSpreadsheets.” Interactions 20 (5): 68–72.https://doi.org/10.1145/2509224.
98. 98 desRivieres, J., and J. Wiegand. 2004. “Eclipse: A Platform forIntegrating Improvement Instruments.” IBM Methods Journal 43 (2): 371–83.https://doi.org/10.1147/sj.432.0371.
99. 99 diSessa, A. A, and H. Abelson. 1986. “Boxer: A ReconstructibleComputational Medium.” Commun. ACM 29 (9): 859–68.https://doi.org/10.1145/6592.6595.
100. 100 diSessa, Andrea A. 1985. “A Principled Design for an IntegratedComputational Atmosphere.” Human–Laptop Interplay 1 (1): 1–47.https://doi.org/10.1207/s15327051hci01011.
101. 101 repl.it. 2022. “Replit: The Collaborative Browser-Primarily based IDE.”https://replit.com.
102. 102 workforce, Darkish language. 2022. “Darkish Lang.” https://darklang.com.

Summary

Programming requires way more than simply writing code in a programming language. It’s often performed within the context of a stateful surroundings, by interacting with a system via a graphical person interface. But, this broad area of potentialities lacks a standard construction for navigation. Work on programming programs fails to kind a coherent physique of analysis, making it onerous to enhance on previous work and advance the state-of-the-art.

In laptop science, a lot has been mentioned and performed to permit comparability of programming languages, but no related principle exists for programming programs; we imagine that programming programs deserve a principle too. We current a framework of technical dimensions which seize the underlying traits of programming programs and supply a way for conceptualizing and evaluating them.

We establish technical dimensions by analyzing previous influential programming programs and reviewing their design rules, technical capabilities, and types of person interplay. Technical dimensions seize traits which may be studied, in contrast and superior independently. This makes it doable to speak about programming programs in a means that may be shared and constructively debated moderately than relying solely on private impressions.

Our framework is derived utilizing a qualitative evaluation of previous programming programs. We define two concrete methods of utilizing our framework. First, we present the way it can analyze a not too long ago developed novel programming system. Then, we use it to establish an fascinating unexplored level within the design area of programming programs.

A lot analysis effort focuses on constructing programming programs which might be simpler to make use of, accessible to non-experts, moldable and/or highly effective, however such efforts are disconnected. They’re casual, guided by the non-public imaginative and prescient of their authors and thus are solely evaluable and comparable on the idea of particular person expertise utilizing them. By offering foundations for extra systematic analysis, we can assist programming programs researchers to face, finally, on the shoulders of giants.

Introduction

Associated work

Programming programs

Analysis

Conclusions

Appendices

A scientific presentation removes concepts from the bottom that made them develop and arranges them in a man-made sample.

Paul Feyerabend, The Tyranny of Science 20

Irony is claimed to permit the artist to proceed his artistic manufacturing whereas immersed in a sociocultural context of which he’s crucial.

Emmanuel Petit, Irony; or, the Self-Important Opacity of Postmodernist Structure 74

Many types of software program have been developed to allow programming. The basic kind consists of a programming language, a textual content editor to enter supply code, and a compiler to show it into an executable program. Situations of this manner are differentiated by the syntax and semantics of the language, together with the implementation methods within the compiler or runtime surroundings. Because the creation of graphical person interfaces (GUIs), programming languages may be discovered embedded inside graphical environments that more and more outline how programmers work with the language—for example, by immediately supporting debugging or refactoring. Past this, the rise of GUIs additionally permits various visible types of programming, together with visible languages and GUI-based end-user programming instruments.

This paper advocates a shift of consideration from programming languages to the extra basic notion of “software program that permits programming”—in different phrases, programming programs.

Definition: Programming system.
A programming system is an built-in and full set of instruments ample for creating, modifying, and executing packages. These will embrace notations for structuring packages and information, amenities for working and debugging packages, and interfaces for performing all of those duties. Services for testing, evaluation, packaging, or model management may additionally be current. Notations embrace programming languages and interfaces embrace textual content editors, however aren’t restricted to those.

This notion covers basic programming languages along with their editors, debuggers, compilers, and different instruments. But it’s deliberately broad sufficient to accommodate image-based programming environments like Smalltalk, working programs like UNIX, and hypermedia authoring programs like Hypercard, along with varied different examples we are going to point out.

There’s a rising curiosity in broader types of programming programs, each within the programming analysis neighborhood and in business. Researchers are finding out subjects equivalent to programming expertise and reside programming that require contemplating not simply the language, however additional elements of a given system. On the similar time, industrial firms are constructing new programming environments like Replit 101 or low-code instruments like Darkish 102 and Glide. 31 But, such subjects stay on the sidelines of mainstream programming analysis. Whereas programming languages are a well-established idea, analysed and in contrast in a standard vocabulary, no related basis exists for the broader vary of programming programs.

The tutorial analysis on programming suffers from this lack of frequent vocabulary. Whereas we could totally assess programming languages, as quickly as we add interplay or graphics into the image, analysis past subjective “coolness” turns into fraught with issue. The identical issue within the context of person interface programs has been analyzed by Olsen. 69 Furthermore, when designing new programs, inspiration is commonly drawn from the identical few standalone sources of concepts. These is perhaps influential previous programs like Smalltalk, programmable end-user functions like spreadsheets, or motivational illustrations like these of Bret Victor. 93

As a substitute of forming a strong physique of labor, the concepts that emerge are tough to narrate to one another. The analysis strategies used to check programming programs lack the rigorous construction of programming language analysis strategies. They have a tendency to depend on singleton examples, which exhibit their creator’s concepts, however are insufficient strategies for evaluating new concepts with the work of others. This makes it onerous to construct on high and thereby advance the state-of-the-art.

Learning programming programs shouldn’t be merely about taking a programming language and searching on the instruments that encompass it. It presents a paradigm shift to a perspective that’s, a minimum of partly, incommensurable with that of languages. When finding out programming languages, all the things that issues is in this system code; when finding out programming programs, all the things that issues is within the interplay between the programmer and the system. As documented by Gabriel, 29 a system from a language perspective makes it unattainable to consider ideas that come up from interplay with a system, however aren’t mirrored within the language. Thus, we should proceed with some warning. As we are going to see, after we discuss Lisp as a programming system, we imply one thing very totally different from a parenthesis-heavy programming language!

We suggest a standard language as an preliminary step in direction of a extra progressive analysis on programming programs. Our set of technical dimensions seeks to interrupt down the holistic view of programs alongside varied particular “axes”. The scale establish a variety of doable design selections, characterised by two excessive factors within the design area. They don’t seem to be quantitative, however they permit comparability by finding programs on a standard axis. We don’t intend for the intense factors to symbolize “good” or “unhealthy” designs; we count on any place to be a results of design trade-offs. At this early stage within the lifetime of such a framework, we encourage settlement on descriptions of programs first with a view to settle any normative judgements later.

The set of dimensions may be understood as a map of the design area of programming programs (see diagram). Previous and current programs will function landmarks, and with sufficient of them, we could reveal unexplored or missed potentialities. Thus far, the sphere has not been capable of set up a virtuous cycle of suggestions; it’s onerous for practitioners to situate their work within the context of others’ in order that subsequent work can enhance on it. Our goal is to supply foundations for the examine of programming programs that might enable such growth.

Foremost contributions

The principle contributions of this mission are organized as follows:

1. In Programming systems, we characterize what a programming system is and assessment landmark programming programs of the previous which might be used as examples all through this paper, in addition to to delineate our notion of a programming system.
2. The Catalogue of technical dimensions presents the scale intimately, organised into associated clusters: interplay, notation, conceptual construction, customizability, complexity, errors, and adoptability. For every dimension, we give examples that illustrate the vary of values alongside its axis.
3. In Evaluation, we sketch two methods of utilizing the technical dimensions framework. We first use it to judge a current fascinating programming system Darkish after which use it to establish an unexplored level within the design area and envision a possible novel programming system.

Programming programs positioned in a standard two-dimensional area.
One 2-dimensional slice of the area of doable programs, examined in additional element in
Exploring the design space,
displaying a set of instance programming programs (or system households) measured towards self-sustainability and notational variety,
revealing an absence of programs with a excessive diploma of each.

The numerical scores on every axis are generated systematically
by a technique described in Making dimensions quantitative.
Whereas these outcomes are believable, they aren’t definitive as the tactic might be developed quite a bit additional in future work
(see Remarks and future work).

Whereas we do have new concepts to suggest, a part of our contribution is integrating a variety of present ideas beneath a standard umbrella. This work is unfold out throughout totally different domains, however every half connects to programming programs or focuses on a selected attribute they might have.

Our strategy lies between a slim deal with programming languages and a broad deal with programming as a socio-political and cultural topic. Our idea of a programming system is technical in scope, though we acknowledge the technical aspect typically has necessary social implications as within the case of the Adoptability dimension. This contrasts with the extra socio-political focus present in Tchernavskij 89 or in software program research 26. It overlaps with Kell’s conceptualization of UNIX, Smalltalk, and Working Methods usually, 46 and we’ve ensured that UNIX has a spot in our framework.

The excellence between extra slim programming languages and broader programming programs is extra refined. Richard Gabriel famous an invisible paradigm shift from the examine of “programs” to the examine of “languages” in laptop science, 29 and this statement informs our distinction right here. One consequence of the change is {that a} language is commonly formally specified aside from any particular implementations, whereas programs resist formal specification and are sometimes outlined by an implementation. We acknowledge programming language implementations as a small area of the area of doable programs, a minimum of so far as interplay and notations may go. Therefore we check with the interactive programming system elements of languages, equivalent to textual content modifying and command-line workflow.

There may be renewed curiosity in programming programs within the type of non-traditional programming instruments:

• Computational notebooks equivalent to Jupyter 51 facilitate information evaluation by combining code snippets with textual content and visible output. They’re backed by stateful “kernels” and used interactively.
• “Low code” end-user programming programs enable utility growth (principally) via a GUI. One instance is Coda, 14 which mixes tables, formulation, and scripts to allow non-technical folks to construct “functions as paperwork”.
• Area-specific programming programs equivalent to Darkish, 102 which claims a “holistic” programming expertise for cloud API companies. This features a language, a direct manipulation editor, and near-instantaneous constructing and deployment.
• Even for basic objective programming with standard instruments, programs like Replit 101 have demonstrated the advantages of integrating all wanted languages, instruments, and person interfaces right into a seamless expertise, out there from the browser, that requires no setup.

Analysis that follows the programming programs perspective may be present in a variety of analysis venues. These embrace Human-Laptop Interplay conferences equivalent to UIST (ACM Symposium on Consumer Interface Software program and Expertise) and VL/HCC (IEEE Symposium on Visible Languages and Human-Centric Computing). Nonetheless, work in these typically emphasizes the person expertise over technical description. Programming programs are sometimes offered in workshops equivalent to LIVE and PX (Programming eXperience). Nonetheless, work in these venues is commonly restricted to the authors’ particular person views and suffers from the aforementioned issue of evaluating to different programs.

Concrete examples of programs seem all through the paper. Current programs which motivated a few of our dimensions embrace Subtext, 18 which mixes code with its reside execution in a single editable illustration; Sketch-n-sketch, 38 which may synthesize code by direct manipulation of its outputs; Hazel, 70 a reside purposeful programming surroundings with typed holes to allow execution of incomplete or ill-typed packages; and Webstrates, 50 which extends Net pages with real-time sharing of state.

There are a number of present tasks figuring out traits of programming programs. Some revolve round a single one, equivalent to ranges of liveness, 88 or plurality and communicativity. 47 Others suggest a complete assortment. Reminiscence Fashions of Programming Languages 82 identifies the “all the things is an X” metaphors underlying many programming languages; the Design Ideas of Smalltalk 43 paperwork the philosophical objectives and dicta used within the design of Smalltalk; the “Gang of 4” Design Patterns 30 catalogues particular implementation ways; and the Cognitive Dimensions of Notation 35 introduces a standard vocabulary for software program’s notational floor and for figuring out their trade-offs.

The latter two immediately affect our proposal. Firstly, the Cognitive Dimensions are a set of qualitative properties which can be utilized to research notations. We’re extending this strategy to the “relaxation” of a system, past its notation, with Technical Dimensions. Secondly, our particular person dimensions naturally fall beneath bigger clusters that we current in an everyday format, much like the presentation of the basic Design Patterns. As for traits recognized by others, a part of our contribution is to combine them beneath a standard umbrella: the prevailing ideas of liveness, pluralism, and uniformity metaphors (“all the things is an X”) grow to be dimensions in our framework.

We observe the perspective of Evaluating Programming Methods 16 in distinguishing our work from HCI strategies and empirical analysis. We’re usually involved with traits that aren’t clearly amenable to statistical evaluation (e.g. mining software program repositories) or experimental strategies like managed person research, so numerical portions are usually not featured.

Comparable growth appears to be happening in HCI analysis centered on person interfaces. The UIST tips 55 instruct authors to judge system contributions holistically, and the neighborhood has developed heuristics for such analysis, equivalent to Evaluating Consumer Interface Methods Analysis. 69 Our set of dimensions gives related heuristics for figuring out fascinating elements of programming programs, although they focus extra on underlying technical properties than the floor interface.

Lastly, we imagine that the aforementioned paradigm shift from programming programs to programming languages has hidden many concepts about programming which might be worthwhile recovering and creating additional. 75 Thus our strategy is said to the concept of complementary science developed by Chang 10 within the context of historical past and philosophy of science. Chang argues that even in disciplines like physics, outmoded or falsified theories should include fascinating concepts price documenting. Within the subject of programming, the place previous programs are discarded for a lot of causes apart from empirical failure, Chang’s complementary science strategy appears notably appropriate.

Programming programs deserve a principle too!

In brief, whereas there’s a principle for programming languages, programming programs deserve a principle too. It ought to apply from the small scale of language implementations to the huge scale of working programs. It ought to be doable to analyse the frequent and distinctive options of various programs, to disclose new potentialities, and to construct on previous work in an efficient method. In Kuhnian phrases, 54 it ought to allow a physique of “regular science”: filling within the map of the area of doable programs, thereby forming a data repository for future designers.

We introduce the notion of a programming system via a variety of instance programs. We draw them from three broad reference lessons:

• Software program ecosystems constructed round a text-based programming language. They include a set of instruments equivalent to compilers, debuggers, and profilers. These instruments could exist as separate command-line packages, or inside an Built-in Improvement Atmosphere.

• People who resemble an working system (OS) in that they construction the execution surroundings and embody the sources of a complete machine (bodily or digital). They supply a standard interface for communication, each between the person and the pc, and between packages themselves.

• Programmable functions, usually optimized for a selected area, providing a restricted diploma of programmability which can be elevated with newer variations.

It have to be famous that our number of programs shouldn’t be meant to be exhaustive; there shall be many previous and current programs that we aren’t conscious of or have no idea a lot about, and we clearly can’t cowl programming programs that haven’t been created but. With that caveat, we are going to proceed to element some programs beneath the above grouping. This can present an instinct for the notion of a programming system and set up a group of go-to examples for the remainder of the paper.

Textual content-based programming languages sit inside programming programs whose boundaries aren’t explicitly outlined. To talk of a programming system, we have to contemplate a language with, at minimal, an editor and a compiler or interpreter. Nonetheless, the precise boundaries are a design alternative that considerably impacts our evaluation.

Java with the Eclipse ecosystem

Java 33 can’t be considered as a programming system by itself, however it’s one if we contemplate it as embedded in an ecosystem of instruments. There are a number of methods to delineate this, leading to totally different analyses. A minimalistic programming system would include a textual content editor to put in writing Java code and a command line compiler. A extra reasonable system is Java as embedded within the Eclipse IDE. 98 The programming programs view permits us to see all there may be past the textual code. Within the case of Eclipse, this contains the debugger, refactoring instruments, testing and modelling instruments, GUI designers, and so forth. This delineation yields a programming system that’s highly effective and handy, however has numerous ideas and secondary notations.

Haskell instruments ecosystem

Haskell is an much more language-focused programming system. It’s used via the command-line GHC compiler 60 and GHCi REPL, alongside a textual content editor that gives options like syntax highlighting and auto-completion. Any editor that helps the Language Server Protocol 64 will suffice to finish the programming system.

Haskell is mathematically rooted and depends on mathematical instinct for understanding lots of its ideas. This background can be mirrored within the notations it makes use of. Along with the concrete language syntax for writing code, the ecosystem additionally makes use of a casual mathematical notation for writing about Haskell (e.g. in educational papers or on the whiteboard). This gives a further device for manipulating Haskell packages. Experiments on paper can present a form of fast suggestions that different programs could present via reside programming.

From REPLs to notebooks

A special form of developer ecosystem that developed round a programming language is the Jupyter pocket book platform. 51 In Jupyter, information scientists write scripts divided into pocket book cells, execute them interactively and see the ensuing information and visualizations immediately within the pocket book itself. This brings collectively the REPL, which dates again to conversational implementations of Lisp within the Nineteen Sixties, with literate programming 52 used within the late Eighties in Mathematica 1.0. 96

As a programming system, Jupyter has a variety of fascinating traits. The first consequence of programming is the pocket book itself, moderately than a separate utility to be compiled and run. The code lives in a doc format, interleaved with different notations. Code is written in small elements which might be executed shortly, providing the person extra fast suggestions than in standard programming. A pocket book may be seen as a hint of how the end result has been obtained, but one typically problematic characteristic of notebooks is that some enable the person to run code blocks out-of-order. The code manipulates mutable state that exists in a “kernel” working within the background. Thus, retracing one’s steps in a pocket book is extra refined than in, say, Frequent Lisp, 86 the place the dribble perform would immediately report the person’s session to a file.

“OS-likes” start from the Nineteen Sixties when it turned doable to work together one-on-one with a pc. First, time-sharing programs enabled interactive shared use of a pc by way of a teletype; smaller computer systems such because the PDP-1 and PDP-8 offered related direct interplay, whereas Nineteen Seventies workstations such because the Alto and Lisp Machines added graphical shows and mouse enter. These OS-like programs stand out as having the totalising scope of working programs, whether or not or not they’re ordinarily seen as taking this position.

MacLisp and Interlisp

LISP 1.5 61 arrived earlier than the rise of interactive computer systems, however the existence of an interpreter and the absence of declarations made it pure to make use of Lisp interactively, with the primary such implementations showing within the early Nineteen Sixties. Two branches of the Lisp household, 87 MacLisp and the later Interlisp, embraced the interactive “conversational” means of working, first via a teletype and later utilizing the display screen and keyboard.

Each MacLisp and Interlisp adopted the concept of persistent tackle area. Each program code and program state have been preserved when powering off the system, and might be accessed and modified interactively in addition to programmatically utilizing the similar means. Lisp Machines embraced the concept that the machine runs frequently and saves the state to disk when wanted. At this time, that is broadly seen in cloud-based companies like Google Docs and on-line IDEs. One other thought pioneered in MacLisp and Interlisp was the usage of construction editors. These let programmers work with Lisp information constructions not as sequences of characters, however as nested lists. In Interlisp, the programmer would use instructions equivalent to *P to print the present expression, or *(2 (X Y)) to interchange its second component with the argument (X Y). The PILOT system 90 supplied much more subtle conversational options. For typographical errors and different slips, it might provide an computerized repair for the person to interactively settle for, modifying this system in reminiscence and resuming execution.

Smalltalk

Smalltalk appeared within the Nineteen Seventies with a definite ambition of offering “dynamic media which can be utilized by human beings of all ages”. 44 The authors noticed computer systems as meta-media that might grow to be a variety of different media for training, discourse, artistic arts, simulation and different functions not but invented. Smalltalk was designed for single-user workstations with a graphical show, and pioneered this show not only for functions but in addition for programming itself. In Smalltalk 72, one wrote code within the backside half of the display screen utilizing a construction editor managed by a mouse, and menus to edit definitions. In Smalltalk-76 and later, this had switched to textual content modifying embedded in a class browser for navigating via lessons and their strategies.

Equally to Lisp programs, Smalltalk adopts the persistent tackle area mannequin of programming the place all objects stay in reminiscence, however based mostly on objects and message passing moderately than lists. Any modifications made to the system state by programming or execution are preserved when the pc is turned off. Lastly, the truth that a lot of the Smalltalk surroundings is applied in itself makes it doable to extensively modify the system from inside.

We embrace Lisp and Smalltalk within the OS-likes as a result of they perform as working programs in some ways. On specialised machines, just like the Xerox Alto and Lisp machines, the person began their machine immediately within the Lisp or Smalltalk surroundings and was capable of do all the things they wanted from inside the system. These days, nevertheless, this expertise is related to UNIX and its descendants on an unlimited vary of commodity machines.

UNIX

UNIX illustrates the truth that many elements of programming programs are formed by their meant audience. Constructed for laptop hackers, 57 its abstractions and interface are near the machine. Though traditionally linked to the C language, UNIX developed a language-agnostic set of abstractions that make it doable to make use of a number of programming languages in a single system. Whereas all the things is an object in Smalltalk, the ontology of the UNIX system consists of recordsdata, reminiscence, executable packages, and working processes. Notice the specific “stage” distinction right here: UNIX distinguishes between unstable reminiscence constructions, that are misplaced when the system is shut down, and non-volatile disk constructions which might be preserved. This distinction between kinds of reminiscence is taken into account, by Lisp and Smalltalk, to be an implementation element to be abstracted over by their persistent tackle area. Nonetheless, this didn’t stop the UNIX ontology from supporting a pluralistic ecosystem of various languages and instruments.

Early and trendy Net

The Net developed 1 from a system for sharing and organizing info to a programming system. At this time, it consists of a variety of server-side programming instruments, JavaScript and languages that compile to it, and notations like HTML and CSS. As a programming system, the “trendy 2020s internet” in all fairness distinct from the “early Nineties internet”. Within the early internet, JavaScript code was distributed in a kind that made it straightforward to repeat and re-use present scripts, which led to enthusiastic adoption by non-experts—recalling the delivery of microcomputers like Commodore 64 with BASIC a decade earlier.

Within the “trendy internet”, a number of programming languages deal with JavaScript as a compilation goal, and JavaScript can be used as a language on the server-side. This internet is not easy sufficient to encourage copy-and-paste remixing of code from totally different websites. Nonetheless, it does include superior developer instruments that present performance resembling early interactive programming programs like Lisp and Smalltalk. The Doc Object Mannequin (DOM) construction created by an online web page is clear, accessible to the person and modifiable via the built-in browser inspector instruments. Third-party code to switch the DOM may be injected by way of extensions. The DOM nearly resembles the tree/graph mannequin of Smalltalk and Lisp pictures, missing the important thing persistence property. This limitation, nevertheless, is being addressed by Webstrates. 50

The beforehand mentioned programming programs have been both common, not specializing in any specific form of utility, or focused at broad fields, equivalent to Synthetic Intelligence and symbolic information manipulation in Lisp’s case. In distinction, the next examples deal with extra slim sorts of functions that have to be constructed. Many assist programming based mostly on wealthy interactions with specialised visible and textual notations.

Spreadsheets

The primary spreadsheets turned out there in 1979 in VisiCalc 34 97 and helped analysts carry out price range calculations. As programming programs, spreadsheets are notable for his or her programming substrate (a two-dimensional grid) and analysis mannequin (computerized re-evaluation). The programmability of spreadsheets developed over time, buying options that made them into highly effective programming programs in a means VisiCalc was not. The ultimate step was the 1993 inclusion of macros in Excel, later additional prolonged with Visible Primary for Purposes.

Graphical “languages”

Efforts to assist programming with out counting on textual code can solely be referred to as “languages” in a metaphorical sense. In these programming programs, packages are made out of graphical constructions as in LabView 53 or Programming-By-Instance. 58

HyperCard

Whereas spreadsheets have been designed to resolve issues in a selected utility space, HyperCard 63 was designed round a selected utility format. Applications are “stacks of playing cards” containing multimedia parts and controls equivalent to buttons. These controls may be programmed with pre-defined operations like “navigate to a different card”, or by way of the HyperTalk scripting language for something extra subtle.

As a programming system, HyperCard is fascinating for a few causes. It successfully combines visible and textual notation. Applications seem the identical means throughout modifying as they do throughout execution. Most notably, HyperCard helps gradual development from the “person” position to “developer”: a person could first use stacks, then go on to edit the visible elements or select pre-defined logic till, finally, they be taught to program in HyperTalk.

The technical dimensions ought to be evaluated on the idea of how helpful they’re for designing and analysing programming programs. To that finish, this part demonstrates two makes use of of the framework. First, we use the scale to research the current programming system Darkish, 102 explaining the way it pertains to previous work and the way it contributes to the state-of-the-art. Second, we use technical dimensions to establish a brand new unexplored level within the design area of programming programs and envision a brand new design that might emerge from the evaluation.

A screenshot of the Darkish programming system.
The screenshot reveals a easy internet service in Darkish consisting of two HTTP endpoints (1, 2), a database (3), and a employee (4)
(image source)

Darkish is a programming system for constructing “serverless backends”, i.e. companies which might be utilized by internet and cellular functions. It goals to make constructing such companies simpler by “eradicating unintended complexity” (see Goals of Dark v2) ensuing from the massive variety of programs usually concerned of their deployment and operation. This contains infrastructure for orchestration, scaling, logging, monitoring and versioning. Darkish gives built-in tooling for growth and is described as deployless, that means that deploying code to manufacturing is instantaneous.

Darkish illustrates the necessity for the broader perspective of programming programs. After all, it accommodates a programming language, which is impressed by OCaml and F#. However Darkish’s distinguishing characteristic is that it eliminates the numerous secondary programs wanted for deployment of contemporary cloud-based companies. These exist outdoors of a typical programming language, but kind a significant a part of the complexity of the general growth course of.

With technical dimensions, we are able to transcend the “gross sales pitch”, look behind the scenes, and higher perceive the fascinating technical elements of Darkish as a programming system. The desk beneath summarises the extra detailed evaluation that follows. Two clear advantages of such an evaluation are:

1. It gives a listing of subjects to analyze when analyzing a programming system equivalent to Darkish.
2. It give us a standard vocabulary for these subjects that can be utilized to check Darkish with different programs on the identical phrases.

Positioning Darkish within the design area

The next desk gives a concise abstract of the place Darkish lies on its distinguishing dimensions. For brevity, dimensions the place Darkish doesn’t differ from odd programming are omitted.
A extra detailed dialogue may be discovered within the Dimensional analysis of Dark.

Technical improvements of Darkish

This evaluation reveals a variety of fascinating elements of the Darkish programming system. The primary is the tight integration of various modes of interplay which collapses a heterogeneous stack of applied sciences, makes Darkish learnable, and permits fast suggestions from deployed companies. The second is the usage of error response to information the event of HTTP handlers. Because of the technical dimensions framework, every of those may be extra exactly described. Additionally it is doable to see how they might be supported in different programming programs. The framework additionally factors to doable options (and maybe enhancements) equivalent to constructing a extra self-sustainable system that has related traits to Darkish, however permits higher flexibility in modifying the platform from inside itself.

Modes of interplay and suggestions loops

Standard modes of interaction embrace working, modifying and debugging. For contemporary internet companies, working refers to operation in a cloud-based surroundings that usually comes with additional sorts of suggestions (logging and monitoring). The important thing design resolution of Darkish is to combine all these totally different modes of interplay right into a single one. This tight integration permits Darkish to supply a extra instant feedback loop the place code modifications grow to be instantly out there not simply to the developer, but in addition to exterior customers. The built-in mode of interplay is harking back to the image-based surroundings in Smalltalk; Darkish advances the state of artwork through the use of this mannequin in a multi-user, cloud-based context.

Suggestions loops and error response

The combination of growth and operation additionally makes it doable to make use of errors occurring throughout operation to drive growth. Particularly, when a Darkish service receives a request that’s not supported, the person can construct a handler 13 to supply a response—making the most of the reside information that was despatched as a part of the request. When it comes to our dimensions, this can be a form of error response that was pioneered by the PILOT system for Lisp. 90 Darkish does this not simply to answer errors, but in addition as the first growth mechanism, which we would name Error-Pushed Improvement. This manner, Darkish customers can assemble packages with respect to pattern enter values.

Conceptual construction and learnability

Darkish packages are expressed utilizing high-level ideas which might be particular to the area of server-side internet programming: HTTP request handlers, databases, staff and scheduled jobs. These are designed to scale back unintended complexity and goal for prime conceptual integrity. On the degree of code, Darkish makes use of a general-purpose purposeful language that emphasizes sure ideas, particularly data and pipelines. The high-level ideas contribute to learnability of the system, as a result of they’re extremely domain-specific and can already be acquainted to its meant customers.

Notational construction and uniformity

Darkish makes use of a mix of graphical editor and code. The 2 elements of the notation observe the complementing notations sample. The windowed interface is used to work with the high-level ideas and code is used for working with low-level ideas. On the excessive degree, code is structured in freely positionable packing containers on a 2D floor. In contrast to Boxer, 99 these packing containers don’t nest and the area can’t be used for different content material (say, for feedback, architectural illustrations or different media). Code on the low degree is manipulated utilizing a syntax-aware construction editor, displaying inferred varieties and computed reside values for pure features. It additionally gives particular modifying assist for data and pipelines, permitting customers so as to add fields and steps respectively.

Factoring of complexity and automation

One of many marketed objectives of Darkish is to take away unintended complexity. That is achieved by collapsing the heterogeneous stack of applied sciences which might be usually required for growth, cloud deployment, orchestration and operation. Darkish hides this by way of factoring of complexity. The superior infrastructure is offered by the Darkish platform and is hidden from the person. The infrastructure is programmed explicitly and there’s no want for classy automation. This factoring of performance that was beforehand coded manually follows an identical sample as the event of rubbish assortment in high-level programming languages.

Customizability

The Darkish platform makes a transparent distinction between the platform itself and the person utility, so self-sustainability shouldn’t be an goal. The strict division between the platform and person (associated to its aforementioned factoring of complexity) implies that modifications to Darkish require modifying the platform supply code itself, which is obtainable beneath a license that solely permits utilizing it for the aim of contributing. Equally, functions themselves are developed by modifying and including code, requiring harmful entry to it—so additive authoring shouldn’t be exhibited at both degree. Because of the combination of execution and growth, persistent modifications could also be made throughout execution (c.f. staging of customization however that is performed via the Darkish editor, which is separate from the working service.

With just a little work, technical dimensions can allow us to see patterns or gaps within the design area by plotting their values on a easy scatterplot. Right here, we are going to take a look at two dimensions, notational variety (that is merely uniformity of notations, however flipped in the wrong way) and self-sustainability, for the next programming programs: Haskell, Jupyter notebooks, Boxer, HyperCard, the Net, spreadsheets, Lisp, Smalltalk, UNIX, and COLAs. 77

Whereas our alternative to explain dimensions as qualitative ideas was vital for developing with them, some means of producing numbers is clearly vital for visualizing their relationships like this. For simplicity, we undertake the next scheme. For every dimension, we distill the primary thought into a number of sure/no questions (as mentioned in the appendix) that seize sufficient of the distinctions we observe between the programs we want to plot. Then, for every system, we add up the variety of “sure” solutions and procure a believable rating for the dimension.

The diagram (click on for a bigger version) reveals the outcomes we obtained with our units of questions. It reveals that application-focused programs span a variety of notational variety, however solely inside pretty low self-sustainability. The OS-likes cluster in an “island” on the proper, sharing an identical notational variety and near-identical self-sustainability.

There may be additionally a conspicuous clean area on the top-right, representing an unexplored mixture of excessive values on each dimensions. With different pairs of dimensions, we would take this as proof of an oppositional relationship, such that extra of 1 inherently means much less of the opposite (maybe in search of a single new dimension that describes this higher.) On this case, although, there isn’t any apparent battle between having many notations and with the ability to change a system from inside. Subsequently, we interpret the hole as a brand new alternative to check out: mix the self-sustainability of COLAs with the notational variety of Boxer and Net growth. In reality, this is kind of the forthcoming dissertation of the first creator.

There’s a renewed curiosity in creating new programming programs. Such programs transcend the easy mannequin of code written in a programming language utilizing a roughly subtle textual content editor. They mix textual and visible notations, create packages via wealthy graphical interactions, and problem accepted assumptions about program modifying, execution and debugging. Regardless of the rising variety of novel programming programs, it stays tough to judge the design of programming programs and see how they enhance over work performed previously. To handle the difficulty, we proposed a framework of “technical dimensions” that captures important traits of programming programs in a qualitative however rigorous means.

The framework of technical dimensions places the huge number of programming programs, previous and current, on a standard footing of commensurability. That is essential to allow the strengths of every to be recognized and, if doable, mixed by designers of the following era of programming programs. As an increasing number of programs are assessed within the framework, an image of the area of potentialities will step by step emerge. Some areas shall be conspicuously empty, indicating unrealized potentialities that might be price attempting. On this means, a site of “regular science” is created for the design of programming programs.

Acknowledgments

We notably thank Richard Gabriel for shepherding our submission to the 2021 Sample Languages of Programming (PLoP) convention. We thank the individuals of the PLoP Writers’ Workshop for his or her suggestions, in addition to others who’ve proofread or in any other case given enter on the concepts at totally different phases. These embrace Luke Church, Filipe Correia, Thomas Inexperienced, Brian Hempel, Clemens Klokmose, Geoffery Litt, Mariana Mărășoiu, Stefan Marr, Michael Weiss, and Rebecca and Allen Wirfs-Brock. We additionally thank the attendees of our Programming 2021 Dialog Starters session and our Programming 2022 tutorial/workshop entitled “Methodology Of Programming Methods” (MOPS).

This work was partially supported by the mission of Czech Science Basis no. 23-06506S.

To generate numerical co-ordinates for self-sustainability and notational variety, we break up each dimensions right into a small variety of sure/no questions and counted the “sure” solutions for every system. We got here up with the questions informally, with the aim of reaching three issues:

1. To seize the fundamental concepts or options of the dimension
2. To make prior impressions extra exact (i.e. to roughly match the place we intuitively felt sure key programs match, however present precision and doable surprises for programs we weren’t as assured about.)
3. To be the fewest in quantity vital to achieve the above

The next sections focus on the questions, together with a short rationale for every query. This additionally raises a variety of factors for future work that we focus on beneath.

Questions

1. Are you able to add new gadgets to system namespaces with out a restart? The canonical instance of that is in JavaScript, the place “built-in” lessons like Array or Object may be augmented at will (and destructively modified, however that might be a separate level). Concretely, if a person needs to make a brand new sum operation out there to all Arrays, they aren’t prevented from straightforwardly including the tactic to the Array prototype as if it have been simply an odd object (which it’s). Having to re-compile and even restart the system would imply that this can’t be meaningfully achieved from inside the system. Conversely, with the ability to do which means that even “built-in” namespaces are modifiable by odd packages, which signifies much less of a implementation degree vs. person degree divide and appears necessary for self-sustainability.
2. Can packages generate packages and execute them? This property, associated to “code as information” or the presence of an eval() perform, is a key requirement of self-sustainability. In any other case, re-programming the system, past deciding on from a predefined listing of behaviors, would require modifying an exterior illustration and restarting it. If customers can kind textual content contained in the system then they are going to be capable of write code—yet this code shall be inert except the system can interpret inside information constructions as packages and truly execute them.
3. Are modifications persistent sufficient to encourage indefinite evolution? If preliminary tinkering or later progress may be reset by by accident closing a window, or preserved solely via a convoluted course of, then this discourages any long-term enchancment of a system from inside. For instance, when creating a JavaScript utility with internet browser developer instruments, it’s doable to run arbitrary JavaScript within the console, but these modifications apply solely to the working occasion. After tinkering within the console with the benefit of concrete system state, one should nonetheless return to the supply code file and make the corresponding modifications manually. When the web page is refreshed to load the up to date code, it begins from a contemporary preliminary state. This implies it’s not price utilizing the working system for any programming past tinkering.
4. Are you able to reprogram low-level infrastructure inside the working system? This can be a hopefully trustworthy abstract of how the COLAs work goals to transcend Lisp and Smalltalk on this dimension.
5. Can the person interface be arbitrarily modified from inside the system? Whether or not classed as “low-level infrastructure” or not, the visible and interactive elements of a system are a big a part of it. As such, they have to be as open to re-programming as some other a part of it to categorise as really self-sustainable.

System analysis

Questions

1. Are there a number of syntaxes for textual notation? Clearly, having multiple textual notation ought to rely for notational variety. Nonetheless, for this dimension we wish to bear in mind notations past the strictly textual, so we don’t want this to be the one related query. Ideally, issues ought to be weighted in order that having a large variety of notations inside some slim class shouldn’t be mistaken for notational variety in a extra world sense. We wish to mirror that UNIX, with its huge array of various languages for various conditions, can by no means be as notationally various as a system with many languages and many graphical notations, for instance.
2. Does the system make use of GUI parts? This can be a centered class of non-textual notations that lots of our instance programs exhibit.
3. Is it doable to view and edit information as tree constructions? Tree constructions are frequent in programming, however they’re often labored with as textual content in a roundabout way. A couple of of our examples present a graphical notation for this frequent information construction, so that is a method they are often differentiated from the remainder.
4. Does the system enable freeform association and sizing of information gadgets? We nonetheless felt Boxer and spreadsheets exhibited one thing not lined by the earlier three questions, which is that this. Inside their respective constraints of rendering timber as nested packing containers and single-level grids, they each present for notational variation that may be helpful to the person’s context. These programs may have determined to maintain packing containers neatly positioned or cells all the identical dimension, however the truth that they permit these to range scores a further level for notational variety.

System analysis

This job of quantifying dimensions compelled us to drill down and determine on extra crisp definitions of what they need to be. We advocate it as a helpful train even within the absence of a aim like producing a graph.

It’s price clarifying the that means of what we’ve performed right here. It should not be missed that this settling down on one specific definition doesn’t exchange or out of date the overall qualitative descriptions of the scale that we begin with. Clearly, there are far too many sources of variation in our course of to think about our outcomes right here as ultimate, goal, the one appropriate definition of those dimensions, or something on this vein. Every of those sources of variation suggests future work for events:

Quantification objectives

We sought numbers to generate a graph that roughly matched our personal intuitive placement of a number of instance programs. In different phrases, we have been attempting to make these intuitions extra exact together with the scale themselves. A wholly totally different strategy can be to don’t have any “anchor” in any respect, and to take no matter solutions a given definition produces as floor fact. Nonetheless, this could demand extra element for answering questions and producing them within the first place.

Query era

We generated our questions informally and stopped when it appeared like there have been sufficient to make the necessary distinctions between instance factors. There may be big room for variation right here, although it appears notably onerous to generate questions in any rigorous method. Maybe we may take our self-sustainability inquiries to be drawn from a big set of “actions you may carry out whereas the system is working”, which might be parametrized extra simply. Equally, our notational variety questions tried to bear in mind a couple of lessons of notations—a extra subtle strategy is perhaps to simply rely the notations in a variety of lessons.

Answering the questions

We answered our questions by coming to a consensus on what made sense to the three of us. Others could disagree with these solutions, and tracing the supply of disagreement may yield insights for various questions that each events would reply identically. Helpful info is also obtained from getting many alternative folks to reply the questions and seeing how a lot variation there may be.

What’s “Lisp”, anyway?

The ultimate main supply of variation can be the labels we’ve assigned to instance factors. In some instances (Boxer), there actually is just one system; in others (spreadsheets) there are a number of totally different merchandise with totally different names, but that are nonetheless related sufficient to plausibly analyze as the identical factor; in nonetheless others (Lisp) we’re treating a household of associated programs as a cohesive level within the design area. It’s comprehensible if some assume this elides too many necessary distinctions. On this case, they might suggest splits into totally different programs or sub-families, and even recommend how these households ought to be handled as blobs inside varied sub-spaces.

A programming system is an built-in set of instruments ample for creating, modifying, and executing packages.
The basic form of programming system consists of a programming language with a textual content editor and a compiler, however
programming programs can be constructed round interactive graphical person interfaces, present varied diploma of
integration between the runtime execution surroundings and leverage graphical notations.
Our notion accomodates examples from three broad lessons of programs.

• Methods based mostly round languages.
  Software program ecosystems constructed round a text-based programming language. They include a set of instruments equivalent to compilers, debuggers, and profilers, accessible both via a command-line or a growth surroundings.
  Read more in the paper…

• OS-like programming programs.
  People who resemble an working system in that they management each the execution surroundings and the sources of a complete machine. They supply a standard interface for communication between packages and with the person.
  Read more in the paper…

• Software-focused programs.
  Programmable functions, usually optimized for a selected area, providing a restricted diploma of programmability, which can be elevated with newer variations.
  Read more in the paper…