The educational focus in Software Engineering and Computer Science has traditionally been on the theoretical aspects of computation, problem-solving algorithms, and coding skills. Accreditation standards and the Association of Computing Machinery (ACM) curriculum are designed to prepare students for careers and graduate school. Nevertheless, the majority of graduates engage in technical occupations where they become integral members of teams developing software products or services, requiring a diverse skillset including software de-sign, human-computer interaction, problem-solving methodolo-gies, and software testing, to deliver customer-oriented solutions within specified time and budget constraints. The gap between the skills acquired in academia and those demanded by the industry has given rise to a need for a different software engineering education. To address this need, in 2020, the Computer Science (CS) de-partment at Northern Kentucky University (NKU) launched the Applied Software Engineering (ASE) program, curated to meet industry demands and diversify the appeal of computer science to traditionally underrepresented demographics. The program was designed by faculty members with industry backgrounds and co-designed with the help of alumni and local industry leaders. Since 2020, the program has attracted an array of new and returning students with degrees in disciplines beyond software engineering, leading to a significant increase in enrollment from 6 to 53 students. In this work-in-progress paper, we detail the structure of the program and the elements that incorporate novel and high-impact practices in computing education and, specifically, software engineering to share our approach and invite feedback and comments that can help us measure and improve its success.

The Internet of Things (IoT) has become an essential part of our daily lives and society as a whole, but it is still hard to develop and deliver IoT applications because of the complexity of the inherent heterogeneity nature of IoT devices. In this paper, we present a programming model for IoT, especially focusing on effective sharing of information based on software engineering ideas such as conceptual integrity and managing complexity. We analyze four programming models, Lisp, Fortran, Smalltalk, and Haskell, to understand what factors or ideas made them successful in managing complexity to solve problems in various domains. Then, based on the analysis, we propose an IoT programming model with the conceptual integrity that ‘every information is represented as a map.’ When we share information only in the form of a map data structure—a set of (key, value) pairs, we can simplify the process that manages the lifetime of the information shared. Even more, when we share information only in the form of a map, we can use both probabilistic data structures to reduce the footprint of the information when we need size efficiency and a JSON (JavaScript Object Notation) type information when we need to share high-quality information. We propose an architecture to accomplish this goal and implement a virtual machine to explain how information is generated, processed, and stored in the form of a map data structure.

Software systems become inevitable to have bugs due to the change complexity in a large portion of code. Program repair is a critical maintenance task in software evolution. To reduce maintenance effort and time, the technique of copying and pasting code snippets (code clone) is generally practiced by both the novice and large parts of the developer community. Debugging errors on such replication changes is an effort-prone and time-consuming task. To address this problem, we present an automated program repair approach, called REPCHABUG that helps developers find and repair code change anomalies when they mistakenly apply contradictory updates (contradiction bugs) or miss required edits (exclusion bugs) on code cloning activity. Given the code change portion, REPCHABUG generalizes the code modification into a dependency-aware change template by computing data and control dependency relationships. In our evaluation, a case study with open source applications and a user study with computer science students showed that REPCHABUG should improve developer productivity in finding and fixing replication change bugs.

Reporting bugs is one of the vital activities for evolving software systems. Given such reports, developers cope with unanticipated behaviors during software development, maintenance, and operations. The description of bug reports typically includes (1) what errors occurred previously and (2) how a failure can be reproduced through specific steps, test inputs, and original configurations when a failure was created. However, analyzing bug reports is a tedious and error-prone process due to overflowing, complex terminologies. For example, diverse terms are used to represent similar or divergent elucidations by surrounding contexts during software development and maintenance. To address this problem, we present an approach that applies a topic mining technique to bug reports for finding an adequate code reviewer, who can potentially cope with reported failures, by inferring some hidden topics of a textual document.

As a software system evolves, constant changes are usually made in the code. Similar changes to code fragments often occur in multiple locations. It is very tedious and error prone for developers to manually update similar changes in multiple locations. To address this problem, we propose an approach for Locating and Applying Consistent and Repetitive Changes (LAC) as an Eclipse plug-in. LAC analyzes the code fragments to detect change anomalies, such as omissions or inconsistent edits, and automatically repairs these anomalies by applying required changes. Our static analysis technique to detect anomalies is carried out by inferring change patterns. The evaluation results in a user study show that automatically applying repetitive changes in identified locations using LAC correctly matches with that of manually updated ones, which significantly decreases manual efforts and error-prone edits.

Acquiring local context information and sharing it among co-located devices is critical for emerging pervasive computing applications. The devices belonging to a group of co-located people may need to detect a shared activity (e.g., a meeting) to adapt their devices to support the activity. Today's devices are almost universally equipped with device-to-device communication that easily enables direct context sharing. While existing context sharing models tend not to consider devices' resource limitations or users' constraints, enabling devices to directly share context has significant benefits for efficiency, cost, and privacy. However, as we demonstrate quantitatively, when devices share context via device-to-device communication, it needs to be represented in a size-efficient way that does not sacrifice its expressiveness or accuracy. We present CHITCHAT, a suite of context representations that allows application developers to tune tradeoffs between the size of the representation, the flexibility of the application to update context information, the energy required to create and share context, and the quality of the information shared. We can substantially reduce the size of context representation (thereby reducing applications' overheads when they share their contexts with one another) with only a minimal reduction in the quality of shared contexts.

Sensing applications often require participants to share context information about the physical social, or network environment in which they operate. Building shared views of context requires exchanging sensed information, often via peer-to-peer links. In-network aggregation enables efficient distributed data collection, but the goal has been almost exclusively collect a single aggregate value at a single sink node. In contrast, we design and implement a simple protocol for exchanging context information in aggregate in a peer-to-peer fashion, where every node needs to acquire a shared view of the aggregate context. In our protocol, when a node receives new context information from a neighboring node, it aggregates the new information into its local view of the shared state of the world which it then subsequently shares with its neighbors. We demonstrate (both theoretically and empirically) the situations in which participants' raw context information is fully or partially recoverable by other participants from an aggregate and quantify the tradeoffs in communication overhead for the quality of shared context knowledge. Compared with non-aggregation communication for sharing context values among 100 nodes in a simulated network, we show an overhead savings of at least 78.0%, and an overhead savings of 66.0% with 99.8% average accuracy in a 54 node emulated network driven by real world data.