Relational databases have dominated both industry usage and academic database courses for decades. More recently, there has been a dramatic increase in the use of NoSQL database systems, especially in data science. Bringing NoSQL databases to the classroom is important not only to prepare our students for the technology that they will face, but also because the underlying paradigm introduces new ideas that are not typically emphasized in a relational-only database course alone. However, NoSQL systems seem to receive dramatically less coverage in undergraduate database curricula than relational systems do. This panel discusses examples of how NoSQL can be introduced into undergraduate education, and the possible challenges faced in doing so. Questions from the audience will be invited.

This Research to Practice Work in Progress paper addresses the importance of creating shared vision for change in STEM education. While many educational reform initiatives accomplish their goals in the short-term, only systemic change can truly improve quality and inclusion in engineering and computing education. Developing shared vision is an often repeated recommendation for effective and sustainable change from organizational consultants and scholars of higher education). In our work, we have found that embracing stakeholders as full partners through sharing vision is a proactive way to expose concerns and incorporate a variety of viewpoints into the change process. Shared vision is a useful concept that can be made more accessible and actionable through social scientific research on how change-making teams engage and empower stakeholders to collaborate on their projects.

An increase in data tracking by organizations has created a need for systems that can handle a variety of data models at scale. NoSQL databases and Polyglot persistence - the industry's preferred solution to modern data problems is not covered in sufficient detail, if covered at all in the undergraduate curriculum. The paper reports on our experience of introducing NoSQL paradigms using a four-tiered learning model to undergraduate students over the last two years. We believe that our methodology exposes these new ideas in an approachable manner and would provide a great starting point for other programs interested in teaching modern database paradigms and distributed data modeling and processing.

Requirements Engineering (RE) is an essential component of any software development cycle. Understanding and satisfying stakeholder needs and wants is the difference between the success and failure of a product. However, RE is often perceived as a "soft" skill by our students and is often ignored by students who prioritize the learning of coding, testing, and algorithmic thinking. This view contrasts with the industry, where "soft" skills are instead valued equal to any other engineering ability. A key challenge in teaching RE is that students who are accustomed to technical work have a hard time relating to something that is non-technical. Furthermore, students are rarely afforded the opportunity to practice requirements elicitation and management skills in a meaningful way while learning the RE concepts as an adjunct to other content. At Rose-Hulman, we have experimented with several project-based approaches to teaching RE, which have evolved over time. In this paper, we document the progress of our teaching methodologies, capture the pros and cons of these varied approaches, and reflect on what worked and what did not in teaching RE to undergraduate engineering students.

The computer science capstone experience is designed to bridge the gap from university expectations to those of industry. Yet trying to solve this problem with a single course sequence, even one spanning the senior year, has some shortcomings, in terms of learning outcomes which can be achieved, and also instructional strategies that can be employed. We describe here an alternative plan which first provides a junior year of practice on a client-based project integrated with learning design and other related topics, followed by a senior year in which students can work more independently to hone these skills on a harder year-long project with another client. This two-year sequence, with scaffolding provided at first that is gradually removed, has proven to be especially effective in preparing undergraduates for a career in the soft- ware industry. The approach also integrates well with the need for these students to become proficient at working in engineering teams.

Scrum is one of the many agile approaches to software development that have been widely adopted over the past decade. Agile processes allow developers to embrace under-defined problems in complex environments where change in requirements is inevitable. The key agile features of Scrum are a flexible, adaptive schedule; democratic, collaborative teams; and frequent, iterative project and process reviews [2]. While students may engage with Scrum in the context of software development, the characteristics that suit many software problems to an agile approach also describe the student learning environment: complexity (new and unfamiliar concepts), under-defined problem space (students don't know what they don't know), short timeframe with frequent meetings (terms and class meetings), and inevitable change (apply new knowledge). This makes Scrum not only a software development strategy but a general learning strategy. Scrum facilitates frequent and iterative practice with timely feedback, development of mastery, and self-direction [1]. In this panel, the participants will describe how their students learn and practice Scrum in a software development context, how they use it to manage student projects outside the software development context, and how Scrum provides opportunities to integrate communication skills into the Computer Science (CS) and Software Engineering (SE) curricula. As participants in the NSF-funded CPATH II project (NSF Grants 0939122 and 0939081) "Incorporating Communication Skills Throughout Computer Science and Software Engineering Curricula," each panelist has developed Scrum-based assignments that exercise the skills of reading, writing, speaking, and teaming. The participants will discuss the design of these assignments and their experiences with them to date.

Requirements engineering, an integral part of the life of a software engineer, often receives little or no attention in the education of a computer science student. We report on our experiences in constructing an innovative curriculum that utilizes a three tier model of learning that provides students with hands-on experience on the various facets of requirements elicitation and management. This curriculum can be integrated into an existing course on software engineering, software requirements or the senior capstone experience. We believe our experience will be of use to other computer science and software engineering programs that are aiming at introducing requirements in the undergraduate curriculum.

Evolving software products is a tricky business, especially when the domain is complex and changing rapidly. Like other fields of engineering, software engineering productivity advances have come about largely through abstraction, reuse, process, and automation (e.g., moving from assembly language to third generation languages offered increased productivity through better abstraction). For canonical or domain applications, model-based engineering (MBE) of software provides a systematic approach for producing software systems that leverage all of these avenues of productivity. Specifying or modeling software at higher levels of abstraction and connecting these representations with previously developed (reusable) components provides a repeatable assembly and transformation process that can often be automated. Since 2004, we have explored MBE for generating software from the high-level for sophisticated agent-based systems, low-level complexity in the details of software-defined radios, and more recently with the maturation of emergent systems found in social networking (i.e., Facebook-like systems). While productivity is a key benefit of MBE in software, there have been few studies that examine productivity. In this paper, we present our experience in these efforts and reflect on some productivity implications. Our experience shows that MBE introduces some complexities early in the product life cycle, but provides a stable basis for better productivity through systematic abstraction, reuse, process, and automation.

We present ACXESS (Access Control for XML with Enhanced Security Specifications), a system for specifying and enforcing enhanced security constraints on XML via virtual "security views" and query rewrites. ACXESS is the first system that bears the capability to specify and enforce complicated security policies on both subtrees and structural relationships.

Being able to express and enforce role-based access control on XML data is a critical component of XML data management. However, given the semi-structured nature of XML, this is non-trivial, as access control can be applied on the values of nodes as well as on the structural relationship between nodes. In this context, we adopt and extend a graph editing language for specifying role-based access constraints in the form of security views. A Security Annotated Schema (SAS) is proposed as the internal representation for the security views and can be automatically constructed from the original schema and the security view specification. To enforce the access constraints on user queries, we propose Secure Query Rewrite (SQR) -- a set of rules that can be used to rewrite a user XPath query on the security view into an equivalent XQuery expression against the original data, with the guarantee that the users only see information in the view but not any data that was blocked. Experimental evaluation demonstrates the efficiency and the expressiveness of our approach.