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