This article presents the use of a model-centric approach to facilitate software development projects conforming to the three-tier architecture in undergraduate software engineering courses. Many instructors intend that such projects create software applications for use by real-world customers. While it is important that the first version of these applications satisfy the customer by providing the functionality the customer expects and perform reliably and efficiently, it is equally important to be able to accommodate the customer's change requests over the period of the product's lifetime. The challenges in achieving these goals include the lack of real-world software development experience among the student developers and the fact that postdeployment change requests will almost certainly have to be handled by students who are not among the original developers. In this article, we describe how a model-centric approach using UML has been effective in enabling students to develop and maintain eight software applications for small businesses over a 9-year period. We discuss the characteristics of our modeling technique, which include the application of modeling patterns and quality check rules that enable students to create a model that can be clearly and consistently mapped to code. We also describe the nature of these mapping-to-code techniques, emphasizing how they reduce coupling among the implementation's classes. We then discuss our experiences in the classroom with these techniques, focusing on how we have improved our teaching over the years based on the analysis of student performance and feedback. Finally, we compare our approach to related work teaching modeling and the development and maintenance of code in software engineering courses with both extensive and minimal modeling.

The road network of a small town is represented as a directed graph where each road junction is a vertex and each road segment (which has a length and a priority value) is a directed edge. We assume that there are several plows available to service the roads. We seek to compute an optimal allocation of routes to plows. Each route begins and ends at the same (depot) vertex. The union of all plow routes must cover every edge in the graph at least once. In addition, we wish to minimize the following parameters: total distance covered by all plows (thereby minimizing the deadhead miles), amount of variation in the mileage covered by individual plows (thereby dividing the workload equitably), number of u-turns and extent of priority misplacements. In this paper, we propose a Genetic Algorithms (GA)-based solution to compute a near-optimal route allocation and the minimization of other parameters simultaneously. This algorithm is based on our GA solution to the 1-plow problem reported earlier. We have developed a Java application that implements our algorithm. Our experiments with reasonably large graphs have yielded good solutions. These solutions are especially useful in snowplow routing for small towns, as plowing costs consume significant portions of the total municipal budgets of these communities. Most of the route planning in small towns is currently done manually and routes have evolved over time by experience. In these times of severe budget stress, route allocation using our approach can help in performing this essential service in a more efficient manner.

Snow plowing comprises a major portion of the total municipal budget in many communities. In these times of severe budget stress, it is vital to find ways to perform this essential service in an efficient manner. Optimizing the routes travelled by plows is one way to reduce costs. This problem, however, can be shown to be an NP-Hard problem at its core, with several additional complications. In this paper, we demonstrate how this problem can be formulated as a state-space search problem, and how one can employ AI techniques such as A-Star (A*) search to compute optimal or close-to-optimal routes. Specifically, we have developed A*-SnowPlowRouter (A*SPR), a Java software application that uses a “roads data set” of a town and generates efficient route plans. This data set is generally obtained from the municipal Geographical Information System (GIS). Our procedure transforms this data into a directed graph representation, augmented with road priority data. We then employ the A* technique to generate routes which minimize travel distance, avoid U-Turns, and reach higher-priority roads before lower-priority roads. The route plans computed by A*SPR are then exported into a format that can be displayed on the GIS. We have experimented with road networks in several local municipalities, and obtained routes that are significantly better than the ones currently used.

The road network of a small town is represented by a directed graph. Road junctions are the vertices of this graph and each road segment (which has a length and a priority value) is represented by a directed edge. Priority values are numbers 1, 2, etc. with the assumption that 1 is the highest priority. We seek to compute an optimal route map that begins at a particular vertex (the depot) and covers all the edges at least once and returns to the start vertex. The parameters that we wish to minimize are: the total distance covered (thereby minimizing the deadhead miles), the number of u-turns and priority misplacements. In this paper, we propose a Genetic Algorithms-based solution to compute near-optimal route maps in such a graph. Specifically, we have developed a Java software application that generates route maps that minimize a linear combination of the three parameters. We have experimented with reasonably large graphs and obtained good solutions. These solutions are especially useful in snowplow routing for small towns, as plowing costs consume significant portions of the total municipal budgets of these communities. Most of the route planning is currently done manually and routes have evolved over time by experience. In these times of severe budget stress, route planning using our approach can help in performing this essential service in an efficient manner.

We propose the use of a new design-first approach called Problem Stereotypes and Solution Frameworks, for teaching CS1 and CS2. A problem stereotype is a category of problems that can be solved using similar techniques. A solution framework is a typical solution to a problem, parts of which can be reused to solve other problems of this stereotype. Students are introduced to a stereotype through a selection of related problems, and common features among these are identified. Homework problems are selected from the same stereotype, with students expected to follow the "recipe" provided by the given examples to generate their own solutions. Using this approach reduces the stress level for beginner students, and prevents them falling prey to the "CS is HARD" myth. We present the results of our experience with this approach in two introductory classes and an upper-division Artificial Intelligence (AI) class at SUNY Brockport.

This paper describes a new specification model called the dynamic coordinated concurrent activities (DCCA) model and shows its utility for the specification of coordination protocols needed in manufacturing control systems. The principal advantage of this model lies in the ease with which a distributed implementation of the specified controls may be automatically generated from the formal specification itself in this paper, the authors describe some specific DCCA features, such as dynamic processes, structured states and a versatile means of specifying predicates on such states- these features facilitate obtaining a largely generic and reusable specification of a real-world FMC. The authors emphasize the elegant methodology for obtaining the distributed implementation automatically.>

Abstract A serious problem in large Ada programs is finding a satisfactory order of elaboration for all of the program's compilation units. Some elaboration sequence must be selected but access to a program entity before its elaboration will raise the exception (PROGRAM_ERROR) shortly after execution of the program begins. The rules of the 1983 Ada standard1fail to ensure that validated compilers produce a satisfactory elaboration order, or report an error if static analysis shows that such an order may not exist. The problem can make programs non‐portable and sensitive to modifications. This paper presents an algorithm ada_elab which determines an order of elaboration, free of PROGRAM_ERROR, if link‐time, static analysis can determine that there is one. Examples are used to illustrate the occurrence of elaboration errors and the inadequacy of pragma ELABORATE to resolve the problem. The paper closes with descriptions of elaboration and elaboration‐related problems that cannot be handled by ada_elab, access before initialization and coding practices that should avoid elaboration and initialization errors. While Ada is the subject of this paper, the problem being studied could occur in any language that permits a complex initialization of individual program modules prior to the execution of the main program module.