Round-Trip Sketches: Supporting the Lifecycle of Software Development Sketches from Analog to Digital and Back

08/05/2017 ∙ by Sebastian Baltes, et al. ∙ 0

Sketching is an important activity for understanding, designing, and communicating different aspects of software systems such as their requirements or architecture. Often, sketches start on paper or whiteboards, are revised, and may evolve into a digital version. Users may then print a revised sketch, change it on paper, and digitize it again. Existing tools focus on a paperless workflow, i.e., archiving analog documents, or rely on special hardware - they do not focus on integrating digital versions into the analog-focused workflow that many users follow. In this paper, we present the conceptual design and a prototype of LivelySketches, a tool that supports the "round-trip" lifecycle of sketches from analog to digital and back. The proposed workflow includes capturing both analog and digital sketches as well as relevant context information. In addition, users can link sketches to other related sketches or documents. They may access the linked artifacts and captured information using digital as well as augmented analog versions of the sketches. We further present results from a formative user study with four students and outline possible directions for future work.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 3

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

Sketches and diagrams play an important role in design-related activities [1, 2, 3]. Artists sketch to clarify existing ideas and to develop new ones [4]. In mechanical design, sketches not only document final designs, but also provide designers with a memory extension to help ideas taking shape and to communicate concepts to colleagues [5]. Beside sketches being an external representation of memory and a means for communication [6, 7], they serve as documentation [8]. The ambiguity in sketches is a source of creativity [9] and they support problem solving and understanding [10]. In engineering, controlled experiments have shown that the possibility to sketch has a positive effect on the quality of the solution [8]. Software developers use sketches and diagrams to understand, to design, and to communicate different aspects of software systems [11, 12, 13, 14]. Most software engineering sketches do not follow formal conventions like the Unified Modeling Language (UML), but have an informal, ad-hoc nature [12, 15, 11, 14, 16].

Media used for sketch creation include not only whiteboards and paper, but also software tools like Photoshop and PowerPoint [13, 12, 17, 16, 14]. Often, sketches are revised [14] and pass through transitions from analog to digital media [13], because digital sketches can more easily be edited, copied, organized, and shared [18]. Even if a digital version exists, analog sketches may be kept as a memory aid [19]. Context information is often needed to understand informal sketches [20] and information may get lost due to the transient nature of sketches [12, 14].

Despite the widespread usage of sketches in many domains, to the best of our knowledge there is currently no tool that explicitly supports the complete analog and digital lifecycle of sketches. Popular tools like EverNote and OneNote focus on a paperless workflow, i.e., archiving analog documents, not on integrating digital versions into the analog-focused workflow that many users follow [14, 19]. Other proposed tools rely on special hardware like digital pens and compatible paper for creating analog sketches [21, 22, 23, 24], need a special scanning device to access digital versions [25], or treat analog documents only as passive link anchors for digital resources [26].

From the literature cited above and in particular our own research on the use of sketches and diagrams in software engineering practice [14], we derived four main requirements that a tool supporting the analog and digital lifecycle of sketches should implement: (1) it should be possible to archive analog sketches along with context information needed for their understanding, (2) the tool should provide a version control for evolving sketches, (3) since sketches are usually connected and embedded in a work context, it should be possible to link them to other sketches or related artifacts, and (4) the tool should support the “round-trip” of sketches from analog to digital and back. In the following, we further elaborate on the conceptual design, present a prototype implementation of this concept named LivelySketches, and report findings from a formative user study.

Ii Conceptual Design

[width=0.98]figures/lifecycle

Fig. 1: The conceptual workflow of round-trip sketching from analog to digital and back.

Sketches often start on analog media like paper or whiteboards and later get digitized to share and revise them [14, 12, 19]. However, sketches do not only evolve digitally, but may be printed out or redrawn on paper or whiteboards. We denote this process involving transitions from analog to digital sketching and vice versa as “round-trip sketching”. In this section, we describe an exemplary scenario and a conceptual workflow to derive requirements for a tool providing support for round-trip sketching.

In our scenario, a software development team discusses possible extensions of an app. They collect emerging ideas in a shared whiteboard sketch. Furthermore, some developers write down their own thoughts in personal notebooks. At some point, the whiteboard becomes too cluttered and the team leader decides to clean the whiteboard partially. After the meeting, one developer is asked to create a polished version of the whiteboard sketch for the customer. This sketch is also posted in an internal development wiki. A week later, the team uses a printout of the polished sketch together with the developers’ notes to continue where they left off.

In this scenario, several issues arise: When the whiteboard is cleaned, it is not possible to go back to erased content that may still be relevant to understand the evolution of the sketch. Further, the developers’ notes are related to the shared sketch, but the connection is only present in their mind. To be able to refine the whiteboard sketch, the developer may need contextual information that has not been captured during the meeting. If the sketch is shared with others (e.g., in a wiki), parallel versions of the sketch may evolve that are later merged during the next meeting. This evolution of the sketch can either happen on analog or digital media. A tool supporting round-trip sketching should addresses these issues by providing means to capture context, manage revisions, and link sketches to related sketches or other artifacts. It should then be possible to access this information using digital as well as augmented analog versions of a sketch.

Figure 1 visualizes the conceptual workflow for round-trip sketching including different transitions from analog to digital media and back: The lifecycle starts with the creation of an analog sketch (1). The user decides that the sketch is worth capturing and adds a generated QR code label to the sketch (2) to be able to identify this version later. Then, he or she uses a tablet to capture the sketch (3). At that point, it is possible to add metadata like authors, textual annotations, or even short videos explaining the content of the sketch (4). After the sketch is digitized, users may add content using tools like Gimp, Visio, or Photoshop, or utilize the sketch to redraw a revised digital version. The tool should allow users to easily add these new revisions to the captured sketch. Generally, if analog and digital versions of a sketch evolve concurrently, version control should help to keep track of their relation and should assist in merging versions existing in the analog as well as in the digital world. Users may also link the whole sketch or parts of it to other related sketches or documents to embed the artifact in the work context (5). To return from digital to analog, the user can print the revised sketch, for instance to bring it to a meeting (6). Using the QR code on the printed or the initial sketch, the user can access all revisions of the sketch as well as linked artifacts and captured metadata (7). To close the circle, users may add content to the printed sketch (8) and capture this new revision with a tablet to access, refine, or share it later (9).

For a first prototype implementation supporting the workflow described above, we formulated six requirements:

[width=]figures/metaview_annotated.png

(a) MetaView: Show/add metadata, version control.

[width=]figures/linkview.png

(b) LinkView: Manage links to other sketches.
Fig. 2: Two views of the LivelySketches prototype.
  • [labelindent=0pt, labelwidth=(augment), label=(augment), leftmargin=*, align=parleft, parsep=1ex, partopsep=1ex, topsep=1ex, itemsep=0.5ex]

  • The tool should allow users to unambiguously identify analog and digital sketches.

  • The tool should enable users to capture analog sketches along with context information.

  • The tool should enable users to add both analog and digital revisions to a captured sketch.

  • The tool should allow users to link captured sketches to related sketches and other artifacts.

  • The tool should allow users to print captured and digitally revised sketches.

  • The tool should allow showing captured metadata and linked artifacts of identified sketches.

These requirements cover the main requirements mentioned in the introduction, which we derived from related work and our own research on sketches and diagrams in software development (1REQ2+6, 2REQ3, 3REQ4, 4REQ1+5).

[width=0.95]figures/architecture

Fig. 3: Architecture of LivelySketches

Iii Prototype Implementation

To be able to evaluate the conceptual workflow, we created a prototype that implements the above requirements. It uses a simple client-server architecture (see Figure 3). The client is web-based and runs on both desktop and mobile browsers. We optimized the GUI to be used on touch devices and tested it on an Apple iPad. The server is responsible for storing and managing the versioned sketches and for creating and decoding the QR codes used to identify sketches. It provides a REST API [27] that the client uses to upload and retrieve data. The web client of LivelySketches provides three main views: One view to open captured sketches and to add new ones (OverView), one view to add and view metadata and to manage the revisions of a sketch (MetaView), and one view to link a captured sketch or parts of it to other sketches (LinkView). The latter two views are depicted in Figure 2. In the following, we describe how the prototype implements the above requirements.

REQ1 (Identification)

Every sketch is identified by a Universally Unique Identifier (UUID). This identifier is either assigned to a sketch when it is uploaded to the server or by sticking a prepared QR code label to it. LivelySketches allows to create lists with QR codes that encode predefined UUIDs. These lists can then be printed to adhesive labels. The labels are very small () and thus do not distract from the main content of the sketch (see Figure 4 for an example from the formative study). One sheet contains 13 rows with different UUID and 10 identical labels in each row. This enables the user to mark different revisions of the same sketch drawn on different sheets of paper with the same label. LivelySketches then recognizes the identical codes and adds later uploaded sketches as revisions of the first one. The tool also allows the user to generate labels for already captured sketches to mark new analog revisions of them. Further, QR codes can be digitally added to a sketch after uploading it. However, we recommend to always use labels to mark analog sketches to be able to reference them later.

REQ2 (Capturing)

Using the main view of the app, the user can open already captured sketches or upload new sketches. He or she can either upload a JPEG or PNG file or use the tablet’s camera to take a picture of an analog sketch. The tool then allows the user to add different meta information like title, author names, or date. After the sketch is uploaded, the MetaView (see Figure 1(a)) provides the functionality to add textual annotations, audio, or video files to the sketch. Again, existing files can be uploaded or the tablet camera can be used to record these annotations.

REQ3 (Versioning)

As mentioned above, sketches are often revised and redrawn. To keep track of the history of a sketch, the prototype enables the user to add new revisions that were created either on analog or digital media. LivelySketches follows a state-based extensional versioning approach [28] that establishes a simple linear successor relationship between the revisions of a sketch. The sequential order of the revisions is shown in the lower part of the MetaView. When adding a new revision, the tool asks for a commit message describing the modifications that took place between the two revisions. Further, the tool assists the user in transferring metadata from a previous version.

REQ4 (Linking)

To link sketches, the prototype provides a dedicated view (see Figure 1(b)). A link always connects whole sketches or parts of sketches that are identified using a link anchor. Currently, LivelySketches only allows to use rectangular link anchors, but we plan to extend this with other shapes or a free-form selection to allow for a more fine-grained selection.

REQ5 (Printing)

In the MetaView, sketches can be either printed directly or the image files may be downloaded. Furthermore, this view allows the user to print a list of QR code labels that may be used to identify new analog revisions of the sketch.

REQ6 (Augmenting)

Using the corresponding button in the header of LivelySketches, it is possible to scan the QR code of an analog sketch. The system then decodes the UUID of the sketch, opens the MetaView and automatically switches to the most recent revision. The user can then browse to the history of the scanned sketch, access or add metadata, or navigate to linked sketches.

Iv Formative User Study

A formative user study is a study conducted “during the development of a product […] to mould or improve the product” [29]. To get early feedback for improving the prototype we conducted such a study with four participants. All participants were computer science graduate students. During the study, they worked in teams of two to design a graphical user interface for a dice game. After a short introduction into the LivelySketches prototype, we provided them the rules of the game they were going to design, paper and pencils for drawing sketches, an Apple iPad running the prototype, and a prepared sheet with QR code labels. Then, we gave them a task description for the study, namely to design a GUI and a storyboard for the game at hand. During the study, we captured audio and video data. We recorded both the sketching activity on the desk with a camcorder as well as the interaction with the tool using a screen capturing software. We provide all sketches created during the study as well as the screen captures as supplementary material [30]. After the study, the participants filled in a system usability scale (SUS) questionnaire which we used as a “quick and dirty” way of accessing the tool’s usability [31].

[width=]figures/sketch_group1

Fig. 4: Sketch with QR code created during formative study.

Participants’ comments and a SUS score of 81.3 indicate that they were very satisfied with the performance and stability of the tool. Since we conducted the study to improve the tool, we will focus on possible improvements and feature requests in the following: Because it is tedious to enter the author names each time a sketch is captured, participants requested a user management that would allow them to automatically add their own username or usernames of other registered authors. Currently, all sketches are managed globally, which was not a problem during this short study, but for real-world usage, participants proposed to add a feature allowing to assign sketches to certain projects.

Regarding the link anchors, participants requested other shapes and free-form anchors to be more flexible in linking parts of sketches. Further, they wanted to be able to automatically center the view around a selected anchor and then zoom into the linked part of the sketch. This would be particularly useful when capturing large sketches, for example from whiteboards. Regarding the linked sketches, participants proposed a global view visualizing all sketches and all links between them. In this view, it would then be possible to zoom in and out and to navigate through this structure by following the links. We will consider the comments and feature requests described above in the future development of the tool.

V Conclusion and Future Work

In this paper, we presented the conceptual design of round-trip sketching as well as a prototype implementation named LivelySketches that supports the lifecycle of sketches from analog to digital media and back. It enables users to manually capture both analog and digital sketches as well as relevant context information. The captured sketches can then be organized in a common version history. Further, LivelySketches allows linking sketches to related sketches. We conducted a formative user study and got valuable insights to improve the tool. In the future, we plan to extend LivelySketches to allow users to also link sketches to other relevant resources like documents, emails, or source code [32]. A linked sketch could then be used to navigate through linked artifacts.

Although we tried to support a very common scenario motivated by related studies, the evolution of a sketch from paper to a digitally revised version (and back) is not the only possible workflow. Walny et al. [19] present an overview of other possible lifecycles of software development sketches. We want to evaluate the tool in a larger context to see how well it integrates into “real-life” settings. The proposed approach works best with paper sketches, but it is also possible to capture sketches on whiteboards using a tablet camera. In this scenario, the original sketch is lost when the whiteboard is erased, but the lifecycle can continue with the digitally captured version or with a printout.

LivelySketches can be used to capture storyboards for graphical user interfaces, connect sketches and visualizations of different components of a software architecture, connect visualizations of dynamic and static aspects of software (e.g. UML class and sequence diagrams), or connect visualizations of different steps in the development process of a software project. However, the application area of LivelySketches is not limited to software development—the approach can be adapted to any discipline where sketching plays an important role.

Acknowledgments

The authors would like to thank the participants of the formative study for their valuable feedback.

References

  • [1] S. Sonnentag, “Expertise in professional software design: A process study.” Journal of Applied Psychology, vol. 83, no. 5, pp. 703–715, 1998.
  • [2] B. Tversky, M. Suwa, M. Agrawala, J. Heiser, C. Stolte, P. Hanrahan, D. Phan, J. Klingner, M.-P. Daniel, P. Lee et al., “Sketches for design and design of sketches,” in Human Behaviour in Design.   Springer, 2003, pp. 79–86.
  • [3] A. Black, “Visible planning on paper and on screen: The impact of working medium on decision-making by novice graphic designers,” Behaviour & Information Technology, vol. 9, no. 4, pp. 283–296, 1990.
  • [4] J. Fish and S. Scrivener, “Amplifying the mind’s eye: sketching and visual cognition,” Leonardo, vol. 23, no. 1, pp. 117–126, 1990.
  • [5] D. G. Ullman, S. Wood, and D. Craig, “The importance of drawing in the mechanical design process,” Computers & Graphics, vol. 14, no. 2, pp. 263–274, 1990.
  • [6] B. Tversky, “What do sketches say about thinking?” in AAAI Spring Symposium, Sketch Understanding Workshop, Stanford University.   AAAI, 2002, pp. 148–151.
  • [7] ——, “Spatial schemas in depictions,” in Spatial Schemas and Abstract Thought.   MIT Press, 2001, pp. 79–111.
  • [8] M. Schütze, P. Sachse, and A. Römer, “Support value of sketching in the design process,” Research in Engineering Design, vol. 2, no. 14, pp. 89–97, 2003.
  • [9] G. Goldschmidt, “The backtalk of self-generated sketches,” Design Issues, vol. 19, no. 1, pp. 72–88, 2003.
  • [10] M. Suwa and B. Tversky, “External representations contribute to the dynamic construction of ideas,” in Diagrammatic representation and inference.   Springer, 2002, pp. 341–343.
  • [11] U. Dekel and J. D. Herbsleb, “Notation and representation in collaborative object-oriented design: An observational study,” in ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2007).   ACM, 2007, pp. 261–280.
  • [12] M. Cherubini, G. Venolia, R. DeLine, and A. J. Ko, “Let’s go to the whiteboard: how and why software developers use drawings,” in 25th ACM SIGCHI Conference on Human Factors in Computing Systems (CHI 2010).   ACM, 2007, pp. 557–566.
  • [13] J. Walny, M. S. T. Carpendale, N. Henry Riche, G. Venolia, and P. Fawcett, “Visual thinking in action: Visualizations as used on whiteboards,” IEEE Transactions on Visualization and Computer Graphics, vol. 17, no. 12, pp. 2508–2517, 2011.
  • [14] S. Baltes and S. Diehl, “Sketches and diagrams in practice,” in 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE 2014).   ACM, 2014, pp. 530–541.
  • [15] M. Petre, “UML in practice,” in 35th International Conference on Software Engineering (ICSE 2013).   IEEE Computer Society, 2013, pp. 722–731.
  • [16] T. Gorschek, E. D. Tempero, and L. Angelis, “On the use of software design models in software development practice: An empirical investigation,” Journal of Systems and Software, vol. 95, pp. 176–193, 2014.
  • [17] B. A. Myers, S. Y. Park, Y. Nakano, G. Mueller, and A. J. Ko, “How designers design and program interactive behaviors,” in IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC 2008).   IEEE, 2008, pp. 177–184.
  • [18] W. Willett, P. Goffin, and P. Isenberg, “Understanding digital note-taking practice for visualization,” IEEE Computer Graphics and Applications, vol. 35, no. 4, pp. 38–51, 2015.
  • [19] J. Walny, J. Haber, M. Dörk, J. Sillito, and M. S. T. Carpendale, “Follow that sketch: Lifecycles of diagrams and sketches in software development,” in 6th IEEE International Workshop on Visualizing Software for Understanding and Analysis (VISSOFT 2011).   IEEE, 2011, pp. 1–8.
  • [20] T. D. LaToza, G. Venolia, and R. DeLine, “Maintaining mental models: A study of developer work habits,” in 28th International Conference on Software Engineering (ICSE 2006).   ACM, 2006, pp. 492–501.
  • [21] F. Guimbretière, “Paper augmented digital documents,” in Proceedings of the 16th Annual ACM Symposium on User Interface Software and Technology (UIST 2003).   ACM, 2003, pp. 51–60.
  • [22] C. Liao, F. Guimbretière, and C. E. Loeckenhoff, “Pen-top feedback for paper-based interfaces,” in Proceedings of the 16th Annual ACM Symposium on User Interface Software and Technology (UIST 2006), vol. 6, 2006, pp. 15–18.
  • [23] C. Liao, F. Guimbretière, K. Hinckley, and J. Hollan, “Papiercraft: A gesture-based command system for interactive paper,” ACM Transactions on Computer-Human Interaction (TOCHI), vol. 14, no. 4, 2008.
  • [24] N. Weibel, A. Ispas, B. Signer, and M. C. Norrie, “Paperproof: a paper-digital proof-editing system,” in Extended Abstracts on Human Factors in Computing Systems (CHI 2008).   ACM, 2008, pp. 2349–2354.
  • [25] M. C. Norrie and B. Signer, “Switching over to paper: a new web channel,” in Proceedings of the Fourth International Conference on Web Information Systems Engineering (WISE 2003).   IEEE, 2003, pp. 209–218.
  • [26] L. Bian and R. Shilkrot, “Palimpost: Information convergence using sticky notes,” in Proceedings of the 2nd International Workshop on Web of Things (WoT 2011).   ACM, 2011, pp. 13–18.
  • [27] R. T. Fielding, “Architectural styles and the design of network-based software architectures,” Ph.D. dissertation, University of California, Irvine, 2000.
  • [28] R. Conradi and B. Westfechtel, “Version models for software configuration management,” ACM Computing Surveys (CSUR), vol. 30, no. 2, pp. 232–282, 1998.
  • [29] D. Travis, “Usability test reporting,” Accessed 23 June 2017, April 2006. [Online]. Available: http://www.measuringu.com/blog/formative-summative.php
  • [30] S. Baltes, F. Hollerich, and S. Diehl, “LivelySketches—Supplementary Material,” June 2017. [Online]. Available: https://doi.org/10.5281/zenodo.818197
  • [31] J. Brooke et al., “Sus—a quick and dirty usability scale,” Usability evaluation in industry, vol. 189, no. 194, pp. 4–7, 1996.
  • [32] S. Baltes, P. Schmitz, and S. Diehl, “Linking sketches and diagrams to source code artifacts,” in 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE 2014).   ACM, 2014, pp. 743–746.