Agile methods are lightweight, iterative software development frameworks used predominantly on small and mid-sized software development projects. This chapter introduces a project structure and management practices creating agile conditions for large software projects outsourced either offshore or onshore. Agility is achieved by slicing a large project into a number of small projects working in agile settings. Development is divided into research and development activities that are located on-site, and production activities located off-site. The proposed approach makes agile methods applicable to the stressed conditions of outsourcing without compromising the quality or pace of the software development effort. Creating an agile environment in an outsourcing project relies on maintaining a balance between the functions and sizes of on-site and off-site teams, on redefining the developers’ roles, and on reorganizing the information flow between the different development activities to compensate for the lack of customers on-site, team colocation, and tacit project knowledge.

In this paper we propose a process for generating formal object-oriented specifications in OCL and class diagrams from the use case model of a system through a clearly defined sequence of model transformations. The algebraic invariant of business values exchanged in a use case guides the design of statechart descriptions for the actors and counter-actors, collectively called agents, of a use case. Each state in a statechart corresponds to a system state characterized by sending or receiving a business object to or from the system's environment. The system class model and OCL specifications are derived from the agents' statecharts. The proposed approach fills the gap between the outside behavioral system description as offered by use cases and the "first cut" at software architecture, the analysis level class model.

Object-orientation (OO) is a powerful design methodology, which has firmly moved into the mainstream of software development. In 2002, both the IEEE John von Neumann Medal and the ACM Turing Award (the Nobel Prize for Computing) were awarded to the scholars who started the object-oriented journey back in 1967. Despite this recognition, objectorientation is far from being the dominant technology of choice. Contrary to the common belief, a recent authoritative study reports that only 30% of the software companies rely on OO technologies, and that the waterfall model is still the most popular lifecycle model of software development. In this introductory chapter, we present the fundamental concepts and principles of object-oriented modeling with UML version 2. Born out of the efforts to resolve the software crisis, UML has taken such a hegemonic role that we fear object-orientation may undergo a population “bottleneck.” In biology, this is an event that dangerously cuts the amount of genetic diversity in a population. The objectives of this chapter are as follows: 1) to present the influential ideas in the evolution of objectorientation; 2) to identify the lasting trends in object-orientation; 3) to

This work proposes a technique for requirements validation and logical structure discovery, compatible with evolutionary process models. The technique is based on a conservation law, called business value invariant, which quantifies the exchange of business objects between a system and its environment. With the invariant, the logical class structure of the designed system is algorithmically derived from its use case model. To validate that the modeled requirements and derived structure faithfully reflect the user requirements, the behavior of the constructed prototype is projected on the business objects exchanged on the system’s boundary, and the projected behavior is animated with a labeled transition system analyzer. The model animation approach explicitly describes the interface between the system and its environment, and through OCL pre- and post-conditions, it distinguishes between system and environment responsibilities. The animated prototype links the outwardly visible “interobject” behavior to the information structures and the behaviors of the comprising parts, or “intraobject” behavior. Unlike formal notations based on logic, the proposed approach does not preclude the owners of the problem from taking part in the problem-solving process, that is, the knowledge locked in the prototype can be validated. The proposed prototyping technique acts as a discursive communication instrument, bringing the worlds of clients and developers a step closer.

The combination of low labor costs, technological sophistication, project management skills, and successful software establishment makes India a particularly attractive location for software production outsourcing. Furthermore, in most situations, information and communication technologies render virtual presence practically equivalent to physical presence, thus enabling effective communication and cooperation in a distributed mode. This chapter introduces a project structure creating agile conditions for large outsourcing software projects. The agility advantage is achieved by scaling down a large project into a number of small-sized projects working in agile settings. We divide the work into R&D activities, located onsite, and production activities, located offsite. The proposed approach makes Agile applicable to the stressed condition of outsourcing environments without compromising the quality and the pace of the software development effort. Creating a context congenial to agile methods hinges on maintaining a good balance between the functions and sizes of onsite and offsite teams, on redefining the developers’ roles, and on reorganizing the information flow between the different development activities to compensate for the lack of customer onsite, team co-location, and tacit project knowledge.

xUML epitomizes the convergence of visual modeling with model manipulation programming. The results of this merger are executable models and model-driven software development. This chapter presents the fundamental notions of constructing executable domain models with xUML, as well as the principles of the MDA approach. In particular, we define the new roles of the developers in development processes based on MDA and the MDA activity workflow. We discuss also the output artifacts from each activity. As new technologies require new software development processes, we present an iterative and incremental model-driven process, combined with techniques for project planning and progress estimation based on BERT and ERNIE. We show how model executability creates congenial conditions for the application of higher-order cognitive skills in the software development process, and for the substitution of liberal creativity with design automation.

Object-orientation (OO) is a powerful design methodology, which has firmly moved into the mainstream of software development. In 2002, both the IEEE John von Neumann Medal and the ACM Turing Award (the Nobel Prize for Computing) were awarded to the scholars who started the object-oriented journey back in 1967. Despite this recognition, object-orientation is far from being the dominant technology of choice. Contrary to the common belief, a recent authoritative study reports that only 30% of the software companies rely on OO technologies, and that the waterfall model is still the most popular lifecycle model of software development. In this introductory chapter, we present the fundamental concepts and principles of object-oriented modeling with UML version 2. Born out of the efforts to resolve the software crisis, UML has taken such a hegemonic role that we fear object-orientation may undergo a population “bottleneck.” In biology, this is an event that dangerously cuts the amount of genetic diversity in a population. The objectives of this chapter are as follows: 1) to present the influential ideas in the evolution of object-orientation; 2) to identify the lasting trends in object-orientation; 3) to introduce the core UML modeling languages and some of the techniques closely associated with them; and 4) to discuss some of the challenges with object-oriented modeling. In addition, we present the E-ZPass system, a system of moderate complexity used as a running example in the first five chapters of this book. This presentation is the book’s cornerstone. There is not a single chapter in the rest of this volume that does not assume an overdetermined <> reader.

This paper proposes a new concurrent data structure, called parallel hash table, for synchronizing the access of multiple threads to resources stored in a shared buffer. We prove theoretically the complexity of the operations and the upper limit on the thread conflict probability of the parallel hash table. To empirically evaluate the proposed concurrent data structure, we compare the performance of a TCP multi-threaded parallel hash table-based server to a conventional TCP multi-threaded shared buffer-based server implemented in Java. The experimental results on a network of 36 workstations running Windows NT, demonstrate that the parallel hash table-based server outperforms the conventional multithreaded server.

Agile methods are lightweight, iterative software development frameworks used predominantly on small-and mid-sized software development projects. This article introduces a project structure and management practices creating Agile conditions for large software projects outsourced either offshore or onshore. Agility is achieved by slicing a large project into a number of small-sized projects working in Agile settings. Development is divided into R&D activities, located onsite, and production activities, located offsite. The proposed approach makes Agile applicable to the stressed conditions of outsourcing without compromising the quality or pace of the software development effort. Creating an Agile environment in an outsourcing project relies on maintaining a balance between the functions and sizes of onsite and offsite teams, on redefining the developers' roles, and on reorganizing the information flow between the different development activities to compensate for the lack of customer onsite, team co-location, and tacit project knowledge.

The change to Model-Driven Architecture (MDA) with Executable UML (xUML) results in changes to the existing object-oriented development practices, techniques, and skills. To use a transformational approach to create objects with Finite State Machines (FSMs), communicating by exchanging signals, adopters of MDA and xUML have to acquire expertise in new areas such as domain modeling, concurrency, non-determinism, precise modeling with FSM, programming in model-manipulation action languages, writing OCL constraints, and clear separation of application from architecture. The much more complex xUML object model presents system analysts with a longer and steeper learning curve. In this chapter, we critically evaluate the opportunities, capabilities, limitations, and challenges of MDA based on xUML. The purpose of our analysis is to aid organizations, software developers, and software product managers in their transition to this new development paradigm, and to assist them in understanding how MDA and xUML change the software design space and project planning.

ABSTRACTModern software practices call for the active involvement of business people in the software process. Therefore, programming has become an indispensable part of the information systems component of the core curriculum at business schools. In this paper, we present a model‐based approach to teaching introduction to programming to general business students. The theoretical underpinnings of the new approach are metaphor, abstraction, modeling, Bloom's classification of cognitive skills, and active learning. We employ models to introduce the basic programming constructs and their semantics. To this end, we use statecharts to model object's state and the environment model of evaluation as a virtual machine interpreting the programs written in JavaScript. The adoption of this approach helps learners build a sound mental model of the notion of computation process. Scholastic performance, student evaluations, our experiential observations, and a multiple regression statistical test prove that the proposed ideas improve the course significantly.

The universal adoption of UML for object-oriented modeling notwithstanding, a major impediment for UML 1.4 is the lack of seamless integration between the different models and the inadequate support for diagram interchange. In this paper we propose a process generating formal object-oriented specifications in OCL and class diagrams from the use case model of a system through a clearly defined sequence of model transformations. The algebraic invariant of values exchanged in a use case guides the derivation of state machine descriptions for the actors and counter-actors, collectively called agents of the use case. The use case specification is obtained as the composition of the agents' state machines. We present an algorithm for converting a narrative use case specification to a set of OCL expressions and/or class diagrams. The proposed approach fills the gap between the outside behavioral system description as offered by use cases and the "first cut" at software architecture, the analysis level class model.

In this paper, we propose a process generating class diagrams from the use case model of a system through a clearly defined sequence of model transformations. Similarly to conservation laws in physics, we define the notion of value-added invariant for a use case. The algebraic invariant of values exchanged in a use case guides the derivation of state machine descriptions for the actors and counter-actors of a use case, collectively called agents. The class diagrams are obtained as the composition of the agents’ state machines.

In this paper we set out to theoretically explore and experimentally compare different client-server design alternatives implemented in Java. We introduce a new concurrent data structure, called concurrent hash table, for solving the synchronization problem in the classical producer/consumer model. The structure allows multiple reads and a single write to proceed concurrently. We look at the following TCP server designs: concurrent server-new thread per client; pre-threaded servers: locking around accept; socket passing through a shared buffer; socket passing through a concurrent queue; socket passing through a concurrent hash table; socket passing through pipes. The servers have been tested on a network of 35 workstations. The experimental results have shown that the server using pipes to pass tasks to the workers outperforms every other one. For all servers, better performance is achieved by using a number of worker threads in the range of one hundred rather than fifteen as commonly recommended.

Series on Scalable ComputingAnnual Review of Scalable Computing, pp. 63-84 (2001) No AccessTask Scheduling on NOWs using Lottery-Based Work StealingBORIS ROUSSEV and JIE WUBORIS ROUSSEVDepartment of Information Systems, Susquehanna University, 514 University Avenue, Selinsgrove, PA 17870, USA and JIE WUDepartment of Computer Science and Engineering, Florida Atlantic University, Boca Raton, Fl 33431, USAhttps://doi.org/10.1142/9789812810182_0003Cited by:0 (Source: Crossref) PreviousNext AboutSectionsPDF/EPUB ToolsAdd to favoritesDownload CitationsTrack CitationsRecommend to Library ShareShare onFacebookTwitterLinked InRedditEmail Abstract: This paper presents a Java framework for high performance computing (HPC) on networks of workstations (NOWs). We introduce a new lottery-based work stealing algorithm for efficient scheduling of large-scale multithreaded computations on NOWs. In the proposed algorithm, idle workstations actively search out work to do rather than wait for work to be assigned. In the lottery game, each workstation is equipped with a set of tickets and the number of tickets is proportional to the age of the oldest thread in the ready pool of the workstation. A winning ticket is drawn at random and the workstation with the winning ticket becomes the victim from which the idle workstation steals work. The proposed selection procedure serves for two purposes. First, we try to lower communication costs by stealing large amounts of work, with the logic behind being that old-aged computations are likely to spawn more work than relatively young computations. Second, we would like to bias the search to obtain favourable results while at the same time avoid system bottleneck. Our approach has been implemented and tested on NOWs under the Solaris OS. Several examples have been used to demonstrate the potential performance gain. Keywords: High Performance Computing (HPC)JavaNetwork of Workstations (NOWs) FiguresReferencesRelatedDetails Recommended Annual Review of Scalable ComputingMetrics History KeywordsHigh Performance Computing (HPC)JavaNetwork of Workstations (NOWs)PDF download