CMPT 270: Developing Object Oriented Systems in Java

I taught CMPT 270, Developing Object Oriented Systems in Fall 2019 where 188 students enrolled to attend the course. CMPT 270 is an anchor course of the 2nd year curriculum that needs to be completed by all compute science majors.

CMPT898: Human-Driven Software Engineering for Scientific Research

I taught CMPT 898, Human-Driven Software Engineering for Scientific Research last year (Spring and Summer Term 2019). This is an entirely new graduate course that I offered. With this course I wanted to establish my own research direction in interactive software engineering. I have been also teaching this course in Spring 2020. In this course I focus on how practitioners can engineer software engineering tools and techniques by considering human computer interaction (HCI) aspects.

Related Topics and papers:

Following topics are covered in this course to ensure human aspects are considered in software engineering.

 1.      Usability Engineering:

 [1] folmer, eelke & Welie, Martijn & Bosch, Jan. (2006). Bridging patterns: An approach to bridge gaps between SE and HCI. Information and Software Technology. 48. 69-89. 10.1016/j.infsof.2005.02.005. (pdf)

Abstract: Adding usability improving solutions during late stage development is to some extent restricted by the software architecture. However, few software engineers and human–computer interaction engineers are aware of this important constraint and as a result avoidable rework is frequently necessary. In this paper we present a new type of pattern called a bridging pattern. Bridging patterns extend interaction design patterns by adding information on how to generally implement this pattern. Bridging patterns can be used for architectural analysis: when the generic implementation is known, software architects can assess what it means in their context and can decide whether they need to modify the software architecture to support these patterns. This may prevent part of the high costs incurred by adaptive maintenance activities once the system has been implemented and leads to architectures with better support for usability.

[2] Roy, Banani & Graham, T.C. & Gutwin, Carl. (2012). DiscoTech: A Toolkit for Handling User Level Disconnection Problems in Synchronous Groupware. CSCW 2012. (pdf)

Abstract: During a collaboration session in synchronous groupware participants can often get disconnected, which causes various user level problems, such as interpretation difficulties, confusion and misunderstanding To date, no toolkit exists for providing programming support for developers to solve user level disconnection problems. In this paper, we present a toolkit called DiscoTech that offers a gentle learning curve programming solution to the groupware developers for handling user level disconnection problems.

[3] Christopher Wolfe, T.C. Nicholas Graham, W. Greg Phillips and Banani Roy, Fiia: User-Centered Development of Adaptive Groupware Systems, in Proceedings of the ACM SIGCHI Symposium on Engineering Interactive Computing Systems, ACM, pp. 275-284, 2009. (pdf)

Abstract: Adaptive groupware systems support changes in users’ locations, devices, roles and collaborative structure. Developing such systems is difficult due to the complex distributed systems programming in-volved. In this paper, we introduce Fiia, a novel architectural style for groupware. Fiia is user-centered, in that it allows easy specification of groupware structured around users’ settings, devices and applications, and where adaptations are specified at a high level similar to scenarios. The Fiia.Net toolkit automatically maps Fiia architectures to a wide range of possible distributed systems, under control of an annotation language. Together, these allow developers to work at a high level, while retaining control over distribution choices.

[4] Mostaeen, Golam & Roy, Banani & Roy, Chanchal & Schneider, Kevin. (2019). Designing for Real-Time Groupware Systems to Support Complex Scientific Data Analysis. Proceedings of the ACM on Human-Computer Interaction. 3. 1-28. 10.1145/3331151.  (pdf)

Abstract: Scientific Workflow Management Systems (SWfMSs) have become popular for accelerating the specification, execution, visualization, and monitoring of data-intensive scientific experiments. Unfortunately, to the best of our knowledge no existing SWfMSs directly support collaboration. Data is increasing in complexity, dimensionality, and volume, and the efficient analysis of data often goes beyond the realm of an individual and requires collaboration with multiple researchers from varying domains. In this paper, we propose a groupware system architecture for data analysis that in addition to supporting collaboration, also incorporates features from SWfMSs to support modern data analysis processes. As a proof of concept for the proposed architecture we developed SciWorCS – a groupware system for scientific data analysis. We present two real-world use-cases: collaborative software repository analysis and bioinformatics data analysis. The results of the experiments evaluating the proposed system are promising. Our bioinformatics user study demonstrates that SciWorCS can leverage real-world data analysis tasks by supporting real-time collaboration among users.

2.      Program comprehension at architectural level

[1] V. Walunj, G. Gharibi, D. H. Ho and Y. Lee, “GraphEvo: Characterizing and Understanding Software Evolution using Call Graphs,” 2019 IEEE International Conference on Big Data (Big Data), Los Angeles, CA, USA, 2019, pp. 4799-4807, doi: 10.1109/BigData47090.2019.9005560. (pdf)

Abstract: Understanding software evolution is an imperative prerequisite for software related activities such as testing, debugging, and maintenance. As a software system evolves, it increases in size and complexity, introducing new challenges of understating the inner system interactions and subsequently hinders the overall system comprehension. While tools that construct and visualize call graphs have been used to facilitate software comprehension, they are still limited to capturing the functionality of a single software system at a time. However, understanding the similarities and differences across multiple releases becomes an imperative and challenging task during software evolution. To this end, we present a tool, named GraphEvo, that focuses on automating the process of quantifying and visualizing the changes across multiple releases of a software system based on an information-theoretic approach to compare the call graphs. Specifically, GraphEvo can automatically (1) construct and visualize the call graph for one or more software releases, (2) calculate and display a set of graph-based metrics, and (3) construct color-coded call graphs to visualize system evolution. The main goal of GraphEvo is to assist software developers and testers in exploring and tracking software changes over time. We demonstrate the functionality of GraphEvo by analyzing and studying five real software systems throughout their entire lifespan. The tool, evaluation results, and a video demo are available at

[2] Murphy, Gail & Notkin, David & Sullivan, Kevin. (2001). “Software Reflexion Models: Bridging the Gap between Design and Implementation”. Software Engineering, IEEE Transactions on. 27. 364 – 380. 10.1109/32.917525. (pdf)

Abstract: The artifacts constituting a software system often drift apart over time. We have developed the software reflexion model technique to help engineers perform various software engineering tasks by exploiting, rather than removing, the drift between design and implementation. More specifically, the technique helps an engineer compare artifacts by summarizing where one artifact (such as a design) is consistent with and inconsistent with another artifact (such as source). The technique can be applied to help a software engineer evolve a structural mental model of a system to the point that it is “good enough” to be used for reasoning about a task at hand. The software reflexion model technique has been applied to support a variety of tasks, including design conformance, change assessment, and an experimental reengineering of the million-lines-of-code Microsoft Excel product. We provide a formal characterization of the reflexion model technique, discuss practical aspects of the approach, relate experiences of applying the approach and tools, and place the technique into the context of related work

3.   Developers’ productivity

[1] Ebert, Felipe & Castor, Fernando & Novielli, Nicole & Serebrenik, Alexander. (2019). Confusion in Code Reviews: Reasons, Impacts, and Coping Strategies. 49-60. 10.1109/SANER.2019.8668024. (pdf)

Abstract: Code review is a software quality assurance practice widely employed in both open source and commercial software projects to detect defects, transfer knowledge and encourage adherence to coding standards. Notwithstanding, code reviews can also delay the incorporation of a code change into a code base, thus slowing down the overall development process. Part of this delay is often a consequence of reviewers not understanding, becoming confused by, or being uncertain about the intention, behavior, or effect of a code change. We investigate the reasons and impacts of confusion in code reviews, as well as the strategies developers adopt to cope with confusion. We employ a concurrent triangulation strategy to combine the analyses of survey responses and of the code review comments, and build a comprehensive confusion framework structured along the dimensions of the review process, the artifact being reviewed, the developers themselves and the relation between the developer and the artifact. The most frequent reasons for confusion are the missing rationale, discussion of nonfunctional requirements of the solution, and lack of familiarity with existing code. Developers report that confusion delays the merge decision, decreases review quality, and results in additional discussions. To cope with confusion developers request information, improve familiarity with existing code, and discuss off-line. Based on the results, we provide a series of implications for tool builders, as well as insights and suggestions for researchers. The results of our work offer empirical justification for the need to improve code review tools to support developers facing confusion. Index

[2] Kersten, Mik & Mik, & Murphy, Gail & C, Gail. (2006). Using task context to improve programmer productivity. 10.1145/1181775.1181777. (pdf)

Abstract: When working on a large software system, a programmer typically spends an inordinate amount of time sifting through thousands of artifacts to find just the subset of information needed to complete an assigned task. All too often, before completing the task the programmer must switch to working on a different task. These task switches waste time as the programmer must repeatedly find and identify the information relevant to the task-at-hand. In this paper, we present a mechanism that captures, models, and persists the elements and relations relevant to a task. We show how our task context model reduces information overload and focuses a programmer’s work by filtering and ranking the information presented by the development environment. A task context is created by monitoring a programmer’s activity and extracting the structural relationships of program artifacts. Operations on task contexts integrate with development environment features, such as structure display, search, and change management. We have validated our approach with a longitudinal field study of Mylar, our implementation of task context for the Eclipse development environment. We report a statistically significant improvement in the productivity of 16 industry programmers who voluntarily used Mylar for their daily work.

4.  Designing and evaluating interface for a SE technique  

[1] Bateman, Scott & Mandryk, Regan & Gutwin, Carl & Genest, Aaron & Mcdine, David & Brooks, Christopher. (2010). Useful Junk? The effects of visual embellishment on comprehension and memorability of charts. Conference on Human Factors in Computing Systems – Proceedings. 4. 2573-2582. 10.1145/1753326.1753716. (pdf)

Abstract: Guidelines for designing information charts often state that the presentation should reduce ‗chart junk’ – visual embellishments that are not essential to understanding the data. In contrast, some popular chart designers wrap the presented data in detailed and elaborate imagery, raising the questions of whether this imagery is really as detrimental to understanding as has been proposed, and whether the visual embellishment may have other benefits. To investigate these issues, we conducted an experiment that compared embellished charts with plain ones, and measured both interpretation accuracy and long-term recall. We found that people’s accuracy in describing the embellished charts was no worse than for plain charts, and that their recall after a two-to-three-week gap was significantly better. Although we are cautious about recommending that all charts be produced in this style, our results question some of the premises of the minimalist approach to chart design.

[2] Debashish Chakroborti and Banani Roy. Designing for Recommending Intermediate States in A Scientific Workflow Management System. EICS 2020, in Major Revision stage.

Abstract: To process a large amount of data sequentially and systematically, proper management of workflow components (i.e., modules, data, configurations, associations among ports and links) in a Scientific Workflow Management System (SWfMS) is inevitable. Managing data with provenance information in a SWfMS to support reusability of workflows, modules, and data is not a simple task. Handling such components is even more burdensome for frequently assembled and executed complex workflows for investigating large datasets with different technologies (i.e., various learning algorithms or models). However, a great many studies propose various techniques and technologies for managing and recommending services in a SWfMS, but only a very few studies consider the management of data in a SWfMS for effcient storing and facilitating workflow executions. Furthermore, there is no study to inquire about the effectiveness and effciency of such data management in a SWfMS from a user perspective. In this paper, we present and evaluate a GUI version of such a novel approach of intermediate data management with two use cases (Plant Phenotyping and Bioinformatics). The technique we call RISP (Recommending Intermediate States from Pipelines) can facilitate executions of workflows with processed data and can thus reduce the computational time of some modules in a SWfMS. We integrated RISP with an existing workflow management system called SciWorCS. In SciWorCS, we also designed an interface that users use for selecting the recommendation of intermediate states. We investigated GUI-RISP’s effectiveness from users’ perspectives along with measuring its overhead in terms of storage and effciency in workflow execution.

 5. Social software engineering