Scenario-Based Programming, Usability-Oriented Perception

In this article, we discuss the possible connection between the programming language and the paradigm behind it, and programmers’ tendency to adopt an external or internal perspective of the system they develop. Based on a qualitative analysis, we found that when working with the visual, interobject language of live sequence charts (LSC), programmers tend to adopt an external and usability-oriented view of the system, whereas when working with an intraobject language, they tend to adopt an internal and implementation-oriented viewpoint. This is explained by first discussing the possible effect of the programming paradigm on programmers’ perception and then offering a more comprehensive explanation. The latter is based on a cognitive model of programming with LSC, which is an interpretation and a projection of the model suggested by Adelson and Soloway [1985] onto LSC and scenario-based programming, the new paradigm on which LSC is based. Our model suggests that LSC fosters a kind of programming that enables iterative refinement of the artifact with fewer entries into the solution domain. Thus, the programmer can make less context switching between the solution domain and the problem domain, and consequently spend more time in the latter. We believe that these findings are interesting mainly in two ways. First, they characterize an aspect of problem-solving behavior that to the best of our knowledge has not been studied before—the programmer’s perspective. The perspective can potentially affect the outcome of the problem-solving process, such as by leading the programmer to focus on different parts of the problem. Second, relating the structure of the language to the change in perspective sheds light on one of the ways in which the programming language can affect the programmer’s behavior.

[1]  Rick Kazman,et al.  Surveying the Solitudes: An Investigation into the Relationships between Human Computer Interaction and Software Engineering in Practice , 2005 .

[2]  Agile Manifesto,et al.  Manifesto for Agile Software Development , 2001 .

[3]  Sarah A. Douglas,et al.  Incorporating Human-Computer Interaction into the undergraduate computer science curriculum , 2002, SIGCSE '02.

[4]  Bruria Haberman,et al.  Activating “black boxes” instead of opening “zipper” - a method of teaching novices basic CS concepts , 2001 .

[5]  Donald A. Norman,et al.  Cognitive artifacts , 1991 .

[6]  Assaf Marron,et al.  Spaghetti for the main course?: observations on the naturalness of scenario-based programming , 2012, ITiCSE '12.

[7]  B. Adelson,et al.  The Role of Domain Expenence in Software Design , 1985, IEEE Transactions on Software Engineering.

[8]  Colin Potts,et al.  Design of Everyday Things , 1988 .

[9]  David Harel,et al.  Statecharts: A Visual Formalism for Complex Systems , 1987, Sci. Comput. Program..

[10]  M. Costabile,et al.  USABILITY IN THE SOFTWARE LIFE CYCLE , 2010 .

[11]  Bonnie A. Nardi,et al.  A Small Matter of Programming: Perspectives on End User Computing , 1993 .

[12]  J. Stanley Warford BlackBox: a new object-oriented framework for CS1/CS2 , 1999, SIGCSE '99.

[13]  David Harel,et al.  The effect of previous programming experience on the learning of scenario-based programming , 2012, Koli Calling.

[14]  Bruria Haberman,et al.  Activating “black boxes” instead of opening “zipper” - a method of teaching novices basic CS concepts , 2001, ITiCSE '01.

[15]  Hans van Vliet,et al.  What makes software design effective , 2010 .

[16]  Amir Pnueli,et al.  The temporal logic of programs , 1977, 18th Annual Symposium on Foundations of Computer Science (sfcs 1977).

[17]  David Harel,et al.  On Teaching Visual Formalisms , 2009, IEEE Software.

[18]  David Harel,et al.  On teaching programming with nondeterminism , 2013, WiPSE '13.

[19]  David Harel,et al.  LSCs: Breathing Life into Message Sequence Charts , 1999, Formal Methods Syst. Des..

[20]  David Harel,et al.  Behavioral programming , 2012, CACM.

[21]  David Harel,et al.  Come, let's play - scenario-based programming using LSCs and the play-engine , 2003 .

[22]  Manuel Santos-Trigo,et al.  Mathematical Problem Solving , 2015 .

[23]  David Harel,et al.  Scenario-based programming: reducing the cognitive load, fostering abstract thinking , 2014, ICSE Companion.

[24]  J. Wertsch The zone of proximal development: Some conceptual issues† , 1984 .

[25]  M. Chi Quantifying Qualitative Analyses of Verbal Data: A Practical Guide , 1997 .

[26]  Steve McConnell,et al.  Rapid Development: Taming Wild Software Schedules , 1996 .

[27]  Bruria Haberman,et al.  Logic programming based curriculum for high school students: the use of abstract data types , 1995, SIGCSE '95.

[28]  Amir Pnueli,et al.  On the Development of Reactive Systems , 1989, Logics and Models of Concurrent Systems.

[29]  L. S. Vygotskiĭ,et al.  Mind in society : the development of higher psychological processes , 1978 .

[30]  David Ginat Loop invariants and mathematical games , 1995, SIGCSE '95.

[31]  Michal Armoni,et al.  On Teaching Abstraction in CS to Novices , 2013 .

[32]  David Harel,et al.  Come, Let’s Play , 2003, Springer Berlin Heidelberg.

[33]  Mordechai Ben-Ari,et al.  Conceptual models of software artifacts , 2006, Interact. Comput..

[34]  Ivar Jacobson,et al.  Object-oriented software engineering - a use case driven approach , 1993, TOOLS.

[35]  David Harel,et al.  Specifying and executing behavioral requirements: the play-in/play-out approach , 2003, Software & Systems Modeling.

[36]  Michael Eisenberg,et al.  Programmable applications: interpreter meets interface , 1995, SGCH.

[37]  Xavier Ferré,et al.  How a Human-Centered Approach Impacts Software Development , 2007, HCI.