=Paper=
{{Paper
|id=Vol-1522/Chaudron2015HuFaMo
|storemode=property
|title=A Vision on a New Generation of Software Design Environments
|pdfUrl=https://ceur-ws.org/Vol-1522/Chaudron2015HuFaMo.pdf
|volume=Vol-1522
|dblpUrl=https://dblp.org/rec/conf/models/ChaudronJ15
}}
==A Vision on a New Generation of Software Design Environments==
https://ceur-ws.org/Vol-1522/Chaudron2015HuFaMo.pdf
A Vision on a New Generation of
Software Design Environments
(Empirical Theory)
Michel R.V. Chaudron, Rodi Jolak
Joint Department of Computer Science and Engineering
Chalmers University of Technology and Gothenburg University
Gothenburg, Sweden
{chaudron, jolak}@chalmers.se
Abstract— In this paper we explain our vision for a new solutions, capture design discussions, etc. [13, 5]. Whiteboards
generation of software design environments. We aim to are normally used for sketching when more than two people are
generalize existing software development tools in several key involved [2]. Generic diagramming tools such as PowerPoint
ways – which include: integration of rigorous and informal and Visio are informal in the sense that they do not constrain
notations, and support for multiple modes of interaction. We
the notation, but they do provide mature digital editing
describe how we can consolidate the environment by integrating
it with other software engineering tools. Furthermore, we functionality (move, delete, undo). While on the other hand we
describe some methods which could permit the environment to mean by formal tools any CASE tool which supports one or
provide a flexible collaborative medium and have a practical and more formalized notations. Typical examples are UML CASE
inspiring user experience. tools (like Rational Rose, Enterprise Architect, Visual
Index Terms—software engineering, modeling tools, Paradigm, StarUML etc.). Also for many other modeling
collaborative design, IDE. languages, tools are often dedicated to a single notation
(Archimate for Enterprise Modeling, ARIS-tool for Business
I. INTRODUCTION Process Modeling, etc.). All CASE tools support mature digital
Software systems have an important role in the technological edition functionality.
evolution which we are witnessing nowadays, and as a Table 1 is based on Hammouda [11] and describes some
consequence, software systems are becoming more and more relative advantages of informal and formal modeling tools:
complex. The increasing complexity of such systems has raised Table 1: Relative Advantages of Informal and Formal Modeling
some certain challenges, such as e.g. design uncertainty and Approaches
run-time changes, making it difficult to meet continuous
Informal Formal
customer demands for a better software quality [7, 8]. Software High clarity because of strict
modeling plays a pivotal role in software development. Models Clarity
adherence to syntax
present an understandable description of complex systems at Caters for improvisation
Flexibility
several levels of abstraction and from a diversity of of notation.
perspectives. Furthermore, they provide an essential medium Ease of In tools based on digital editing, editing (move, resize,
continuous delete, undo, etc.) is easier than in sketch-based tools such
matching between problem and software implementation by design as whiteboards.
describing user’s needs and prescribing the product to be Ease of
Formal syntax checking helps
developed. learning
in learning the proper syntax.
Software modeling is a highly complex and demanding notation
More difficult to learn, but
activity [21]. Software designers often use software modeling Intuitiveness very simple to use; but
advanced functionalities
tools to perform a software design. There are two dimensions of using tool limited in functionality
supported.
of these tools that we will challenge in this paper: i) the Multiple people collabo-
formality of the notation used, and ii) the modes of interaction rating on a shared design
Collaboration
prefer to use informal
supported by the tools. Next, we briefly explain our views on representations [2].
these dimensions. Absence of a formal Formal syntax allows a formal
First, we classify modeling tools into two groups: informal syntax (and semantics) representation of the design
Integration
and formal. We mean by informal any tool that supports prohibits exchange of that can be exchanged with
informal design in the sense that it does not constrain the designs. other tools.
notation used. Examples of such tools are whiteboards, paper
and pencil. Whiteboards are often used to collaboratively We envision our environment to have the advantages of both
sketch software modeling ideas, discover architectural formal and informal tools.
11
The second dimension we challenge is that of the modes of purposes of sketches were related to designing, explaining, or
interaction supported by modeling tools. Oviatt and Cohen [19] understanding. Baltes and Diehl also showed that the sketches
illustrated the importance of multimodal systems in reshaping were archived digitally for re-visualization and future use. Like
daily computing tasks and predicted their future role in shifting us, they think software design tools should enable informal
the balance of human-computer interaction much closer to the design sketching.
human. Based on that, we want to support multimodal Wüest et al. [22] stated that software engineers often use
communication interactions by recognizing touch, voice and paper and pencil to sketch ideas when gathering requirements
gesture for a more intuitive software modeling experience. from stakeholders, but such sketches on paper often need to be
modelled again for a further processing. A tool, FlexiSketch,
Summarizing, the following questions are addressed: was prototyped by them to combine freeform sketching with
Q1: How can we achieve an integrated design environment the ability to interactively annotate the sketches for an
having the power of both formal and informal tools? incremental transformation into semi-formal models. The users
Q2: How can we make modeling tools easier to use and more of FlexiSketch were able to draw UML-like diagrams and
productive? introduced their own notation. They were also able to assign
- How can tools better support tasks of software developers? types to drawn symbols. Users liked the informality provided
Our focus is on tasks related to the design of systems. by the tool, and stated that they would be willing to adopt it in
- Which sources of knowledge and information can be practice. FlexiSketch runs on tablet computers. It is a single
connected to provide information needed at easy disposal user tool, and does not support collaborative sketching. We
(right information at the right moment, place and format)? think running FlexiSketch on electronic whiteboards could
allow for multi-user input and facilitate collaboration. We also
The paper is organized as follows: in section two we describe think that software design tools should be able to support
the related work. Section three illustrates our vision. Finally we sketch recognition and its transformation into a kind of formal
conclude and discuss ideas for future work in section four. diagrams as well as allow the exportation of such diagrams to
other programs e.g. CASE tools. FlexiSketch Team [23] is an
II. RELATED WORK extended version of FlexiSketch, which supports a
Many empirical studies of formal tools usage have pointed collaborative sketching via ad-hoc local Wi-Fi network, but it
out that software designers consider these tools overly does not allow for a distributed collaboration.
restrictive and this often lead to poor utilization [13, 6]. By Chen et al. have developed SUMLOW [4]. A sketching-
doing a HCI study, Plimmer et al. revealed that in early based UML design tool for electronic whiteboard technology.
software design phases, the designers prefer to sketch by hand It allows to preserve hand drawn diagrams and supports for
rather than using a keyboard or a mouse [20]. Whiteboards manipulation of the diagrams using pen-based actions. UML
support informal design. They are frequently used by software sketches can be formalized and exported to a 3rd party CASE
designers during project meetings to sketch ideas and thoughts tool. Their tool does not support design sketching on different
about system goals, requirements and design solutions [13, 5]. platforms like mobiles and tablets. Again as all works
Electronic interactive whiteboards offer the potential for previously mentioned, it does not support a collaborative
enhanced support by allowing the manipulation of the content, distributed software modeling.
handling of sketches, and doing collaborative distributed MaramaSketch [10] includes a meta-modeling editor. This
works. Mangano et al. [15] identified some behaviors that editor allows to define a conventional modeling language
occur during informal design. They implemented an interactive which is then used to compile a modeling tool for the defined
whiteboard system to support these behaviors, and identified language. However, MaramaSketch needs to create the
some ways where interactive whiteboards can enable designers complete language definition first, and after that, users must
to work more effectively. The main goal of the system that they strictly follow it. So as a consequence, it prevents any flexible
implemented, called Calico, is to maintain fluidity and sketching.
flexibility allowing software designers to focus on the content Magin and Kopf [14] have created a multi-touch based
of their sketches rather than the tool used to make it. Mangano system allowing users to collaboratively design UML class
et al. revealed a number of weaknesses in Calico ranging from diagram on touch screens. They have also implemented new
usability issues to challenges inherent to interactive algorithms to recognize the gestures drawn by the users and to
whiteboards. In particular, designers reported that some improve the layout of the diagrams. However, it does not
gestures were not rapidly interpreted, and the large e- support a remote collaboration, and as they stated, their tool has
whiteboard diminished the quality of their handwriting, forcing some usability challenges in creating and editing of sketches,
them to write slower or larger. We want to support software and in the recognition process of hand written text.
design not only with interactive whiteboards, but with PCs, In the area of integration of software development tools
touch pads and smart phones. Open Services for Lifecycle Collaboration “OSLC” [25] is an
Baltes and Diehl [2] investigated the use of sketches in emerging standard. This standard defines API’s through which
software engineering activities by conducting an exploratory development tools can interoperate. OSLC could be a
study in three different software companies. Their results technology that underlies the integration aspects of our vision.
showed that the majority of the sketches were informal, and the
12
Brosch et al. [3] showed the importance of model versioning the same canvas [15]. Furthermore, they should not constrain
in enabling efficient team-based development of models. Based designers to sketch only some specific notations. For instance,
on that, we think a version management tool should be designers should be able to draw and create a variety of
integrated within software design environments to track sketches e.g. use case diagrams, workflows, arrows, state
modeling processes and their evolution. There is a fair amount charts, data models, etc. In general, NGDE should enable
of work ongoing in versioning for software models [1], but designers to add domain specific icons or notations. These
none of this has been integrated in mainstream CASE tools yet.
kind of notations help to better describe a specific domain
IBM’s family of integrated development environments [24]
problem.
allow for a collaborative software development. In particular,
they provide teams with rich capabilities for continuous NGDEs should keep from existing editors the abilities to
development, testing, analyzing and optimizing applications. organize diagrams by moving, resizing, grouping and
For example, IBM Rational Business Developer is an Eclipse- separating sketches, and the ability to modify and evolve
based environment. It allows complex applications to be sketches.
modeled graphically. IBM only offers these tools on a NGDEs should have the ability to transform sketches into
commercial basis. formalized content by providing a recognition unit. This
While a comprehensive theory of IDEs does not exist, there enables designs be formally represented and hence easily
are proposals for theoretical models that can serve to support exchanged with other software tools. Furthermore, they should
the design of NGDE. Notable approaches are the Cognitive have the power of formal tools in maintaining and transferring
Dimensions approach [9] and the ‘Physics of Notations’ [16]. the designs for further processing tasks.
III. OUR VISION B. Integration
In this section we present our vision for a more intuitive, In their daily work, many software designers work
inspiring and efficient tool to support exploratory and concurrently on different artefacts: changes to a design and
collaborative software modeling. In particular, we are going to followed closely by changes in code and changes in
describe some ideas which we consider to be relevant to requirements. Unfortunately, with current tools the developer
achieve such a tool. We will refer the next generation software needs to switch to different applications. We propose to design
design environment as NGDE. an integrated environment. This does not need to become a
One first point is that in practice modeling and designing go ‘Swiss army knife’ that integrates all functionality in a single
hand-in hand. A modeling language provides the notation in tool. Integration of development tools needs to address a
which to express a design. As such a modeling language is a shared data model of software development artefacts, but also
part of the toolbox that a designer uses in the creative process a shared UI-concept.
of designing a solution. Currently, most case tools are The goal behind the idea of integrating other software
modeling (or even diagramming) tools. Instead, the next management tools within a software modeling tool in a ‘one
generation of tools should take a holistic view on supporting all stop’ environment is to provide effective support for an
design activities in which developers are engaged. effective software modeling process.
Next, we discuss several key aspects in which NGDE can Software requirements, for instance, evolve over time and
provide better support for the design activities of software they are frequently subject to changes during initial
developers: development and later on to delivery. Designers generate
many ideas in order to understand a problem and find a
A. Informal versus Formal Notation
solution for it. These ideas are often compared, modified,
Informal tools like whiteboards provide a useful mean for evaluated and enriched as the modeling process evolves. In
flexible collaborative modeling. In fact, software designers order to realize how useful could be having a trace of the
can easily create/extend diagrams, add comments and requirements within a software modeling tool, let’s think
highlight some parts of their sketches. Even more, they can about the following scenario: a group of software designers
sketch diagrams of multiple notations without following any start to document and gather needs of a specific software
restrictive rule imposed by the formality of a one modeling product, after that, they proceed to create a first design of the
language or syntax. However, re-modeling is a difficult and a product using for example a traditional whiteboard or a CASE
time consuming task. Moreover, whiteboards do not support tool. Let’s also consider that the software needs, written on a
data persistency and transference. Formal tools like CASE simple paper sheet, are given by a client. In both cases, using
tools are restrictive in that they require designers to use some either a whiteboard or a CASE tool, software designers have
to meet again and again whenever new requirements come out
specific notations for modeling. We propose that NGDE tools
or having earlier requirements exposed to changes. This is a
should support the mix of both formal and informal modeling
time consuming task and especially when designers have to
notations that designers use. Ideally, NGDEs should maintain recollect their designs and re-model them according to the new
the characteristics of formal tools in their support of design set of requirements.
transfer and persistency. To support informal modeling, tools Here, a NGDE should be able to handle notes written on
should allow designers to create different types of diagrams on paper as an artefact. Ideally, this paper is not only stored as a
13
(jpeg) picture, but contents are (partially) recognized and can designers from two different locations want to exchange ideas
be transformed into formal concepts. about a specific design, they could make use of the integrated
Modeling involves several stakeholders who conduct the social media or chatting tools to do such a task, and of course,
creation of the design in elicitation and formalization phases, this reduces the time spent handling emails. In fact, these
and since requirements evolve over time, modeling usually communicative facilities play an important role in establishing
comprises several iterations of elicitation and formalization a basis for discussions and negotiations, information
resulting in an evolving process [12]. Therefore, we think that exchanging, and sharing data e.g. images, videos, etc.
software modeling tools should be integrated with other
software engineering tools to deliver a ‘one stop’ environment
capable of addressing and supporting issues like requirements
analysis and management, programming and coding,
generation of bug reports, performance and security analysis,
testing, versioning, etc. This is in line with the Twin Peaks
model by Nuseibeh [18]. This model states that in reality
requirements and designs develop progressively in concert and
mutually influence each other.
Of course, source code is also essential in the development
of software. Hence throughout the development process,
models and code must be combined – in the sense that
developers must be able to view them side by side and jump
between editing one and keeping the other synchronized. One
challenge is the linking between models and code. It is typical Figure 1. An illustrative view of NGDEs and the integration mechanism.
that models are used at various and varying levels of
abstraction. Models start out at a high level of abstraction and In general, modeling tools should be “open” providing
gradually get refined by adding details. various integration mechanisms among the different platforms.
The integration of code and models also raises the question In particular, they should have programmable interfaces,
of debugging. While we can always use the IDE’s debugging import/export formats, and enable plug-ins for integration (see
functionality, it usually does not make sense to debug the Figure 1), thus offering an ideal support for team work, and
generated code itself. The developer is more familiar with the letting the overall development process becomes easier and
model than the code, and if a problem is found, we want to faster. On this topic, we will explore to what degree OSLC
correct it in the model not the code. Modeling tools should helps solve this issue.
support the usage of models in debugging the functionalities at In summary, integration has several facets:
a higher level of abstraction in order to know if the application - Integration of rigorous and informal notation
is doing what it was designed to do. - Integration of different tools for different activities in the
Modeling tools should support multiple people and teams software development lifecycle.
working on the same design from different locations. In - Integration of (machine and human) knowledge sources.
particular, they should provide means to achieve an effective
coordination between geographically distributed project C. Usability, Interaction and Collaboration
members. Version management, for example, should be The usability of current CASE tools is a common source of
adapted to support collaborative modeling and design. We criticism. One key aspect of usability is the manner in which
think modeling tools should provide a repository to keep track humans interact with the system. Currently this is by using the
of the version history of the models stored in it, as well as keyboard and the mouse – essentially we are using the
provide the ability to observe who is changing what artifacts in computer as an enriched typewriter. Other modes of
the environment. Following the checkout-update-commit
interaction have gained popularity because of their intuitive
interaction paradigm, the repository would offer an interactive
model merging tool to resolve conflicts when two users nature and these should also be employed in the area of
change the same model data. It would increase the potential software design environments.
for parallel and distributed work, improve ability to track and Touch-based interfaces have become common in tablets
merge changes over time and automate management of and smart phones, and also smart-whiteboards with touch-
revision history. It would also allow multiple designers to based interaction have been introduced in class room
work with the same models concurrently, supporting tight environments. This introduces the dimension of modality of
collaboration and a fast feedback loop. interaction. While traditional interaction with a computer is
Finally, and to provide an effective communication via a keyboard (and mouse) currently there are many options
medium for a geographically distributed software modeling available: voice, touch, gesture, eye-focus or laser-focus as
teams, we propose integrating social media and chat tools pointing. Computers are capable of handling such new types
within the modeling tools. The goal is to make software of inputs. This will make interacting with NGDEs much more
modeling activity more efficient. For instance when two
intuitive.
14
Whiteboards allow multiple users to draw software - Support for mixing formal notations with informal
models together. In order to emulate this informality in our notations (e.g. UML diagrams with additional sketching).
environment, we propose enabling it to support a collaborative - Higher level of integration of tools: on the one hand
multi-touch modeling. Multi-touch is an interaction technique integrating tools for different development tasks
that’s permits the manipulation of graphical entities with (requirements, testing, coding) and also analysis tools
several fingers at the same time. Making use of multi-touch (performance, security). On the other hand, integration of
social/organizational sources of knowledge via ((video)
screens allows users to design complex diagrams
chat).
simultaneously by performing simple intuitive touch gestures
- Rich support for multiple platforms: work does not only
to draw their part of the diagram. happen behind a PC, there is also discussions at the
Such joint drawing sessions typically also trigger a lot of whiteboard and via tablets. NGDE should offer a seamless
discussion. Such discussion may contain valuable information environment for this.
about a design, such as e.g. its rationale. However, traditional The design of software design environments should be
tools do not capture the discussion. NGDE can be equipped driven by studying the needs of actual software developers. We
with microphones and also record the spoken discussion. New consider it very important that more observation studies are
challenges in this area will be to search through this type of performed about the actual tasks that software developers
recorded spoken text. Inspiring work in this direction is the perform. From this we can learn how to best support them.
work by Nakakoji et al. [17]. They describe a system that This paper describes our vision. It is beyond our own
makes video-recordings of the design discussion in front of the capacity to realize this vision. We therefore call on the
whiteboard. Their system does automated voice recognition community to collaboratively work on the next generation of
and produced a textual transcript of the discussion. Also, their software design environments.
system offers a way of navigating through the discussion using
a time-line. The recording of discussions is effortless for (i.e. REFERENCES
without any explicit action) the developers. In such a way
[1] Altmanninger, Kerstin, Martina Seidl, and Manuel
NGDE can relieve the developer by lowering the cognitive
Wimmer. "A survey on model versioning approaches."
attention needed for inputting relevant information into the
International Journal of Web Information Systems 5, no. 3
system and linking it to related artefacts.
(2009): 271-304.
A task that is commonly forgotten is that of design
review. Designers frequently review the design progress in
[2] Baltes, Sebastian, and Stephan Diehl. "Sketches and
order to know what is done and what they have still to do. For
diagrams in practice." In Proceedings of the 22nd ACM
that, NGDEs should support design review “on the fly”, as
SIGSOFT International Symposium on Foundations of
well as in detail whenever designers want to add some
Software Engineering, pp. 530-541. ACM, 2014.
additional items to their previously sketched design. One
approach in this direction is offered by the recent version of
[3] Brosch, Petra, Gerti Kappel, Philip Langer, Martina Seidl,
the Altova UModel tool. This tool provides a layering-
Konrad Wieland, and Manuel Wimmer. "An introduction to
mechanism: here review comments are part of one layer and
model versioning." In Formal Methods for Model-Driven
the software design is part of another layer. The user can then
Engineering, pp. 336-398. Springer Berlin Heidelberg, 2012.
select to see combined layers or layers in isolation.
D. Multiplatform [4] Chen, Qi, John Grundy, and John Hosking. "An e-
Rather than tying the development process down to any whiteboard application to support early design-stage sketching
specific hardware environment, the NGDE should aim to of UML diagrams." In Human Centric Computing Languages
facilitate multiple platforms: smart whiteboards, tablets, smart and Environments, 2003. Proceedings. 2003 IEEE Symposium
phones, and traditional desktops and laptops. This increases on, pp. 219-226. IEEE, 2003.
the accessibility of the environment. Also, in classroom
environments, this will open up new opportunities for [5] Cherubini, Mauro, Gina Venolia, Rob DeLine, and
interactive collaborative design. Andrew J. Ko. "Let's go to the whiteboard: how and why
software developers use drawings." In Proceedings of the
IV. CONCLUSION SIGCHI conference on Human factors in computing systems,
Other application domains have gone before software pp. 557-566. ACM, 2007.
development CASE tools and have shown that rich interaction
with computer-based systems is enhancing productivity [19]. [6] Damm, Christian Heide, Klaus Marius Hansen, and
Next generation software design tools must keep up with this Michael Thomsen. "Tool support for cooperative object-
trend and offer improvements over existing tools in the oriented design: gesture based modelling on an electronic
following dimensions: whiteboard." In Proceedings of the SIGCHI conference on
- Rich support for multiple modes of interaction (touch, Human Factors in Computing Systems, pp. 518-525. ACM,
audio, video, gesture). 2000.
15
[7] Fiadeiro, José Luiz. "The many faces of complexity in [18] Nuseibeh, Bashar. "Weaving together requirements and
software design." In Conquering Complexity, pp. 3-47. architectures." Computer 34, no. 3 (2001): 115-119.
Springer London, 2012.
[19] Oviatt, Sharon and Philip Cohen. "Multimodal interfaces
[8] Filieri, Antonio, Carlo Ghezzi, Raffaela Mirandola, and that process what comes naturally." Communications of the
Giordano Tamburrelli. "Conquering complexity via seamless ACM. Volume 43 Issue 3, March 2000 Pages 45-53.
integration of design-time and run-time verification." In
Conquering Complexity, pp. 253-275. Springer London, 2012. [20] Plimmer, Beryl, and Mark Apperley. "Computer-aided
sketching to capture preliminary design." In Australian
[9] Green, Thomas R. G., and Marian Petre. "Usability Computer Science Communications, vol. 24, no. 4, pp. 9-12.
analysis of visual programming environments: a ‘cognitive Australian Computer Society, Inc., 2002.
dimensions’ framework." Journal of Visual Languages &
Computing 7, no. 2 (1996): 131-174. [21] Tang, Antony, Aldeida Aleti, Janet Burge, and Hans van
Vliet. "What makes software design effective?" Design
[10] Grundy, John, and John Hosking. "Supporting generic Studies 31, no. 6 (2010): 614-640.
sketching-based input of diagrams in a domain-specific visual
language meta-tool." In Software Engineering, 2007. ICSE [22] Wüest, Dustin, Norbert Seyff, and Martin Glinz.
2007. 29th International Conference on, pp. 282-291. IEEE, "Flexisketch: A mobile sketching tool for software modeling."
2007. In Mobile Computing, Applications, and Services, pp. 225-
244. Springer Berlin Heidelberg, 2013.
[11] Hammouda, Imed, Håkan Burden, Rogardt Heldal,
Michel R.V. Chaudron, "CASE tools versus pencil and paper: [23] Wüest, Dustin, Norbert Seyff, and Martin Glinz.
A student's perspective on modeling software "FLEXISKETCH TEAM: Collaborative Sketching and
design." EduSymp@MoDELS. 2014: 21-30. Notation Creation on the Fly." In Software Engineering
(ICSE), 2015 IEEE/ACM 37th IEEE International Conference
[12] Hoppenbrouwers, S. J. B. A., H. A. Proper, and Tvd on, vol. 2, pp. 685-688. IEEE, 2015.
Weide. "Formal modelling as a grounded conversation." In
Proceedings of the 10th International Working Conference on [24] IBM Rational Development Family, http://www-
the Language Action Perspective on Communication 03.ibm.com/software/products/en/developer, last visited Sep.
Modelling (LAP05), Kiruna, Sweden. Linköpings Universitet 03, 2015.
and Högskolan i Borås, Linköping and Borås, pp. 139-155.
2005. [25] Open Services for Lifecycle Collaboration “OSLC”, an
open community building practical specifications for
[13] Lank, Edward, J. Thorley, Sean Chen, and Dorothea integrating software, http://open-services.net/ , last visited Jul.
Blostein. "On-line recognition of UML diagrams." In 16, 2015.
Document Analysis and Recognition, 2001. Proceedings. Sixth
International Conference on, pp. 356-360. IEEE, 2001.
[14] Magin, Michael, and Stephan Kopf. "A Collaborative
Multi-Touch UML Design Tool." Technical reports 13 (2013).
[15] Mangano, Nicolas, Thomas D. LaToza, Marian Petre, and
André van der Hoek. "Supporting informal design with
interactive whiteboards." In Proceedings of the SIGCHI
Conference on Human Factors in Computing Systems, pp.
331-340. ACM, 2014.
[16] Moody, Daniel L. "The “physics” of notations: toward a
scientific basis for constructing visual notations in software
engineering." Software Engineering, IEEE Transactions on
35, no. 6 (2009): 756-779.
[17] Nakakoji, Kumiyo, Yasuhiro Yamamoto, Nobuto
Matsubara, and Yoshinari Shirai. "Toward Unweaving
Streams of Thought for Reflection in Professional Software
Design." Software, IEEE 29, no. 1 (2012): 34-38.
16