diff --git a/src/conf.py b/src/conf.py index 10cfb52..83f41b8 100644 --- a/src/conf.py +++ b/src/conf.py @@ -39,7 +39,8 @@ # ones. extensions = [ 'sphinxcontrib.bibtex', - 'sphinx.ext.todo' + 'sphinx.ext.todo', + 'sphinx.ext.autosectionlabel', ] # Add any paths that contain templates here, relative to this directory. @@ -100,3 +101,6 @@ def setup(app): ''', 'extraclassoptions': 'openany,oneside', } + +# avoid duplicate label +autosectionlabel_prefix_document = True diff --git a/src/language-usability.bib b/src/language-usability.bib new file mode 100644 index 0000000..6e52ae5 --- /dev/null +++ b/src/language-usability.bib @@ -0,0 +1,86 @@ +@inproceedings{brown1991zeus, + title={Zeus: A system for algorithm animation and multi-view editing}, + author={Brown, Marc H}, + booktitle={Proceedings 1991 IEEE Workshop on Visual Languages}, + pages={4--9}, + year={1991}, + organization={IEEE} +} + +@article{stasko1993methodology, + title={A methodology for building application-specific visualizations of parallel programs}, + author={Stasko, John T and Kraemer, Eileen}, + journal={Journal of parallel and distributed computing}, + volume={18}, + number={2}, + pages={258--264}, + year={1993}, + publisher={Elsevier} +} + +@article{price1993principled, + title={A principled taxonomy of software visualization}, + author={Price, Blaine A and Baecker, Ronald M and Small, Ian S}, + journal={Journal of Visual Languages \& Computing}, + volume={4}, + number={3}, + pages={211--266}, + year={1993}, + publisher={Elsevier} +} + +@article{sorva2013review, + title={A review of generic program visualization systems for introductory programming education}, + author={Sorva, Juha and Karavirta, Ville and Malmi, Lauri}, + journal={ACM Transactions on Computing Education (TOCE)}, + volume={13}, + number={4}, + pages={15}, + year={2013}, + publisher={ACM} +} + +@inproceedings{maletic2002task, + title={A task oriented view of software visualization}, + author={Maletic, Jonathan I and Marcus, Andrian and Collard, Michael L}, + booktitle={Proceedings First International Workshop on Visualizing Software for Understanding and Analysis}, + pages={32--40}, + year={2002}, + organization={IEEE} +} + +@inproceedings{murphy2010interactive, + title={An interactive ambient visualization for code smells}, + author={Murphy-Hill, Emerson and Black, Andrew P}, + booktitle={Proceedings of the 5th International Symposium on Software visualization}, + pages={5--14}, + year={2010}, + organization={ACM} +} + +@inproceedings{reiss2005paradox, + title={The paradox of software visualization}, + author={Reiss, Steven P}, + booktitle={3rd IEEE International Workshop on Visualizing Software for Understanding and Analysis}, + pages={1--5}, + year={2005}, + organization={IEEE} +} + +@incollection{de2002visualizing, + title={Visualizing the execution of {Java} programs}, + author={De Pauw, Wim and Jensen, Erik and Mitchell, Nick and Sevitsky, Gary and Vlissides, John and Yang, Jeaha}, + booktitle={Software Visualization}, + pages={151--162}, + year={2002}, + publisher={Springer} +} + +@inproceedings{goodall2010visual, + title={Visual analysis of code security}, + author={Goodall, John R and Radwan, Hassan and Halseth, Lenny}, + booktitle={Proceedings of the seventh International Symposium on visualization for cyber security}, + pages={46--51}, + year={2010}, + organization={ACM} +} diff --git a/src/language-usability.rst b/src/language-usability.rst index e7a5e88..ecb4283 100644 --- a/src/language-usability.rst +++ b/src/language-usability.rst @@ -1,4 +1,4 @@ -.. :Authors: - Cyrus Omar +.. :Authors: - Cyrus Omar, Yongwei Yuan .. title:: Language Usability @@ -19,5 +19,146 @@ API Usability Program Comprehension ===================== +Software Visualization +---------------------- + +.. container:: bib-item + + .. bibliography:: language-usability.bib + :filter: key == "price1993principled" + + The paper defines **software visualization** as the use of the crafts of typography, graphic design, animation, and cinematography with modern human-computer interaction technology to facilitate both the human understanding and effective use of computer software. This paper also gives a detailed "road map" of the work accomplished so far in **software visualization**, by identifying six broad categories of characteristics and by filling in the observed characteristics in each category. + + * Scope - what is the range of program that the SV system may take as input for visualization + + * Content - what subset of information about the software is visualized by the SV system + + * Form - what are the characteristics of the output of the system, i.e., the visualization + + * Method - what style of visualization specification is used + + * Interaction - how does the user of the SV system interact with and control it + +.. container:: bib-item + + .. bibliography:: language-usability.bib + :filter: key == "maletic2002task" + + Another paper revisits the definition of software visualization systems. By modeling the general way how the human perceives the mapping from data to a visual from, it defines five dimensions to describe several more recent software visualization systems that have very different features along those defined dimensions: + + * Tasks - *why* is the visualization needed? + + * Audience - *who* will use the visualization? + + * Target - *what* is the data source to represent? + + * Representation - *how* to represent it? + + * Medium - *where* to represent the visualization? + + By looking at the current software engineering problems along the given dimensions, open research issues are identified. The paper also discusses how cognitive psychology and information visualization can aid the design of software visualization. Additionally, the paper identifies the strengths of individual tools and the techniques they apply. + +.. container:: bib-item + + .. bibliography:: language-usability2.bib + :filter: key == "isohanni2014visualization" + + This paper studies by whom, how, why, and why not visualization is used in programming education by conduct a worldwide survey for over 250 teachers of programming. There is a trend that more visualization tools are used by teachers teaching teenagers. The topics where visualizations are used most often are basic programming and data structures. On the other hand, there are other reasons more related to teachers' preference, e.g. "I prefer to create my own visualization" or "I do not believe that visualizations are educationally effective in high-level programming courses". Especially noteworthy is that most often the visualization tool is used by the teacher, not the students, which should be taken into account in the future tool and material design and instructions on their usage. + + +.. container:: bib-item + + .. bibliography:: language-usability.bib + :filter: key == "reiss2005paradox" + + This paper argues that most past and current work in the field is out of touch with the reality of software development and that new approaches and new ideas are needed. To be successful today or in the future, software visualization needs to address three kinds of reality. + + * the reality of understanding: Understanding involves design with specific problems that represent task-specific solutions. + + * the reality of software: Today's software are multi-threaded and heterogeneous. + + * the reality of programmer: Software developers want to do their development as quickly, as accurately, and as high quality as possible. + +Algorithm Animation +^^^^^^^^^^^^^^^^^^^ + +**Algorithm animation** techniques aim to communicate the behavior of algorithms through animated visual notation, sometimes together with natural language commentary. It has been used with success in teaching computer science courses, designing and analyzing algorithms, producing technical drawings, tuning performance, and documenting programs. + +.. container:: bib-item + + .. bibliography:: language-usability.bib + :filter: key == "brown1991zeus" + + This paper presents a system for algorithm animation, *Zeus*. To a programmer, *Zeus* can be viewed as a general-purpose framework for associating multiple client-defined views with a set of client-defined events, emitted while an algorithm executes. According to the author, constructing animations in *Zeus* appears to be easy and straightforward. Particularly, object-oriented techniques make it easy to reuse views, and to build sophisticated views by composing and subclassing other views. However, those claims were not rigorously evaluated in the paper. + +.. container:: bib-item + + .. bibliography:: language-usability.bib + :filter: key == "stasko1993methodology" + + Instead of focusing on how to build an easy-to-use algorithm animation system, this paper discusses why we need different forms of visualization for different classes of algorithms, i.e. **application-specific** visualization, and specifically, what is the requirements for parallel program visualizations. Also, a program animation tool called POLKA is developed for case study. It is claimed that by taking advantage of such application-specific visualizations, programmers could rapidly assess the program's correctness, though without rigorous evaluation. + +Program Visualization +^^^^^^^^^^^^^^^^^^^^^ + +**Program visualization** is the use of various techniques to help programmers comprehend computer programs. Program visualization techniques take into account various sources of information, including the structure of the source code and run-time behavior. Some program visualizations designed to aid significantly the practice of professional programming and software engineering, while others are focused on aiding the learning of computer science by novice programmers. Program visualization is different from algorithm visualization in that the latter focuses on the visualization of a high-level description of algorithm or a piece of software which is in contrast to program visualization where actual implemented code is visualized :cite:`price1993principled`. + +.. container:: bib-item + + .. bibliography:: language-usability.bib + :filter: key == "sorva2013review" + + This paper serves as a survey of program visualization systems whose **task** is to aid the learning and teaching of introductory programming, with an intended **audience** of novice programmers and *CS1* teachers. Even a visualization that has been painstakingly crafted to be as lucid as possible may fail to aid learning in practice. Therefore, the paper introduces a new taxonomy to describe how program visualization systems engage learners. + +.. container:: bib-item + + .. bibliography:: language-usability.bib + :filter: key == "murphy2010interactive" + + **Code smells** are characteristics of software that indicate that code may have a design problem. The paper propose a novel smell detector, Stench Blossom, that provides an iteractive ambient visualization designed to first give programmers a quick, high-level overview of the smells, and then to help in understanding the smells if users wish. As a result, the experiment confirmed that programmers identify more smells and make more confident and informed refactoring jedgements using the tool than not using the tool. + +.. container:: bib-item + + .. bibliography:: language-usability.bib + :filter: key == "de2002visualizing" + + Jinsight is a tool for exploring a Java program's runtime behavior visually, featuring a collection of linked views. + + - a basic visualization of resource consumption in terms of classes, instances, and methods + - a reference pattern view with extraneous detail eliminated that could detect memory leak + - a performance analysis by visualizing event sequences + + With Jinsight, users have successfully diagnosed numerous problems on large commercial applications. However, the visualization is specialized for particular tasks and the visualized application could only run on a single *JVM*. + +.. container:: bib-item + + .. bibliography:: language-usability.bib + :filter: key == "goodall2010visual" + + This paper describes a system that brings together the results of disparate software analysis tools into a visual environment to support the triage and exploration of code vulnerabilities. Note that it is an program visualization system because it actually visualizes the vulnerabilities information of a given program, though it takes advantage of other analysis tools. The system could give more confidence that the detected vulnerabilities are not false positive by correlating and normalizing the output of multiple software analysis tools. And also, as for some particular vulnerable code file, the system could figure out which programmer regularly checks in the file or who is the main developer that contribute the most. By choosing either heuristic approach, the user can associate the vulnerability with some programmer. This workflow allows the system to scale to large code bases with tens of thousands of vulnerabilities. However, the paper doesn't evaluate this prototype system at all. + +.. container:: bib-item + + .. bibliography:: language-usability2.bib + :filter: key == "david2016frappe" + + And it turns out that program visualization doesn't have to deal with toy programs. This video introduces a tool called Frappé. Code dependency of the codebase would be represented by a property graph including information of the code and data from different spaces like file system. By specifying queries in terms of the graph, the programmer could locate the code more accurately than traditional text-based searching. + +TODO: maybe include more papers going over other data that could being visualized, i.e., increase the diversity of data sources + Domain-Specific Languages ========================= + +.. container:: hidden + + :cite:`brown1991zeus` + :cite:`stasko1993methodology` + :cite:`price1993principled` + :cite:`maletic2002task` + :cite:`sorva2013review` + :cite:`murphy2010interactive` + :cite:`reiss2005paradox` + :cite:`de2002visualizing` + :cite:`goodall2010visual` + :cite:`david2016frappe` + :cite:`isohanni2014visualization` diff --git a/src/language-usability2.bib b/src/language-usability2.bib new file mode 100644 index 0000000..aba1eaf --- /dev/null +++ b/src/language-usability2.bib @@ -0,0 +1,16 @@ +@misc{david2016frappe, + url={https://www.youtube.com/watch?v=kHSmcJs7phY}, + title={Frappé: Querying and managing evolving code dependency graphs}, + publisher={LDBC}, + year={2016}, + month={June} +} + +@inproceedings{isohanni2014visualization, + title={Are visualization tools used in programming education?: by whom, how, why, and why not?}, + author={Isohanni, Essi and J{\"a}rvinen, Hannu-Matti}, + booktitle={Proceedings of the 14th Koli Calling International Conference on Computing Education Research}, + pages={35--40}, + year={2014}, + organization={ACM} +} diff --git a/src/live-programming.rst b/src/live-programming.rst index 4c8877a..90e050a 100644 --- a/src/live-programming.rst +++ b/src/live-programming.rst @@ -23,10 +23,6 @@ Debugging Interactive Debuggers --------------------- -Program Visualization ---------------------- - - Programming by Demonstration ============================ diff --git a/src/notation.rst b/src/notation.rst index b675b9c..12bc348 100644 --- a/src/notation.rst +++ b/src/notation.rst @@ -1,4 +1,4 @@ -.. :Authors: - Cyrus Omar +.. :Authors: - Cyrus Omar, Yongwei Yuan .. title:: Notation @@ -100,6 +100,13 @@ A **pretty printer** is a function that takes a structure as input and generates This paper reflects on cognitive dimensions theory as a whole and, in particular, states, based on observations made in other studies, that experts are more adept at using secondary notation than novices. +.. container:: bib-item + + .. bibliography:: notation2.bib + :filter: key == "brown1992color" + + This paper focuses on the use of color and sound in **algorithm animation** systems by evaluating their previous work, *Zeus*, a system for algorithm animation and multi-view editing. Color has been used in *Zeus*, for the purpose of encoding the state of data structures, tying views together, highlighting activity, emphasizing patterns, and making history visible. In addition, sound has been used to reinforce visual views, convey patterns, replaces visual views and signals exceptional conditions. For instance, a sound effects "visualization" produces a tone whose pitch rises with the number of active threads. See :ref:`language-usability:Algorithm Animation` for more details about *Zeus* and other algorithm animation systems. + Textual Notation ================ @@ -190,7 +197,6 @@ Customizable Notation Cite Schwerdfeger and Van Wyk - .. container:: hidden :cite:`cajori1993history` @@ -203,4 +209,5 @@ Customizable Notation :cite:`petre2006cognitive` :cite:`hughes95` :cite:`wadler2003prettier` - :cite:`bernardy17` \ No newline at end of file + :cite:`bernardy17` + :cite:`brown1992color` diff --git a/src/notation2.bib b/src/notation2.bib index aa65f0b..525bdba 100644 --- a/src/notation2.bib +++ b/src/notation2.bib @@ -26,3 +26,14 @@ @article{bernardy17 biburl = {https://dblp.org/rec/bib/journals/pacmpl/Bernardy17}, bibsource = {dblp computer science bibliography, https://dblp.org} } + +@article{brown1992color, + title={Color and sound in algorithm animation}, + author={Brown, Marc H and Hershberger, John}, + journal={Computer}, + volume={25}, + number={12}, + pages={52--63}, + year={1992}, + publisher={IEEE} +}