Interdisciplinary programming language design

ABSTRACT

Approaches for programming language design used commonly in the research community today center around theoretical and performance-oriented evaluation. Recently, researchers have been considering more approaches to language design, including the use of quantitative and qualitative user studies that examine how different designs might affect programmers. In this paper, we argue for an interdisciplinary approach that incorporates many different methods in the creation and evaluation of programming languages. We argue that the addition of user-oriented design techniques can be helpful at many different stages in the programming language design process.

References

1. Jonathan Aldrich, Craig Chambers, and David Notkin. 2002. ArchJava: Connecting Software Architecture to Implementation. In Proceedings of the 24th International Conference on Software Engineering (ICSE ’02) . ACM, New York, NY, USA, 187–197.
2. Celeste Barnaby, Michael Coblenz, Tyler Etzel, Eliezer Kanal, Joshua Sunshine, Brad Myers, and Jonathan Aldrich. 2017. A User Study to Inform the Design of the Obsidian Blockchain DSL. In PLATEAU ’17 Workshop on Evaluation and Usability of Programming Languages and Tools .
3. Nels E. Beckman. 2010. Types for Correct Concurrent API Usage. Ph.D. Dissertation. Carnegie Mellon University, 5000 Forbes Ave., Pittsburgh, PA, USA. CMU-ISR-10-131.
4. Nels E. Beckman, Duri Kim, and Jonathan Aldrich. 2011. An Empirical Study of Object Protocols in the Wild. In European Conference on Object-Oriented Programming .
5. E. D. Berger, S. M. Blackburn, M. Hauswirth, and M. Hicks. 2018. Empirical Evaluation Checklist (beta). http://www.sigplan.org/Resources/ EmpiricalEvaluation/
6. Yves Bertot and Pierre Castran. 2010. Interactive Theorem Proving and Program Development: Coq’Art The Calculus of Inductive Constructions (1st ed.). Springer Publishing Company, Incorporated.
7. Kevin Bierhoff. 2009. API Protocol Compliance in Object-Oriented Software . Ph.D. Dissertation. Carnegie Mellon University, 5000 Forbes Ave., Pittsburgh, PA, USA. CMU-ISR-09-108.
8. Kevin Bierhoff and Jonathan Aldrich. 2007. Modular Typestate Checking of Aliased Objects. In Proceedings of the 22Nd Annual ACM SIG-PLAN Conference on Object-oriented Programming Systems and Applications (OOPSLA ’07) . ACM, New York, NY, USA, 301–320.
9. Susanne Bødker and Ole Sejer Iversen. 2002. Staging a Professional Participatory Design Practice: Moving PD Beyond the Initial Fascination of User Involvement. In Proceedings of the Second Nordic Conference on Human-computer Interaction (NordiCHI ’02) . ACM, New York, NY, USA, 11–18.
10. John Boyland, James Noble, and William Retert. 2001. Capabilities for Aliasing: A Generalisation of Uniqueness and Read-Only. In European Conference on Object-Oriented Programming , Jørgen Lindskov Knudsen (Ed.).
11. Bill Buxton. 2007. Sketching user experiences: getting the design right and the right design . Morgan Kaufmann.
12. Oscar Callaú, Romain Robbes, Éric Tanter, and David Röthlisberger. 2011. How Developers Use the Dynamic Features of Programming Languages: The Case of Smalltalk. In Proceedings of the 8th Working Conference on Mining Software Repositories (MSR ’11) . ACM, New York, NY, USA, 23–32.
13. Don Chamberlin. 2012. Early History of SQL. IEEE Ann. Hist. Comput. 34, 4 (Oct. 2012), 78–82.
14. Sarah Chasins. 2012. An Efficient Implementation of the Plaid Language. Honors thesis. Swarthmore College Honors Thesis.
15. Michael Coblenz, Whitney Nelson, Jonathan Aldrich, Brad Myers, and Joshua Sunshine. 2017. Glacier: Transitive Class Immutability for Java. In Proceedings of the 39th International Conference on Software Engineering - ICSE ’17 .
16. Michael Coblenz, Joshua Sunshine, Jonathan Aldrich, Brad Myers, Sam Weber, and Forrest Shull. 2016. Exploring Language Support for Immutability. In International Conference on Software Engineering.
17. Wikipedia contributors. 2018. List of educational programming languages. https://en.wikipedia.org/wiki/List_of_educational_ programming_languages
18. William R. Cook. 2007. AppleScript. In Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages (HOPL III) . ACM, New York, NY, USA, 1–1–1–21.
19. David M. Eddy. 2005. Evidence-Based Medicine: A Unified Approach. Health Affairs 24 (2005). Issue 1.
20. Stefan Endrikat, Stefan Hanenberg, Romain Robbes, and Andreas Stefik. 2014. How Do API Documentation and Static Typing Affect API Usability?. In International Conference on Software Engineering. ACM, New York, NY, USA, 632–642.
21. FDA. 2018. The Drug Development Process > Step 3: Clinical Research. https://www.fda.gov/ForPatients/Approvals/Drugs/ucm405622.htm
22. Ronald Garcia, Éric Tanter, Roger Wolff, and Jonathan Aldrich. 2014. Foundations of Typestate-Oriented Programming. ACM Trans. Program. Lang. Syst. 36, 4, Article 12 (Oct. 2014), 44 pages.
23. Thomas R. G. Green and Marian Petre. 1996. Usability analysis of visual programming environments: a ‘cognitive dimensions’ framework. Journal of Visual Languages & Computing 7, 2 (1996), 131–174.
24. Christian Haack and Erik Poll. 2009. Type-based Object Immutability with Flexible Initialization. In European Conference on Object-Oriented Programming .
25. C. Haack, E. Poll, J. Schäfer, and A. Schubert. 2007. Immutable objects for a java-like language. In European Symposium on Programming.
26. Tony Hoare. 2009. Null references: The billion dollar mistake. Presentation at QCon London 298 (2009).
27. Paul Hudak and Mark P Jones. 1994. Haskell vs. Ada vs. C++ vs. awk vs.... an experiment in software prototyping productivity. Contract 14, 92-C (1994), 0153.
28. Roberto Ierusalimschy, Luiz Henrique de Figueiredo, and Waldemar Celes. 2007. The Evolution of Lua. In Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages (HOPL III) . ACM, New York, NY, USA, 2–1–2–26.
29. Caitlin Kelleher and Randy Pausch. 2005. Lowering the Barriers to Programming: A Taxonomy of Programming Environments and Languages for Novice Programmers. ACM Comput. Surv. 37, 2 (June 2005), 83–137.
30. Mary Beth Kery, Claire Le Goues, and Brad A Myers. 2016. Examining programmer practices for locally handling exceptions. In Mining Software Repositories (MSR), 2016 IEEE/ACM 13th Working Conference on . IEEE, 484–487.
31. Mary Beth Kery and Brad A Myers. 2017. Exploring exploratory programming. In Visual Languages and Human-Centric Computing (VL/HCC), 2017 IEEE Symposium on . IEEE, 25–29.
32. Gunter Kniesel and Dirk Theisen. 2001. JAC—Access right based encapsulation for Java. Journal of Software Practice & Experience -Special issue on aliasing in object-oriented systems 31, 6 (2001), 555–576. http://dl.acm.org/citation.cfm?id=377334
33. Andrew J Ko, Brad A Myers, Michael J Coblenz, and Htet Htet Aung. 2006. An exploratory study of how developers seek, relate, and collect relevant information during software maintenance tasks. IEEE Transactions on software engineering 32, 12 (2006).
34. Thomas D LaToza and Brad A Myers. 2010. On the importance of understanding the strategies that developers use. In Proceedings of the 2010 ICSE Workshop on Cooperative and Human Aspects of Software Engineering . ACM, 72–75.
35. K. Rustan M. Leino. 2010. Dafny: An Automatic Program Verifier for Functional Correctness. In Proceedings of the 16th International Conference on Logic for Programming, Artificial Intelligence, and Reasoning (LPAR’10) . Springer-Verlag, Berlin, Heidelberg, 348–370. http://dl.acm.org/citation.cfm?id=1939141.1939161
36. Bass Len, Clements Paul, and Kazman Rick. 2003. Software architecture in practice. Boston, Massachusetts Addison (2003).
37. Donna Malayeri and Jonathan Aldrich. 2009. Is Structural Subtyping Useful? An Empirical Study. In Proceedings of the 18th European Symposium on Programming Languages and Systems: Held As Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009 (ESOP ’09) . Springer-Verlag, Berlin, Heidelberg, 95–111.
38. John McCarthy. 1981. History of Programming Languages I. ACM, New York, NY, USA, Chapter History of LISP, 173–185.
39. André N. Meyer, Thomas Fritz, Gail C. Murphy, and Thomas Zimmermann. 2014. Software Developers’ Perceptions of Productivity. In Proceedings of the 22Nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE 2014) . ACM, New York, NY, USA, 19–29.
40. Leo A. Meyerovich and Ariel S. Rabkin. 2012. Socio-PLT: Principles for Programming Language Adoption. In Proceedings of the ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (Onward! 2012) . ACM, New York, NY, USA, 39–54.
41. Sasa Misailovic, Michael Carbin, Sara Achour, Zichao Qi, and Martin C. Rinard. 2014. Chisel: Reliability- and Accuracy-aware Optimization of Approximate Computational Kernels. In Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications (OOPSLA ’14) . ACM, New York, NY, USA, 309–328.
42. B. A. Myers, A. J. Ko, T. D. LaToza, and Y. Yoon. 2016. Programmers Are Users Too: Human-Centered Methods for Improving Programming Tools. Computer 49, 7 (July 2016), 44–52.
43. Brad A. Myers, John F. Pane, and Andy Ko. 2004. Natural Programming Languages and Environments. Commun. ACM 47 (2004), 47–52. Issue 9.
44. Brad A. Myers and Jeffrey Stylos. 2016. Improving API Usability. Commun. ACM 59, 6 (May 2016), 62–69.
45. Jakob Nielsen and Rolf Molich. 1990. Heuristic evaluation of user interfaces. In Proceedings of the SIGCHI conference on Human factors in computing systems . ACM, 249–256.
46. Fatih Kursat Ozenc, Miso Kim, John Zimmerman, Stephen Oney, and Brad Myers. 2010. How to Support Designers in Getting Hold of the Immaterial Material of Software. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI ’10) . ACM, New York, NY, USA, 2513–2522.
47. J. F. Pane, B. A. Myers, and L. B. Miller. 2002. Using HCI techniques to design a more usable programming system. In Proceedings IEEE 2002 Symposia on Human Centric Computing Languages and Environments . 198–206.
48. Victor Pankratius, Felix Schmidt, and Gilda Garretón. 2012. Combining Functional and Imperative Programming for Multicore Software: An Empirical Study Evaluating Scala and Java. In Proceedings of the 34th International Conference on Software Engineering (ICSE ’12) . IEEE Press, Piscataway, NJ, USA, 123–133. http://dl.acm.org/citation.cfm?id= 2337223.2337238
49. Seymour Papert. 1980. Mindstorms: Children, Computers, and Powerful Ideas . Basic Books, Inc., New York, NY, USA.
50. D. L. Parnas. 1972. On the Criteria to Be Used in Decomposing Systems into Modules. Commun. ACM 15, 12 (Dec. 1972), 1053–1058.
51. Benjamin C. Pierce. 2002. Types and Programming Languages. MIT Press.
52. Terrence W. Pratt and Marvin V. Zelkowitz. 1996. Programming Languages: Design and Implementation .
53. L. Prechelt and W.F. Tichy. 1998. A controlled experiment to assess the benefits of procedure argument type checking. IEEE Transactions on Software Engineering 24, 4 (apr 1998), 302–312.
54. Baishakhi Ray, Daryl Posnett, Premkumar Devanbu, and Vladimir Filkov. 2017. A Large-scale Study of Programming Languages and Code Quality in GitHub. Commun. ACM 60, 10 (Sept. 2017), 91–100.
55. Mitchel Resnick, John Maloney, Andrés Monroy-Hernández, Natalie Rusk, Evelyn Eastmond, Karen Brennan, Amon Millner, Eric Rosenbaum, Jay Silver, Brian Silverman, and Yasmin Kafai. 2009. Scratch: Programming for All. Commun. ACM 52, 11 (Nov. 2009), 60–67.
56. Dennis M. Ritchie. 1993. The Development of the C Language. In The Second ACM SIGPLAN Conference on History of Programming Languages (HOPL-II) . ACM, New York, NY, USA, 201–208.
57. Dennis M. Ritchie. 1996. History of Programming languages—II. ACM, New York, NY, USA, Chapter The Development of the C Programming Language, 671–698.
58. David L Sackett, William MC Rosenberg, JA Muir Gray, R Brian Haynes, and W Scott Richardson. 1996. Evidence based medicine: what it is and what it isn’t.
59. D. W. Sandberg. 1988. Smalltalk and Exploratory Programming. SIG-PLAN Not. 23, 10 (Oct. 1988), 85–92.
60. Robert C Seacord. 2013. Secure Coding in C and C++. Addison-Wesley.
61. Robert W. Sebesta. 2006. Concepts of Programming Languages, Seventh Edition .
62. Mary Shaw and David Garlan. 1996. Software Architecture: Perspectives on an Emerging Discipline . Prentice-Hall, Inc., Upper Saddle River, NJ, USA.
63. B. Spring. 2007. Evidence-based practice in clinical psychology: what it is, why it matters; what you need to know. Journal of Clinical Psychology 63 (2007). Issue 7.
64. Andreas Stefik and Stefan Hanenberg. 2014. The Programming Language Wars: Questions and Responsibilities for the Programming Language Community. In Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming & Software (Onward! 2014) . ACM, New York, NY, USA, 283–299.
65. A. Stefik and S. Hanenberg. 2017. Methodological Irregularities in Programming-Language Research. Computer 50, 8 (2017), 60–63.
66. Andreas Stefik, Stefan Hanenberg, Mark McKenney, Anneliese Andrews, Srinivas Kalyan Yellanki, and Susanna Siebert. 2014. What is the Foundation of Evidence of Human Factors Decisions in Language Design? An Empirical Study on Programming Language Workshops. In Proceedings of the 22Nd International Conference on Program Comprehension (ICPC 2014) . ACM, New York, NY, USA, 223–231.
67. Andreas Stefik, Melissa Stefik, and Evan Pierzina. 2018. The Quorum Programming Language. https://quorumlanguage.com
68. Robert E Strom and Shaula Yemini. 1986. Typestate: A Programming Language Concept for Enhancing Software Reliability. IEEE Transactions on Software Engineering 12, 1 (1986), 157–171.
69. Bjarne Stroustrup. 2007. Evolving a Language in and for the Real World: C++ 1991-2006. In Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages (HOPL III) . ACM, New York, NY, USA, 4–1–4–59.
70. Joshua Sunshine, James D. Herbsleb, and Jonathan Aldrich. 2014. Structuring Documentation to Support State Search: A Laboratory Experiment about Protocol Programming. In European Conference on Object-Oriented Programming (ECOOP) .
71. Joshua Sunshine, James D. Herbsleb, and Jonathan Aldrich. 2015. Searching the State Space: A Qualitative Study of API Protocol Usability. In Proceedings of the 2015 IEEE 23rd International Conference on Program Comprehension (ICPC ’15) . IEEE Press, Piscataway, NJ, USA, 82–93. http://dl.acm.org/citation.cfm?id=2820282.2820295
72. Joshua Sunshine, Karl Naden, Sven Stork, Jonathan Aldrich, and Éric Tanter. 2011. First-class state change in Plaid. In ACM SIGPLAN Notices, Vol. 46. ACM, 713–732.
73. Matthew S. Tschantz and Michael D. Ernst. 2005. Javari: Adding Reference Immutability to Java. In Object-oriented programming, systems, languages, and applications .
74. Preston Tunnell Wilson, Justin Pombrio, and Shriram Krishnamurthi. 2017. Can We Crowdsource Language Design?. In Proceedings of the 2017 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (Onward! 2017) . ACM, New York, NY, USA, 1–17.
75. Phillip Merlin Uesbeck, Andreas Stefik, Stefan Hanenberg, Jan Pedersen, and Patrick Daleiden. 2016. An Empirical Study on the Impact of C++ Lambdas and Programmer Experience. In Proceedings of the 38th International Conference on Software Engineering (ICSE ’16) . ACM, New York, NY, USA, 760–771.
76. Christopher Unkel and Monica S. Lam. 2008. Automatic inference of stationary fields. ACM SIGPLAN Notices 43, 1 (jan 2008), 183.
77. Philip Wadler. 2015. Propositions As Types. Commun. ACM 58, 12 (Nov. 2015), 75–84.
78. Michelle Yeh, Young Jin Jo, Colleen Donovan, and Scott Gabree. 2013. Human Factors Considerations in the Design and Evaluation of Flight Deck Displays and Controls . Technical Report. Federal Aviation Administration.
79. Yoav Zibin, Alex Potanin, Mahmood Ali, Shay Artzi, Adam Kielun, and Michael D. Ernst. 2007. Object and reference immutability using Java generics. In Foundations of Software Engineering. ACM, 75–84.

Index Terms

• Social and professional topics

  • Professional topics

    • History of computing

      • History of programming languages

• Software and its engineering

  • Software notations and tools

    • General programming languages