Integral: Petri-net approach to distributed software development

For safety critical systems, hardware is often preferred over software because it is easier to achieve safety goals in hardware alone and because hardware is considered more reliable than software. But as systems become more complex, software solutions will also be important. Here we demonstrate, using a simple example, that formal methods are a useful tool for developing software specifications for safety critical systems, since they reduce ambiguity in the design and can be proven consistent. Using formal methods for specifications will enable the development of dependable, high-performance, reliable hardware/software safety critical systems. The method we describe is the first step in our work to establish a hardware/software development process for safety critical systems.

\n Contains fulltext :\n 158152.pdf (Publisher’s version ) (Open Access)\n

Use cases are narrative description of interactions between users and a software system. They are primary used to specify functional system requirements. Despite the fact that use cases are narrative, there is no standard that specifies what textual specification of use case should like. However, the integration of use cases in a Model Driven Engineering process requires more rigorous specifications. The specification of use cases at different levels of abstraction is needed because of the large number of stakeholders involved in the software development process. We propose use cases specification at different levels of abstraction to promote better integration, communication and understanding among the involved stakeholders. We still discuss that base on this approach different software development artifacts such as domain model, system operations, user interface design can be automatically generated or validated.

The capability of an enterprise to innovate and promptly and effectively respond to change requests coming from both internal and external drivers has nowadays become a measure of the competitiveness of the enterprise in all business sectors. Innovation often implies modifying the enterprise business processes and, as a consequence, requires the evolution of the enterprise software systems. In this context, the workshop on Evolution of Software Systems in a Business Context (ESSBC), held in Budapest, Hungary, as part of the IEEE Software Technology and Engineering Practice workshop series (STEP 2005), aimed at discussing experiences and research outcomes and identifying research issues in supporting the evolution of enterprise software systems to reach innovation goals

Numerous formal specification methods have been proposed in the literature, such as the Z language, the Unified Modeling Language (UML), the B method, Petri nets, and action systems. Comparing the different specification methods is not an easy task but it is meaningful in many aspects. In this paper, we discuss the properties of five formal specification methods theoretically and address their differences by designing a particular part of the ABM system using each method, and further compare these methods by analyzing their strengths and weaknesses.

Formal methods in Computer Science are a particular kind of mathematically-based techniques for the specification, development and verification of software and hardware systems. Among them, Petri Nets have been widely used because of their high expressive power and accurate description capabilities. On the other hand, Dynamical Systems theory has not been used for these purposes so far. In this paper we present the first use of Discrete Dynamical Systems under the aim to better analyze Concurrent Computing Systems. In order to do that, Petri Nets, PNs, are properly encoded into DDSs, so defining the corresponding Phase Space with its metric structure and the evolution operator of the system.

Quality assessment and assurance constitute an important part of software engineering. The issues of software quality management are widely researched and approached from multiple perspectives and viewpoints. The introduction of a new paradigm in software development – namely Model Driven Development (MDD) and its variations (e.g., MDA [Model Driven Architecture], MDE [Model Driven Engineering], MBD [Model Based Development], MIC [Model Integrated Computing]) – raises new challenges in software quality management, and as such should be given special attention. In particular, the issues of early quality assessment, based on models at a high abstraction level, and building (or customizing the existing) prediction models for software quality based on model metrics are of central importance for the software engineering community.

Many critical control systems are developed using formal methods. When software applied to such systems is developed, the employment of formal methods in the software requirements specification and verification will provide increased assurance for such applications. Earlier error of overlooked requirement specification can be detected using formal specification method. Also the testing and full verification to examine all reachable states using model checking to undertake formal verification are able to be completed. In this paper, we proposed an eclectic approach to incorporate Z(Zed) formal language and ‘Statemate MAGNUM’ which is formal method tools using Statechart. Also we applied the proposed method to safety-critical railway signaling systems for the formal requirement specification and analyzed the specification results.

The most current trends in the evolution of software development process are closely related with the increasing complexity of software systems. This motivates software engineers and system developers to find an alternative solution for software system design and development. In this case, the manner offered by OMG’s initiative, the Model Driven Architecture namely, represents a model-driven approach to software development. It also considers the further evolution of CASE tools, bringing their functionality to the next level. This paper investigates the variety of the CASE tools developed under an impact of MDA growing progress. The differences between Model Driven Architecture and Model Driven Development in the context of automatic capabilities for software development are also discussed in the paper. The example of possibility to define a set of tools proposed as a tool chain for development of software systems under the framework of MDA, the projection of two-hemisphere approach for object-oriented software development into authors’ developed component model of MDA is offered in the paper.

Software development is a greatly multifaceted and intellect-oriented movement. In the early days of program development, developers engraved programs using machine language in which programmers consumed added time, thinking about a particular machine’s instruction set than the difficulty at hand. Progressively, programmers wandered to higher level languages. In order to progress software using higher level languages, there are different approaches and selection of software development approach depending on the type of application to be established. Aspect-oriented software development (AOSD) is a novel paradigm in software development that addresses certain concerns in software development that regards modularization as an important aspect. The practices of AOSD create the possibilities to modularize, crosscutting the concerns of a system. Analogous to objects in object-oriented software development, aspects in AOSD may ascend at any point of time of the software life cycle, containing requirements specification, design, implementation, etc. As this effort is built on empirical validating aspect-oriented metrics, coupling on method call (CMC) metric is selected. This work focuses on empirical validation of the metrics. Novel metric is cognitive weighted metric, which is calculated for CMC to calculate the coupling complexity value of the aspect.

In this chapter, we characterize the deficiencies of current software development paradigms and propose a new object-oriented development paradigm which eliminates such deficiencies. The deficiencies of current software development paradigms lead in general to program structures which often badly reflect the design decisions during the development. In addition software development process models apply a Procrustes bed to the sequence and nature of development steps. From this analysis we develop a new paradigm of software development which tries to overcome these deficiences. Based on the principles of Divide and Conquer and Separation of Concerns we derive two abstraction concepts. The concept of information hiding abstraction provides a structure for software systems. The concept of information neglection abstraction helps to structure the description of specifications. Based on these structuring concepts a specification language is outlined allowing to express many software properties ranging from high-level design to (nearly) implementation including concurrency and distribution aspects. Since the whole range of software design has a common basis development process models are possible which give the necessary freedom to the developer.Thus it helps considerably to manage the complexity of the software development process.

SOFL is a formal language and method for system specification and design. It was developed by integrating Petri Nets, Data Flow Diagrams, and VDM-SL. As the major feature of the original SOFL method is to use structured techniques for analysis and specification, and object-oriented techniques for design and implementation, SOFL has its own implementation language that is similar to C++. However during our recent work of applying SOFL to software systems, the transformation of structured specifications to object-oriented implementations creates some difficulties, simply because of paradigms mismatch. In this paper we extend SOFL to a formal object-oriented language and method while keeping its structured features. This will allow powerful object-oriented reuse mechanisms, such as class inheritance and object composition, to be utilized in the early phases, and transformation from SOFL specifications to commercial object-oriented programming languages to be readily achieved.

Putting Requirements and Quality at the Core of Global Service Delivery: Current Efforts and Future Plans at Pace University

Large-scale data processing forms the core of modern online services, such as social media and e-commerce, calling for an ever-increasing performance with predictable service quality. Even though emerging hardware platforms can deliver the required performance, actually harnessing it and guaranteeing a certain service quality is still a challenge for application and system software developers. We argue that the major hindrance for applications and system software alike lies in the design of today’s system software architecture. The thread abstraction, for example, hides hardware characteristics, such as the memory topology or accelerators from applications and application behavior from the system software, forcing the latter to base resource management on assumptions while preventing the former from leveraging the potential of modern hardware. We present the as a novel system software architecture with the requirements of modern data-intensive applications in mind. Instead of threads, the provides s as control flows, short, closed units of work that can easily be annotated with application-specific hints giving a glimpse into an application’s future behavior. These hints are used by the to provide automatic synchronization and prefetching, as well as efficient dynamic resource partitioning to ensure performance isolation and the observance of quality of service requirements.

Formal methods (FM) are mathematically-based techniques that provide a rigorous basis for software development: the application of FMs makes it possible to achieve provable correctness and reliability in the various steps of system design and implementation. This article is a tutorial presentation of formal methods and description techniques that address modeling and analysis of distributed systems and concurrent processes in telecommunications and protocol engineering. The aim of the article is to introduce to non-practitioners the main formal methods for communication protocols. For each method, a synthetic description of its textual or graphical syntax is provided. Also, the modeling capabilities and the basic communication features are pointed out by the application of the method to a common case study, a simple retransmission protocol. The tutorial description is completed by examples of recent applications of FMs to the specification and analysis of transmission and signaling protocols in industrial and research projects, which describe the methods' application domain and offer selected references for further readings.