Abstract
Programming environments that provide a feeling of liveness help professionals and amateurs alike to approach unfamiliar domains with ease through short feedback loops. Exploration and experimentation are promoted because any change to the program under construction can be observed immediately. However, live-programming systems such as Squeak/Smalltalk struggle with the predictable emergence of adapted program behavior as object communication can be unconstrained and diverse. While programmers wish for immediate effects, it would be helpful to at least know whether anything will happen after some time. In this chapter, we take a closer look at the means available in Squeak to explore and adjust object state and object behavior so that programmers can ensure the system’s responsiveness and hence observe gradual or even induce eventual emergence. We argue that these design strategies are sufficient to architect communication patterns that reward changes with immediate effects. We believe that our work can help programmers to better understand their leverage toward a predictable emergence in systems whose liveness stems from objects and messaging in a space where tools and applications live side by side.
This is a preview of subscription content, log in via an institution to check access.
Access this chapter
Tax calculation will be finalised at checkout
Purchases are for personal use only
Notes
- 1.
The Squeak/Smalltalk programming system, https://squeak.org
- 2.
Note that a feeling of liveness needs more than a timely emergence. A direct-manipulation interface (Hutchins et al., 1985) helps users to directly map their intents to actions (e.g., tangible object commands) as well as quickly figure out the meaning of what they can see (e.g., visual object representations)0.2. Note that a feeling of liveness needs more than a timely emergence. A direct-manipulation interface (Hutchins et al., 1985) helps users to directly map their intents to actions (e.g., tangible object commands) as well as quickly figure out the meaning of what they can see (e.g., visual object representations).
- 3.
Desirable response times depend on the particular use cases (Shneiderman & Plaisant, 2010, p. 445). Typing and cursor movement lies somewhere between 50 and 150 milliseconds. Simple frequent tasks such as button clicks should be no longer than 1 s until something happens. If it takes too long, users cannot make the connection between their action and the system’s response. They might lose track of cause and effect.
- 4.
To this day, the most promising systems for live programming offer level-4 liveness (Tanimoto, 2013). These systems are “informative, significant, responsive, and live.” Program descriptions are human-readable and human-executable; modifying these descriptions changes system execution automatically without any noticeable delay. Systems with level 5 or 6 would be tactically and/or strategically predictive, but we do not know how such cleverness could be implemented. Squeak/Smalltalk provides level-4 liveness without immediate emergence (Rein et al., 2016), which, however, programmers can deliberately induce in their projects.
- 5.
Note that such green threading makes the virtual machine more robust because programmers cannot corrupt the object memory inadvertently. In an informal way, they can explore and experiment unless their experiments botch the processes (or means) responsible for continual responsiveness.
- 6.
On a Microsoft Surface Pro 6 with an Intel Core i7-8650U on Windows 10 21H2 in Squeak 6.0, the VM can process about 190,000,000 sends per second.
- 7.
The OpenSmalltalk VM, https://opensmalltalk.org/
- 8.
Objects send messages. An object receiving a message will entail a message lookup, which means that a symbol will be matched to a piece of source code (or byte code). That code represents a method, which is an implementation of a message. That is why a suspended process has a stack of active methods, not messages. We use the term “chain of messages” to simplify this detail.
- 9.
Trace Debugger, a back-in-time debugger for Squeak, https://github.com/hpi-swa-lab/ squeak-tracedebugger
References
Gabriel, R. P. (2014). I throw itching powder at tulips. In: Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, pp. 301–319. ACM. https://doi.org/10.1145/2661136.2661155.
Hancock, C. M. (2003) Real-time programming and the big ideas of computational literacy. Ph.D. thesis, Massachusetts Institute of Technology.
Hutchins, E. L., Hollan, J. D., & Norman, D. A. (1985). Direct manipulation interfaces. Human-Computer Interaction, 1(4), 311–338. https://doi.org/10.1207/s15327051hci0104_2
Ingalls, D. H. H. (2020): The evolution of smalltalk: From smalltalk-72 through squeak. In: Proceedings of the 4th ACM SIGLAN History of Programming Languages Conference (HOPL IV), pp. 1–101. ACM. https://doi.org/10.1145/3386335.
Maloney, J. H. (2002). An introduction to Morphic: The squeak user Interface framework, chap. 2 (pp. 39–67). Prentice Hall.
Meyer, B. (1998). Object-oriented software construction (2nd ed.). Prentice Hall.
Miranda, E., Béra, C., Boix, E. G., Ingalls, D. H. H. (2018). Two decades of smalltalk vm development: Live vm development through simulation tools. In: Proceedings of the 10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages, pp. 57–66. ACM. https://doi.org/10.1145/3281287.3281295.
Rein, P., Lehmann, S., Mattis, T., Hirschfeld, R. (2016). How live are live programming systems?: Benchmarking the response times of live programming environments. In: Proceedings of the Programming Experience 2016 (PX/16) Workshop, pp. 1–8. ACM. DOI https://doi.org/10.1145/2984380.2984381.
Rein, P., Ramson, S., Lincke, J., Hirschfeld, R., & Pape, T. (2018). Exploratory and live, programming and coding. The Art, Science, and Engineering of Programming, 3(1), 1:1–1:33. https://doi.org/10.22152/programming-journal.org/2019/3/1
Sheil, B. (1998). Datamation®: Power tools for programmers, chap. 33 (pp. 573–580). Morgan Kaufmann. https://doi.org/10.1016/B978-0-934613-12-5.50048-3
Shneiderman, B., & Plaisant, C. (2010). Designing the user interface: Strategies for effective human-computer interaction (5th ed.). Addison-Wesley.
Taeumel, M. (2020). Data-driven tool construction in exploratory programming environments. Ph.D. thesis, University of Potsdam, Digital Engineering Faculty, Hasso Plattner Institute. https://doi.org/10.25932/publishup-44428.
Taeumel, M., Hirschfeld, R. (2016). Evolving user interfaces from within self-supporting programming environments: Exploring the project concept of squeak/smalltalk to bootstrap uis. In: Proceedings of the Programming Experience 2016 (PX/16) Workshop, pp. 43–59. ACM, https://doi.org/10.1145/2984380.2984386.
Taeumel, M., Lincke, J., Rein, P., Hirschfeld, R. (2022). A pattern language of an exploratory programming workspace. In: Design thinking research: Achieving real innovation, pp. 111–145. Springer https://doi.org/10.1007/978-3-031-09297-8_7.
Taeumel, M., Rein, P., Hirschfeld, R. (2021). Toward patterns of exploratory programming practice. In: Design Thinking Research: Translation, Prototyping, and Measurement, pp. 127–150. Springer. https://doi.org/10.1007/978-3-030-76324-4_7.
Tanimoto, S. L. (2013). A perspective on the evolution of live programming. In: 2013 1st International Workshop on Live Programming (LIVE), pp. 31–34. IEEE https://doi.org/10.1109/LIVE.2013.6617346.
Trenouth, J. (1991). A survey of exploratory software development. The Computer Journal, 34(2), 153–163. https://doi.org/10.1093/comjnl/34.2.153
Ungar, D., Lieberman, H., & Fry, C. (1997). Debugging and the experience of immediacy. Communications of the ACM, 40(4), 38–43. https://doi.org/10.1145/248448.248457
Acknowledgments
Many thanks go to Dr. Sharon Nemeth for her editorial support. We gratefully acknowledge the financial support of the HPI Research School on Service-oriented Systems Engineering (www.hpi.de/en/research/research-schools) and the Hasso Plattner Design Thinking Research Program (www.hpi.de/en/dtrp).
Author information
Authors and Affiliations
Corresponding author
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2023 The Author(s), under exclusive license to Springer Nature Switzerland AG
About this chapter
Cite this chapter
Taeumel, M., Rein, P., Lincke, J., Hirschfeld, R. (2023). How to Tame an Unpredictable Emergence? Design Strategies for a Live-Programming System. In: Meinel, C., Leifer, L. (eds) Design Thinking Research. Understanding Innovation. Springer, Cham. https://doi.org/10.1007/978-3-031-36103-6_8
Download citation
DOI: https://doi.org/10.1007/978-3-031-36103-6_8
Published:
Publisher Name: Springer, Cham
Print ISBN: 978-3-031-36102-9
Online ISBN: 978-3-031-36103-6
eBook Packages: Business and ManagementBusiness and Management (R0)