Software Development in Agile Environment

Some programmers who do know about con-Can libraries written without explicit support for design by contract benefit from adding contracts? We studied classes from the .NET collections library for implicit contracts and assessed improvements that might result from making them explicit.

Nowadays, if we want to obtain a sound and correct final software product it is very important to be able to properly join modern OO programming environments, which are built for the new Internet architectures, with the OO methodologies produced over the last few years in order to deal properly with the Conceptual Modeling process. Our contribution to this objective is the OO-Method [Pas96] proposal. OO-Method is an OO Methodology that allows analysts to introduce the relevant system information by means of a set of graphical models to obtain the conceptual model through a requirement collection phase, so that an OO formal specification in OASIS [Pas95] can be generated at any given moment. This formal specification acts as a high-level system repository. Furthermore, a Java software prototype, which is functionally equivalent to the OASIS specification, is also generated in an automated way. This is achieved by defining an execution model that gives the pattern to obtain a concrete implementation in the selected target software development environment. A CASE workbench [Pas97] supports the methodology.

We demonstrate that different categories of software raise different ethical concerns with respect to whether software ought to be Free Software or Proprietary Software. We outline the ethical tension between Free Software and Proprietary Software that stems from the two kinds of licenses. For some categories of software we develop support for normative statements regarding the software development landscape. We claim that as society's use of software changes, the ethical analysis for that category of software must necessarily be repeated. Finally, we make a utilitarian argument that the software development environment should encourage both Free Software and Proprietary Software to flourish.

This paper explains Concurrency control is a database management systems concept that is used to address occurs with a multiuser system. It helps you to make sure that database transactions are performed concurrently without violating the data integrity of respective databases. Concurrency control when applied in advanced database management system is meant to coordinate simultaneous transactions while preserving data integrity. When more than one transactions are running simultaneously there are chances of a conflict to occur which can leave database to an inconsistent state. To handle these conflicts we need concurrency control in advanced DBMS, which allows transactions to run simultaneously but handles them in such a way so that the integrity of data remains intact.

In current-day software development, programmers often use programming patterns to clarify their intents and to increase the understandability of their programs. Unfortunately, most software development environments do not adequately support the declaration and use of such patterns. To explicitly codify these patterns, we adopt a declarative meta-programming approach. In this approach, we reify the structure of an (object-oriented) program in terms of logic clauses. We declare programming patterns as logic rules on top of these clauses. By querying the logic system, these rules allow us to check, enforce and search for occurrences of patterns in the software. As such, the programming patterns become an active part of the development and maintenance environment.

In current-day software development, programmers often use programming patterns to clarify their intents and to increase the understandability of their programs. Unfortunately, most software development environments do not adequately support the declaration and use of such patterns. To explicitly codify these patterns, we adopt a declarative meta programming approach. In this approach, we reify the structure of an (object-oriented) program in terms of logic clauses. We declare programming patterns as logic rules on top of these clauses. By querying the logic system, these rules allow us to check, enforce and search for occurrences of certain patterns in the software. As such, the programming patterns become an active part of the software development and maintenance environment.

On January 22, 1990, Ariane V-35 placed four Microsat spacecraft into orbit. The orbit achieved is nearly perfectly sunsynchronous at 800 km altitude. The satellites, cubic structures measuring only 23 cm per side, were developed by the Radio Amateur Satellite Corporation of North America (AMSAT-NA). The time required to complete the project, from conception to delivery of the four satellites to Kourou, was exactly two years. Each satellite in orbit has a different mission and is performing in accordance with its intended design, although additional software is still being written to enhance the operating characteristics for each mission. This paper reviews the design objectives of the four spacecraft and summarizes their in-orbit performance against these prelaunch technical objectives. The level of technology employed by the Microsat spacecraft is briefly discussed and the software approach taken in implementing a real-time, multitasking operating system is summarized. The paper reviews the AMSAT experience as the first payload user group of the Ariane ASAP structure. Some of the findings regarding the cu"ent technology and how it may be expanded to fulfill other mission needs has been touched upon. 1 Members of the AMSAT-NA Microsat design team.

A large number of software reliability growth models have been proposed to analyze the reliability of software application during the testing phase, but none of the software reliability growth model is universal to all situations.However, most of the existing software reliability growth models are developed with the assumption that all the faults detected during the testing phase are removed, and no new fault is introduced in the debugging process. As far as this assumption is considered, it seems to be unrealistic in practical; therefore it is necessary to develop a software reliability growth models with assumption that new faults are introduced when the faults in the software system are corrected and removed during testing. This study develops a new software reliability growth model incorporating both fault removal efficiency as well as fault introduction. The study considered the sense that new faults can be introduced into the software during debugging and the detected faults m...

CARDS (Central Archive for Reusable Defense Software) exploits advances in domain analysis and domain modeling to identify, specify, develop, archive, retrieve, understand and reuse domain-specific software components. An important element of CARDS is to provide visibility into the domain model artifacts produced by, and services provided by, commercial computer-aided software engineering (CASE) technology. The use of commercial CASE technology is important to provide : rich, robust support for the varied roles involved in a reuse process. We refer to this kind of use of knowledge representation : systems as supporting "knowledge-based integration." , f,,.

This paper describes efforts to use industry wireless software development practices in the classroom. Nokia's OK Java 2 Platform Micro Edition (J2ME) application certification program was chosen for use in a core set of wireless software engineering courses. The adaptation process included 1) modifying Nokia OK application standards for classroom use as examples of what is expected of industry-quality software; 2) incorporating Nokia OK software development tools into a student-friendly software development environment; and 3) implementing in-house Nokia OK certification procedures as a basis for assessing student projects and providing feedback.

This paper presents the Adesso, a computational environment for the development of scientific software. The Adesso environment leverages the reusable software component programming model to support the development and integration of components to several scientific programming platforms. The Adesso system is based on an XML component database and a set of XML document transformation tools for the automatic generation of component code, documentation and packaging. An authoring tool, built with the help of the Adesso transformation system itself, is provided to assist the user in the creation of components. The Adesso system has been used for the development of several image processing toolboxes and applications. Some of them are presented briefly in this paper.

This research results from the need for an effective, reliable, and highly flexible method of control of processes within a small pharmaceutical environment and will be programmed using Ladder Logic programming Language, Siemens Step 7, which entails integrating hardware and software to provide dependable and effective operations. The mixer is controlled through a Supervisory Control and Data Acquisition (SCADA) system and programmed using Ladder Logic in Siemens Step 7 PLC Programming Software. Temperature control, agitation control, and ingredient addition sequences were all integrated by the automated system. The performance of the modeled system is validated through computer simulations. The Batch Mixer is controlled using a Variable Speed Drive (VSD), enabling precise execution of the required processes throughout the entire mixing cycle. Each phase of the process is carefully controlled and monitored, with detailed simulation results demonstrating enhanced performance and efficiency in the proposed batch mixer system, as well as offering a mathematical model of the Batch Mixer and outlining the performance variables that the PLC systems use in detail. As a backup validation tool, Rockwell Automation's RSLogix 5000 PLC is used to verify the validation. The study demonstrates the effectiveness of using Siemens STEP 7 PLC for automation and validation, and with RSLogix 5000 PLC for confirmation of validation, ensuring reliable and efficient pharmaceutical batch mixing operations.

Object-oriented design techniques have begun to play a critical role in increasing productivity, assuring correctness, and modeling both the structure and behavior of applications. However, while most objectoriented models support intra-class behavior definition through encapsulation, inter-class relationships and behavior are supported in only a limited sense, i.e., within ISA or inheritance hierarchies. This is a serious drawback when attempting to model advanced applications such as software-development environments (SDEs) and CAD/CAM. In order to model these critical inter-class relationships and behavior, our goal is to incorporate propagation actions into an object-oriented data model at the design-phase level. This results in increased accuracy in the modeling of information, more complete specification of system behavior, elimination of some side effects, and decreased application coding errors. To meet this goal, this paper presents the active model of propagation (AMP) which supports the specification of inter-class relationships during the design phase to permit system enforced propagation. 1 Introduction Object-oriented methodologies for both software development and database design have continued to draw attention and gain supporters. Object-oriented design techniques that promote data encapsulation (i-e., the

This paper deals with the programming in the large part and the integration with related activities (programming in the small, variant control, support of technical documentation, responsibility and access control) of the software development and maintenance process. It is pointed out how these tasks are supported with an integrated and incremental software project support environment (IPSEN). Snapshots of a working session are used to demonstrate the user interface and the functionality of the tools for the above mentioned topics. The main concern of this paper is to show how an incremental and integrated tool set, regarding the consistency of software documents can support software development.

Object-oriented programming and other programming paradigms are heavily influenced by Western thought and reasoning, which focuses on understanding the world in terms of categories, objects and their attributes: A typical program is decomposed into clearly defined units, such as modules, functions, objects, components and aspects, and each of these units is described by its properties, functionality, and direct relationships to other units. Eastern philosophy, however, focuses on fields of interactions rather than individual units. Harmony-oriented programming is a new programming paradigm based on concepts found in Eastern philosophy. This paper presents principles and constructs of harmony-oriented programming and introduces ongoing work towards creating a harmony-oriented software development environment for further experimental studies.

I would like to express my deep appreciation and thanks for my advisor, Assist. Prof. Dr. Feza BUZLUCA. I also want to thank my parents, Ümmü and Mehmet; my brother, Ümit; my sister Özlem; and my wife, Şule, for their understanding and support.

Program diagnosis systems were developed to help users solve programming problems. By providing guidence on errors and misconceptions, these systems can help the users in writing programs and understanding their dynamic behavior. Features of software visualization which aim at providing visual and concrete depictions to the abstractions and operations of programs have also shown to be making programs more understandable.

The development of large software systems demands intensive cooperation among multiple project team members with different responsibilities. The development process is often distributed across time and space and takes place within and between specialized workgroups. This necessitates finding appropriate answers to questions related to division of labor, to communication, and to coordination and cooperation in the planning, development and maintenance of software systems. Development environments that explicitly support group work are an important prerequisite for the production of high-quality software systems. Most of the software development environments in use today support primarily technical aspects and have shortcomings in the area of organizational support. This paper describes a model for cooperative work processes in software projects and a corresponding development environment that provides balanced support for both organizational and technical aspects of software development. The work toward the conception of the model and the implementation of the development environment have been completed, and the evaluation of the proposed approach has begun. Experience to date with using the developed environment confirms the assumption that the cooperative, cluster-oriented development improves both productivity and quality. The presented approach excels primarily in its easily understandable model, the intuitive usability of the tools and the comprehensible presentation of process-and product-related information.

One often needs to adapt an single object to several different types of usage in different parts of a single system-all at the same time. We refer to such adaptations as views of the object. Such views may differ from the base object in question, and from each other, in two ways: (a) they may allow different access to the intrinsic features of the base object, and (b) they may associ\ate with the base object some additional, eztrinsic features which may be meaningful only with respect to a given view . Consider, for example, an evolving medical information systein M. Suppose that this system is partitioned into several disjoint divisions, which are to be developed more or less independently of each other.

Although software requirements engineering is an essential activity for the successful development of information systems, most of the existing software development environments do not provide support for requirements specification. They concentrate on the development activities, such as code edition, solution management, components testing and deployment, change and configuration management, or integration with modeling artifacts. The Visual Studio .NET IDE is one of the most popular development workbenches, profiting from years of Microsoft experience in developing tools to enhance and automate the tasks of the developer, but still has no support for requirements specification. In this paper we describe how Visual Studio .NET extensibility mechanisms have been used to support the development of a new requirements specification initiative, which we have called ProjectIT-Requirements.

In Software Defined Networking (SDN) critical control plane functions are offloaded to a software entity known as the SDN controller. Today's SDN controllers are complex software systems, owing to heterogeneity of networks and forwarding devices they support, and are inherently prone to bugs. Our previous work showed that Software Reliability Growth Models (SRGM) can model the stochastic nature of bug manifestation process open source SDN controllers. In this article we focus on different applications of our SRGM framework crucial for an efficient management of SDN-based networks. We provide guidelines for network operators to decide when the controller software is mature enough to be deployed in operational environment, based on the reliability requirements of network applications, and quantify the marginal benefits of the prolonged testing phase on the software quality. We show how the accuracy of software reliability prediction in the early phase of the software lifecycle can be improved by extrapolating the behaviour of previous controller software releases. We also propose software maturity metrics, that can be used by operators to discriminate between the competing SDN controller designs, i.e., ONOS and OpenDaylight, when software reliability is a major concern.

The voting audit logs produced by electronic voting systems contain data that could be useful for uncovering procedural errors and election anomalies, but they are currently unwieldy and difficult for election officials to use in post-election audits. In this work, we develop new methods to analyze these audit logs for the detection of both procedural errors and system deficiencies. Our methods can be used to detect votes that were not included in the final tally, machines that may have experienced hardware problems during the election, and polling locations that exhibited long lines. We tested our analyses on data from the South Carolina 2010 elections and were able to uncover, solely through the analysis of audit logs, a variety of problems, including vote miscounts. We created a public web application that applies these methods to uploaded audit logs and generates useful feedback on any detected issues.

The development of information systems is a complex task, involving technical, human and organizational issues. The results of this activity are not always successful, and are apparent in the lack of software quality and in costs and schedules overruns. The first initiatives developed to solve these problems were concerned with the implementation issues. It is now widely accepted that the real problem comes from the early activities and information gathered in the beginning of the projects, the most important being those connected with system requirements. Although the efforts made and the initiatives proposed, there is not a widely accepted practice or standard in this area, comparable to what we have achieved, for example, in the modeling activities. This paper presents a brief description of the state of the art in the area of requirements specification, explains the motivation to develop a new initiative, which we have called "ProjectIT-Requirements" and describes the goals we want to achieve with the project and the global context in which it integrates.

The authors present their way of designing multimedia educational software to support the teaching of pathological and clinical physiology, taking advantage of interactive simulation games. Simulation models, created using Matlab/Simulink® from MathWorks, are decomposed to so-called simulation chips suitable for interdisciplinary cooperation during design-time. Interactive animations utilize Flash and Director from Macromedia, the user interfaces of the simulators are implemented in Control Web from Moravian Instruments, all integrated by Microsoft Visual Studio .NET. The authors also give their arguments concerning their preference for industrial development tools over academic "open source" tools.

A concurrency history graph is way to represent every state that can be entered by a parallel program. Such a graph can be used to detect errors in and verify properties of the parallel program. However, concurrency history graphs are usually too large to be generated in the obvious manner. A new abstraction which allows many program states to be represented by the same node in a concurrency history graph is presented. This new abstraction is more general than previous work by the authors. Using this new abstraction mechanism it is possible to produce concurrency history graphs requiring much less storage than that suggested by a simple worst case complexity analysis. A static analysis tool capable of detecting race conditions in parallel programs is being built based on concurrency history graphs using this new abstraction.

Software development environments can increase user productivity by presenting information in more useful ways. This paper describes Proteus, the presentation system of Ensemble, a software development environment that supports a wide variety of language and document capabilities. Proteus provides a set of services which allow the appearance of software development documents, such as programs or design specifications, to be determined by formal specifications of style. Proteus is based on a generic model of presentation services and is intended for use with a wide variety of media.

The use of registered names, trademarks, etc., in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant laws and regulations and therefore free for general use. The publisher makes no representation, express or implied, with regard to the accuracy of the information contained in this book and cannot accept any legal responsibility or liability for any errors or omissions that may be made.

Automated support such as the one provided by Software Development Environments (SDEs) is a key requirement for the systematization of large-scale component-based software development. However, to provide a Component-Based SDE, adequate software development process, methods and tools that consider Component-Based Development (CBD) activities must be previously defined. Moreover, CBD can be a highly distributed and collaborative activity that needs group interaction support. In this paper we describe OdysseyShare Environment, a Collaborative Component-Based SDE under development at the Computer Science Department of COPPE/UFRJ. It supports activities involved in modeling, construction, reuse and group interaction by providing an integrated set of tools and a repository of reusable components.

Regularities, or the conformity to unifying principles, are essential to the comprehensibility, manageability and reliability of large software systems, and should, therefore, be considered an important element of their architecture. But, as is argued in this paper, the inherent globality of regularities makes them very hard to implement in traditional methods. This paper explores an approach to regularities which greatly simplifies their implementation, making them more easily employable for taming of the complexities of large systems. This approach, which is based on the concept of law-governed architecture (LGA), provides system designers and builders with the means for establishing regularities simply by declaring them formally and explicitly as the law of the system. Once such a law-governed regularity is declared, it is enforced by the environment in which the system is developed. We introduce here the formalism for specifying laws under the Darwin/2 environment, and give a sa...

Within this paper, we describe a neuroinformatics project (called "NeuroScholar," http://www.neuroscholar.org/) that enables researchers to examine, manage, manipulate, and use the information contained within the published neuroscientific literature. The project is built within a multi-level, multi-component framework constructed with the use of software engineering methods that themselves provide code-building functionality for neuroinformaticians. We describe the different software layers of the system. First, we present a hypothetical usage scenario illustrating how NeuroScholar permits users to address largescale questions in a way that would otherwise be impossible. We do this by applying NeuroScholar to a "real-world" neuroscience question: How is stress-related information processed in the brain? We then explain how the overall design of NeuroScholar enables the system to work and illustrate different components of the user interface. We then describe the knowledge management strategy we use to store interpretations. Finally, we describe the software engineering framework we have devised (called the "View-Primitive-Data Model framework," [VPDMf]) to provide an open-source, accelerated software development environment for the project. We believe that NeuroScholar will be useful to experimental neuroscientists by helping them interact with the primary neuroscientific literature in a meaningful way, and to neuroinformaticians by providing them with useful, affordable software engineering tools.

We introduce a unified wcet analysis and scheduling framework for real-time applications deployed on multicore architectures. Our method does not follow a particular programming model, meaning that any piece of existing code (in particular legacy) can be re-used, and aims at reducing automatically the worst-case number of timing interferences between tasks. Our method is based on the notion of Time Interest Points (tips), which are instructions that can generate and/or suffer from timing interferences. We show how such points can be extracted from the binary code of applications and selected prior to performing the wcet analysis. We then represent real-time tasks as sequences of time intervals separated by tips, and schedule those tasks so that the overall makespan (including the potential timing penalties incurred by interferences) is minimized. This scheduling phase is performed using an Integer Linear Programming (ilp) solver. Preliminary results on state-of-the-art benchmarks show promising results and pave the way for future extensions of the model and optimizations.

ASTRAL is a formal specification language for realtime systems. It is intended to support formal software development and, therefore, has been formally defined. The structuring mechanisms in ASTRAL allow one to build modularized specifications of complex systems with layering. A realtime system is modeled by a collection of state machine specifications and a single global specification. This paper discusses the rationale of ASTRAL's design. ASTRAL's specification style is illustrated by discussing a telephony example. Composability of one or more ASTRAL system specifications is also discussed by the introduction of a composition section, which provides the needed information to combine two or more ASTRAL system specifications.

The authors' methodology of creating e-learning content for the students of physiology, pathophysiology and biomedicine at the Faculty of Medicine is presented here. The design process from a formalized description of physiological reality to interactive educational software is described. Various tools are used during the design-starting with the numerical simulation software Matlab/Simulink, through Macromedia Flash for interactive animations, Control Web or MS Visual Studio for user interface design to web publishing tools including the Macromedia Breeze learning management system. Also, various professions are involved-teachers, physicians, simulation/modeling experts, graphic designers and programmers. The aim is to provide students with software that helps them understand the complex dynamics of physiological systems.

Physiomodel (http://www.physiomodel.org) is our reimplementation and extension of an integrative physiological model called HumMod 1.6 (http://www.hummod.org) using our Physiolibrary (http://www.physiolibrary.org). The computer language Modelica is well-suited to exactly formalize integrative physiology. Modelica is an equation-based, and object-oriented language for hybrid ordinary differential equations (http:// www.modelica.org). Almost every physiological term can be defined as a class in this language and can be instantiated as many times as it occurs in the body. Each class has a graphical icon for use in diagrams. These diagrams are self-describing; the Modelica code generated from them is the full representation of the underlying mathematical model. Special Modelica constructs of physical connectors from Physiolibrary allow us to create diagrams that are analogies of electrical circuits with Kirchhoff's laws. As electric currents and electric potentials are connected in electrical domain, so are molar flows and concentrations in the chemical domain; volumetric flows and pressures in the hydraulic domain; flows of heat energy and temperatures in the thermal domain; and changes and amounts of members in the population domain.

This paper describes key features of an interpreter for a language-based editor. The interpreter unites in a RISC framework features which have been used in other domains. The paper examines each feature's integration into the RISC framework.

Recently, a number of extensions to the traditional transaction model have been proposed to support new information-intensive applications such as CAD/CAM and software development. However, these extended models capture only a subset of interactions that can be found in such applications, and represent only some of the points within the spectrum of interactions possible in competitive and cooperative environments. ACTA is a formalizable framework developed for characterizing the whole spectrum of interactions. The ACTA framework is not yet another transaction model, but is intended to unify the existing models. ACTA allows for specifying the structure and the behavior of transactions as well as for reasoning about the concurrency and recovery properties of the transactions. In ACTA, the semantics of interactions are expressed in terms of transactions' effects on the commit and abort of other transactions and on objects' state and concurrency status (i.e., synchronization sta...

Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references. ... [2] François Bancilhon, Won Kim, Henry F. Korth: A Model of CAD Transactions. VLDB 1985: 25-33.

A key ITER maintenance activity is the exchange of the divertor cassettes. One of the major focuses of the EU Remote Handling (RH) programme has been the study and development of the remote handling equipment necessary for divertor exchange. The current major step in this programme involves the construction of a full scale physical test facility, namely DTP2 (Divertor Test Platform 2), in which to demonstrate and refine the RH equipment designs for ITER using prototypes. The major objective of the DTP2 project is the proof of concept studies of various RH devices, but is also important to define principles for standardizing control hardware and methods around the ITER maintenance equipment. This paper focuses on describing the control system hardware design optimization that is taking place at DTP2. Here there will be two RH movers, namely the Cassette Multifuctional Mover (CMM), Cassette Toroidal Mover (CTM) and assisting water hydraulic force feedback manipulators (WHMAN) located aboard each Mover. The idea here is to use common Real Time Operating Systems (RTOS), measurement and control IO-cards etc. for all maintenance devices and to standardize sensors and control components as much as possible. In this paper, new optimized DTP2 control system hardware design and some initial experimentation with the new DTP2 RH control system platform are presented. The proposed new approach is able to fulfil the functional requirements for both Mover and Manipulator control systems. Since the new control system hardware design has reduced architecture there are a number of benefits compared to the old approach. The simplified hardware solution enables the use of a single software development environment and a single communication protocol. This will result in easier maintainability of the software and hardware, less dependence on trained personnel, easier training of operators and hence reduced the development costs of ITER RH.

Multimedia conferencing is an important new telecommunications service, and one of the requirements in this area is support for cooperative work. The approach taken in this paper is to provide such support by extending standard DBMS functionality. The conceptual foundation for this extension is Spheres of Control. These are used to introduce nesting of databases, and thus subdatabases, which serve as a means for cooperative work. Subdatabases can be dynamically created, and may be nested to arbitrary depths. Transactions that are allowed to visit a subdatabase, perform their work on behalf of the owner of the subdatabase. This gives rise to user friendly and easy to understand semantics. Subdatabases can be implemented by means of moderate extensions to standard locking schemes.

The UniForM-Workbench is an open tool-integration environment providing type-safe communication, a toolkit for graphical user-interfaces, version management and configuration management. We demonstrate how to integrate several tools for the Z specification language into the workbench, obtaining an instantiation of the workbench suited as a software development environment for Z. In the core of the setting, we use the encoding HOL-Z of Z into Isabelle as semantic foundation and for formal reasoning with Z specifications. In addition to this, external tools like editors and small utilities are integrated, showing the integration of both self-developed and externally developed tools. The resulting prototype demonstrates the viability of our approach to combine public domain tools into a generic software development environment using a strongly typed functional language.

We designed and implemented a prototype software development environment based on software component composition. Our software development environment, the Entity-Relationship Software Development E n vironment ERSDE, uses extended entity-relationship diagrams EERDs as templates of executable programs. An EERD represents the component types and the relationship types among them within an application domain. The graphical editor of the ERSDE uses an EERD as a menu in constructing application software. An EERD used a s a menu can enforce legitimate patterns of relationships among software components, in addition to providing an intuitive view of available components and possible relationships among them. Furthermore, as the ERSDE uses structural active objects as the components of a program, we can obtain an executable program if those components are instantiated and interconnected as dictated by an EERD. Two experiments conducted c on rmed the e ectiveness of our approach.