Cloud-based services today depend on many layers of virtual technology and application services. Incidents and problems that arise in such complex operational environments are logged as a ticket, worked on by experts and finally resolved. To assist these experts, any machine recommendation method must meet the following critical business requirements: 1) the ticket must be resolved, meeting specific time constraints or Service Level Targets (SLTs), and 2) any predictive assistance must be trustworthy. Existing research uses probabilistic models to recommend transfers between experts based on limited features intrinsic to the ticket content, and does not demonstrate how to meet SLTs. To address this lack of research and ensure SLT-compliance for an incoming ticket given its recommended sequence of experts, there needs to be an accurate time-to-resolve (TTR) estimation. This research aims to identify important features for modeling time-to-resolve estimation given the routing recommendation sequences. This work particularly makes the following contributions: 1) constructs a framework for assessing TTR estimations and their SLT-compliance, 2) applies the assessment to a baseline estimation model to identify the need for better TTR modeling, and 3) uses language modeling to study the impact of anomalous content on the estimation error, and 4) introduces a set of dynamic features, and a methodology to rigorously model the TTR estimation.

Within the enterprise the timely resolution of incidents that occur within complex Information Technology (IT) systems is essential for the business, yet it remains challenging to achieve. To provide incident resolution, existing research applies probabilistic models locally to reduce the transfers (links) between expert groups (nodes) in the network. This approach is inadequate for incident management that must meet IT Service Levels (SLs). We show this using an analysis of enterprise 'operational big data' and the existence of collective problem solving in which expert skills are often complementary and are applied in sequences that are meaningful. We call such a network - 'Collective Expert Network' (or CEN). We propose a probabilistic model which uses the content-base of transfer sequences to generate assistive recommendations that improves the performance of CEN by: (1) resolving incidents to meet customer time constraints and satisfaction (and not just minimize number of transfers), (2) conforming to previous transfer sequences that have already achieved their SLs, and additionally (3) address trust in order to ensure adoption of recommendations. We present a two-level classification framework that learns regular patterns first and then recommends SL-achieving sequences on a subset of tickets, and for the remaining directly recommends knowledge improvement. The experimental validation shows 34% accuracy improvement over other existing research and locally applied generative models. In addition we show 10% reduction in the volume of SL breaching incidents, and 7% reduction in MTTR of all tickets.

In this paper, we present the issues to be addressed and the practical solutions to these issues in a mobile application framework for reading and displaying musical scores enhanced to assist the visually impaired in reading and perform the pieces. This framework, currently operating on MusicXML input files, provides the structures and methods for developers to adapt for other music encoding file formats. It also provides the flexible user-settable colors and enlargement parameters to meet the needs of users with various visual impairments. The development challenges fall into three categories: Variable visual impairment driven requirements, Musical notation complexity, and screen real-estate limitations of a 10-inch tablet. The framework's practical solutions to each of these challenges are presented and contrasted with traditional solutions and competing solutions.

Companies seeking to make their web sites usable for viewing by mobile devices currently need to create a parallel set of web pages designed and built specifically for browsing by devices with screen size and computing constraints. Most companies, however, do not have IT resources to spare for this essentially duplicate manual effort. Hence, effective techniques that can ease the burden of developing mobile web pages can be of great value. In this paper, we present the architecture, design and implementation of a 'web site mobilizer' for semi-automatically converting existing web pages to pages suitable for mobile viewing. The mobilizer extracts the component hierarchy of the page using web crawler techniques, analyzes the structure of the web page, and then converts it to the mobile version using a combination of techniques that include link analysis, ranking algorithms based on component content, and interactive removal of irrelevant content. This mobilizer is in limited production use.

An analysis of hiring patterns showed emerging trends: the complexity of information technology (IT) is shifting from development to post-deployment and integration needed for services. Given the complexity of deployed service systems, generated big data, and the national dialogue on educating engineers, we asked ourselves related questions. Do our graduate students have evaluation skills needed to work at the most advanced level of Bloom's taxonomy? Can they learn to frame and solve the problems within complex industry environments while applying the current research? How do we structure a graduate curriculum and an environment that provides experiences in innovation within the constraints of the academic calendar? Here we present an interdisciplinary curriculum comprised of three components: a service interaction blueprint for framing the industry problem, agile principles focusing on aspects of the solution, and Christensen's theory-building to frame the next iteration of research. The environment for industry problems was created through an National Science Funded Industry & University Cooperative Research Center. The feedback from a pilot graduate-level class is positive and provides insights for further research. We show through feedback discussions that it is possible to have translational activity at the industry-university enterprise boundary resourced in by advanced experiential learning.

The National Science Foundation Industry & University Cooperative Research Center (I/UCRC) program is intended to foster productive collaboration between industry organizations and academia. The focus of the I/UCRC research site herein is on the application of technology within the complex extended enterprise. The center's goal is to conduct research that is of interest to both the industry sponsor and the university partner, with the provision that the industry organization must provide major support to the center. In this paper, we describe the Agile Translation Process (ATP) for complex innovations that was developed at the center. The process meets the constraints of the academic calendar, the knowledge needs and the typical length of stay for a master's student, and the availability constraints of the students. At the same time, the process is designed to provide value to the industry sponsor. Specifically, it describes how the process meets the needs of technology consumers in industry seeking to derive tactical value through the funding of the center. In addition, we demonstrate how to derive research results for technology providers through subsequent activities. We also provide metrics from the center for a period of five years, which show, in particular, the benefit of using the ATP method over the last three years. These metrics provide insights on how to reconcile tactical industry needs with the long-term research and funding goals of academia, while understanding the innovations needed within complex contexts. This case study also provides insights on concurrently meeting the needs of all stakeholders - including industry clients, translational faculty members, adjunct faculty from partner companies, graduate students, and the center's affiliated research faculty - within the constraints of the academic calendar. By using an agile translation process and a set of expanded performance metrics, the center effectively applies research to bring innovation to its industry partners.

Several published papers describe various frameworks to implement an Open World Dialog system. This research conducts a critical review of one system using commodity hardware and software, independent of the vendor and authors. The results delineate the parts of the system that are implemented via the SDK and identify the components that require development. Furthermore, we estimate the difficulty of implementing each component of the dialog system using the SDKs.

Project-oriented environments are key to supporting the co-operative work essential to collaborative research activities. However, personnel and resources in project-oriented environments are typically diverse and heterogeneous as they come from both internal as well as external domains. Providing a robust data security system in such an environment becomes critical. The ideal access control architecture should manage access to resources not only based on roles but also based on the specific nature of each resource and its involvement within the project. Traditional role-based access control (RBAC) does not consider the context which often modifies the responsibility given to resources. We propose using an enhanced role-based access control (RBAC) mechanism to address this problem. Specifically, we discuss the implementation of RBAC using ontological methods borrowed from semantic web technology. We used an ontology-based approach for specification and implementation of the RBAC in a collaborative system used within a research group to manage proteomics data, where the access control policy depends on how the project team hierarchy is structured. We describe the design and implementation of this system in this paper. We also provide a preliminary evaluation of the implementation. We find there are several advantages to using ontological methods to implement RBAC. The most significant of these is standardization, which is essential for portability. Also key is modifiability as the actual roles are defined by the ontology itself. Since data access is provided through URI handling moving to a federated system is made easier. This becomes very important in collaborative environments as the data in question is invariably distributed.

This paper discusses our ongoing experiences with teaching software engineering through an inverted classroom. This course format moves traditional lectures out of in-class hours and into the student's personal study time with prerecorded lectures. We support the inverted classroom with complementary techniques, such as structured discussions, weekly quizzes to ensure students watch the lectures before discussion, an innovative Lego-based workshop, a term project, and guest lectures by industry professionals. The inverted classroom allows the students to have an effective educational experience that encompasses both traditional lectures and an active learning environment. To evaluate the efficacy of this format, we use surveys and interviews of both instructors and students. We examine the time commitment of teaching with this method, from both the instructors' perspective and the students'. We also discuss the time commitment for instructor preparation, and quantitative measures of how the inverted classroom helps smooth the variance in the quality of each instructor's teaching. We also analyze the effectiveness of this technique and our methods for mitigating unintended consequences, such as students having an inexact understanding of the material. Through this evaluation, we distill the effects on student learning and instructor teaching.

Object-oriented software design and programming is an essential part of a computer science curriculum. We have observed that novice software developers, such as fresh college graduates who have been taught object-oriented design, are able to apply good design principles in theory. However, this rarely extends into their professional practice, when they are asked to design software intended to run inside a software framework. In fact, we observe that even advanced software developers abandon good design practices when developing software while using a framework, and focus on simply “making it work.” This paper presents and discusses a methodology developed for designing software in the context of frameworks to overcome these issues. We show how design patterns can serve as the bridge between the paradigms imposed by the framework and the ideal, unconstrained design of the system. We also suggest an evaluation method for observing the results of using this methodology when used by the students.

Capstone courses are expected to prepare students for the “real world” by putting them into a microcosm of the real world. In these courses, students are given a problem of some complexity, and are expected to exercise and develop problem-solving skills as they address the problem. Within our Computer Science and Engineering program we have, over the past eight years, successfully scaled up the Capstone courses. Doing so has required innovative thinking about the roles of the students, faculty, and project sponsors. In this paper, we discuss issues with scaling up the components that have made this program successful. These include housing the courses in an NSF IUCRC that enable the cultivation of highly-committed industry partners, the creation of strong pre-requisite courses, careful development of faculty resources through the selective hiring and mentoring of clinical faculty, a commitment of the faculty to give up close management and control, strong partnerships with other organizations within the university to provide students greater access to resources, an emphasis on cross-team knowledge sharing and learning, and the development of unique assessment and evaluation tools so as to be able to monitor, measure and fairly assess a wide-spectrum of projects.

Case studies have been successfully integrated into a wide variety of educational contexts and disciplines. Today, case studies are increasingly accepted as valuable teaching tools in science and engineering curriculums to complement the underlying theory of the field. Well-articulated cases can reinforce abstract concepts, demonstrate the nature of real client interactions, and showcase the relevance of soft skills to students that lack significant practical experience. However, assembling and delivering quality case studies to students requires a great deal of practical disciplinary knowledge, and a careful alignment of the case content and delivery style with curricular objectives, course learning outcomes, and the overarching institutional format. In this paper, we summarize our experience with an approach for constructing case study teaching materials that are integrative and deep in content, but also carefully aligned to the core principles and format of a senior-level software engineering course. Our approach ensures that the cases are complex enough to retain their realism and intrinsic appeal, while mirroring the format and objectives of the course such that the cases reinforce key points in a familiar and consistent fashion to the students.

Standard methodologies, which have been developed for large software development teams, and Agile practices, developed for small teams, make up the software engineering practices taught in the Computer Science classroom. However, we have found that there is a significant prevalence of “micro” teams doing business-critical software development in the field. Thus, software development best practices for micro teams must be incorporated into the software curriculum. Towards this end, we created a multiple-case case study (comprising five micro team projects) showing how micro teams handle the software development process. Through each of these projects, we seek to showcase what practices from existing software development methodologies are undertaken by the developers of the projects, to achieve similar ends as developers in larger teams. Specifically, the case study highlights how existing software development methodologies need to be modified, adapted or extended for micro teams. The case study and micro team guidelines were presented to students in a software engineering class within the Computer Science department at a large R1 university. The teaching was assessed using a mix of surveys and structured interviews. Initial evaluations showed promise. Students were positively inclined to accept the lessons, and showed good recall of the concepts taught in tests.

In order to better prepare students for professional practice, we have created a software engineering curriculum that provides an end-to-end perspective that begins with the business context of software, and goes all the way to the ongoing management of software services after deployment. This paper examines how the theoretical aspects of this broad-based curriculum may be effectively delivered through a single course within a traditional computer science program. This curriculum is under a diverse set of constraints and requirements, such as the need for pedagogical consistency, faculty development, consideration of the learning style of computer science students, and a need for an effective continuous improvement process. Our approach uses “engineering-oriented” analysis frameworks such as Porter's Five Forces model for the business aspects, and attribute-driven design for software architectures, an “inverted” classroom mode of teaching where lectures are delivered on line with interactions and exercises that promote active learning reserved for the classroom, case studies developed from real projects to serve as concrete examples, open discussion boards and weekly short quizzes for concept refinement and retention, and a paper-based project where students apply the concepts learned. Faculty development and replication outside the current site are also discussed.

Industry-practiced agile methods must become an integral part of a software engineering curriculum. It is essential that graduates of such programs seeking careers in industry understand and have positive attitudes toward agile principles. With this knowledge they can participate in agile teams and apply these methods with minimal additional training. However, learning these methods takes experience and practice, both of which are difficult to achieve in a direct manner within the constraints of an academic program. This paper presents a novel, immersive boot camp approach to learning agile software engineering concepts with LEGO®bricks as the medium. Students construct a physical product while inductively learning the basic principles of agile methods. The LEGO®-based approach allows for multiple iterations in an active learning environment. In each iteration, students inductively learn agile concepts through their experiences and mistakes. Subsequent iterations then ground these concepts, visibly leading to an effective process. We assessed this approach using a combination of quantitative and qualitative methods. Our assessment shows that the students demonstrated positive attitudes toward the boot-camp approach compared to lecture-based instruction. However, the agile boot camp did not have an effect on the students' recall on class tests when compared to their recall of concepts taught in lecture-based instruction.

Reasoning about the impact of change is critical throughout the Information Technology (IT) architecture lifecycle management processes and this is especially challenging because installed architectures are complex, evolve constantly, and most changes have some global impact. We present an enterprise-interaction ontology for integrated query, analysis, and monitoring that supports features to allow architects and engineers pin-point the impact of change to the installed architecture before implementation. The ontology represents select associations between the enterprise’s business processes, services and infrastructure so that significant consequences of a change are propagated to affected areas based on underlying rules. Thus, interdependencies and relationships that are not obvious are identified and the impact is quantified. This allows the architect to know the complete scope of modifications required in order to accomplish a change in a manner consistent with best practices (like ITIL version 3). We illustrate - 1) the rules and taxonomy relationships that give us the ability to propagate changes and determine the impact, and 2) how actual questions and decision-making during the architecture management processes can be better supported using a more precise and factual understanding. Not only does the interaction methodology help analyze the potential impact of adding a new component, a change due to an incident, or the deletion of an existing component from the architecture, it also supports business-IT alignment processes like chargeback, capacity management and disaster recovery.

We propose a systems analysis framework based on goal modelling and transactions for improved decision-making about security solution architectures - with a specific focus on layered security of physical spaces and assets. The framework assists in defining more complete security strategies as well as analyzing tradeoffs between security and other factors such as cost and privacy. Using the conceptual transaction or requirements-execution-delivery (or RED) Transaction model as the basis, we provide a dynamic virtual structure and methodology for security analysis. The benefit is that the implemented security can be optimized based on the value to the various stakeholders and to minimize the benefit to the attacker.

The authors identify and incorporate the critical factors that influence nonuniform memory access (NUMA) memory management into their performance metrics. Using trace-driven simulations, it is shown that under certain conditions no replication is better than replication. It is also concluded that the effectiveness of replication depends on: (1) the ratio of access times to remote and local memory, (2) virtual address assignment to data, (3) data sharing characteristics, (4) overhead of enforcing consistency, and (5) amount of physical memory available relative to the data sharing characteristics.>

The authors describe a tightly coupled environment architecture centered around a customized software development assistant, that uses underlying representations of the software development process, the objects and relationships being manipulated, the functionalities of the tools, and the roles of the various project members to provide automated support for this discipline. The assistant facilitates the interconnection of all the components of the environment. Features of a conceptual modeling language for specifying such representations and using them to generate customized assistants are emphasized.>

Abstract Even though the data processing domain is relatively well‐defined, application‐specific details vary too widely to conceive of totally automating programming and specification support. Conventional tools lack the semantic knowledge to constructively support software development. On the other hand, it is possible to design a prompting and guiding system that can elicit the application details. The limits of automated programming support possible for file and data processing applications were identified by means of a case study of COBOL and PL/I programs. The data gathered from this study facilitated the definition of seventeen widely applicable templates. The resulting template set has immediate value as a manual specification and documentation tool. The templates encourage programmers to make well‐considered design decisions and enforce standardized documentation.

Rapid advances in semiconductor fabrication technology have resulted in an explosion of the number of components realizable on a Very Large Scale Integrated (VLSI) circuit. The design process which exploits this technology is extremely complex and must be supported by a project environment. To this end we examine the design process. The goal of VLSI design is to ‘compile’ a high level specification through a series of intermediate representations to the final ‘buildable’ circuit while taking full advantage of the available technology. During the design process a tremendous volume of information is generated. This paper presents an environment which is designed to facilitate the organization and handling of information generated during a VLSI design project.

Article Free Access Share on Modeling of problem domains for driving program development systems Authors: J. Ramanathan The Ohio State University, Columbus, Ohio The Ohio State University, Columbus, OhioView Profile , C. J. Shubra The Ohio State University, Columbus, Ohio The Ohio State University, Columbus, OhioView Profile Authors Info & Claims POPL '81: Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languagesJanuary 1981 Pages 28–40https://doi.org/10.1145/567532.567535Online:26 January 1981Publication History 1citation183DownloadsMetricsTotal Citations1Total Downloads183Last 12 Months2Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

The need for programming environments which support different phases of the software life cycle using responsive tools is well established. This paper presents a method for developing automatic analyzers which analyze programs and provide programmers with a variety of messages for the purpose of validating these programs in the early stages of program development. We show using an example, that such analyzers can be systematically constructed using an extension of the Attribute Grammar model which reflects the fact that a program analyzer should perform a static analysis of the program as well as monitor its dynamic behavior efficiently. One of the advantages of the model is that a systematic interaction is allowed between the static and dynamic attributes of the program. We illustrate that an advantage of this interaction is selective program instrumentation. That is, the analyzer is responsive to the programmer's needs by providing a selective analysis of the program's behavior rather than an exhaustive analysis which is difficult to comprehend.

The problem of semantic evaluation in a compiler-generating system can be addressed by specifying language semantics in an attribute grammar [19], a context-free grammar augmented with “attributes” for the nonterminals and “semantic functions” to compute the attributes. A deterministic method for evaluating all attributes in a “semantic” parse tree is derived and shown to have time and space complexities which are essentially linear in the size of the tree. In a prepass through the parse tree, the method determines an evaluation sequence for the attributes; thus it is somewhat analogous to dynamic programming. The constructor-evaluator system described should be suitable for inclusion in a general translator-writing system.