Object oriented development of engineering software using CLIPS

Engineering applications involve numeric complexity and manipulations of a large amount of data. Traditionally, numeric computation has been the concern in developing an engineering software. As engineering application software became larger and more complex, management of resources such as data, rather than the numeric complexity, has become the major software design problem. Object oriented design and implementation methodologies can improve the reliability, flexibility, and maintainability of the resulting software; however, some tasks are better solved with the traditional procedural paradigm. The C Language Integrated Production System (CLIPS), with deffunction and defgeneric constructs, supports the procedural paradigm. The natural blending of object oriented and procedural paradigms has been cited as the reason for the popularity of the C++ language. The CLIPS Object Oriented Language's (COOL) object oriented features are more versatile than C++'s. A software design methodology based on object oriented and procedural approaches appropriate for engineering software, and to be implemented in CLIPS was outlined. A method for sensor placement for Space Station Freedom is being implemented in COOL as a sample problem

Teaching Software Development to Non-Software Engineering Students

This paper argues that although the object-oriented programming (OOP) paradigm is appropriate for students taking programming modules on Higher Education (HE) software engineering course, this paradigm is not as relevant for students from other courses who study programming modules. It is also asserts that adopting another paradigm when teaching programming to non-software engineering students need not prevent the encouragement of good software engineering practices The paper discusses the software development model, procedures, techniques and programming language that the author requires non-software engineering students to employ when developing their software. This discussion also includes consideration of implementation issues in an educational context. The paper concludes that his alternative approach has been successfully implemented, that it requires the student to adopt a rigorous approach to development and that it encourages best software engineering practices. The conclusions also note that delivering this alternative offers the opportunity to include good educational practice, such as role-play

An Object-Oriented Software Model for Students’ Registration and Examination Result Processing in Nigerian Tertiary Institutions

The principles of Object-Oriented Software Engineering are employed to model a software application known as Undergraduate Registration and Examination Processing System (SPERU) for Nigerian Tertiary institutions. Rapid Application Development (RAD) tools are utilized in its implementation to achieve an excellent software system. SPERU is herein presented , as a typical instance of a well modelled software system, that testifies to the beauty, power and supremacy of the Object-Oriented paradigm The result of applying software predictor metrics indicates that SPERU is reliable and elegant

REKAYASA PERANGKAT LUNAK DENGAN MODEL UNIFIED PROCESS STUDI KASUS: SISTEM INFORMASI JOURNAL

In the era of object oriented programming, the analysis models of structured approaches is start to be left behind, because it is no longer relevan with object-oriented paradigm. Nowadays who become the standard of analysis and design of object-oriented system is Unified Modeling Language (UML). However UML is just notations, it doesn’t provide a framework to work in software engineering. The Unified Proces which proposed by Rumbaugh and friends, is a framework for object-oriented software engineering

Towards correct-by-construction product variants of a software product line: GFML, a formal language for feature modules

Software Product Line Engineering (SPLE) is a software engineering paradigm that focuses on reuse and variability. Although feature-oriented programming (FOP) can implement software product line efficiently, we still need a method to generate and prove correctness of all product variants more efficiently and automatically. In this context, we propose to manipulate feature modules which contain three kinds of artifacts: specification, code and correctness proof. We depict a methodology and a platform that help the user to automatically produce correct-by-construction product variants from the related feature modules. As a first step of this project, we begin by proposing a language, GFML, allowing the developer to write such feature modules. This language is designed so that the artifacts can be easily reused and composed. GFML files contain the different artifacts mentioned above.The idea is to compile them into FoCaLiZe, a language for specification, implementation and formal proof with some object-oriented flavor. In this paper, we define and illustrate this language. We also introduce a way to compose the feature modules on some examples.Comment: In Proceedings FMSPLE 2015, arXiv:1504.0301

Business engineering. Generic Software Architecture in an Object Oriented View

The generic software architecture offers a solution for the the information system's development and implementation. A generic software/non-software model could be developed by integrating the enterprise blueprint concept (Zachman) and the object oriented paradigm (Coad's archetype concept). The standardization of the generic software architecture for various specific software components could be a direction of crucial importance, offering the guarantee of the quality of the model and increasing the efficiency of the design, development and implementation of the software. This approach is also useful for the implementation of the ERP systems designed to fit the user’s particular requirements.software engineering, software architecture, object oriented design, archetype, domain-neutral component

Assessing design patterns for concurrency

Design patterns are language-independent software-engineering techniques for solving recurring problems within a particular problem-context. Despite their generality, they have been primarily adopted by, and for the most part developed within, the object-oriented community. As a result, some pattern definitions are sometimes expressed with objects-oriented machinery in mind such as classes and inheritance. We test the paradigm independence of these design patterns and investigate the viability of adopting existing patterns from the object-oriented paradigm to the message-passing concurrency setting. By porting these techniques to the new programming paradigm, we expect to inherit the benefits associated with these design patterns. We achieve these goals by implementing a suite of design patterns as reusable modules in Erlang, an industry-strength message-passing language for programming concurrent distributed systems.peer-reviewe

An Object Oriented Paradigm for Requirements Specifications.

Software engineering defines a formalized five-step life-cycle for software development. These steps are: requirements specification, design, implementation, testing and maintenance. The requirements specification phase of the software development life-cycle is responsible for determining the functionality of the proposed system. In this work, a methodology is developed that enhances the generation of accurate requirements specifications, utilizing an object-oriented paradigm. This research realizes four objectives. First, the process of information transferral between the user and the specification team is enhanced. Second, a working base of knowledge containing the domain-specific information within the initial requirements document is established for use by the specification team. Third, techniques for evaluating the overall quality of the initial requirements document are addressed. Specifically, the problems associated with document ambiguity, completeness, consistency and structure are examined. Finally, a specification paradigm is defined utilizing this knowledge-based specification environment. The paradigm permits the automatic generation of an object-oriented specification model. This model may then be used as an input for the design phase. This paradigm defines a methodology for the establishment and evaluation of the knowledge-based specification environment. The environment permits the incorporation of an object-oriented development strategy into the specification process. In addition, the concept of information traceability throughout the specification process is enhanced

Developing Distributed System with Service Resource Oriented Architecture

 Service oriented architecture (SOA) is a design paradigm in software engineering for an enterprise scale which built in a distributed system environment. This paradigm aims at abstracting of application functionality as a service through a protocol in web service technology, namely simple object access protocol (SOAP). However, SOAP have static characteristic and oriented by the service methode, so have restrictiveness on creating and accessing for big numbers of service. For this reason, this reasearch aims at combining SOA with resource oriented architecture (ROA) that is oriented by the service resource use representational state transfer (REST) protocol in order to expand scalability of service. This combination is namely service resource oriented architecture (SROA). SROA can optimize distributing of applications and integrating of services where is implemented to develop the project management software. To realize this model, the software is developed according with framework of Agile model driven development (AMDD) to reduce complexities on the whole stage processing of software development

An object-oriented analysis technique for developing object-oriented simulations in Silk.

Simulation is very popular as an analysis tool for complex systems. A new paradigm shift towards object oriented simulations is hoping to make simulations even more powerful and accessible. However, in order for those not familiar with object oriented techniques to join this shift, methods must be developed for them to build object oriented simulations, until they acquire an understanding of this programming paradigm. This is an attempt to develop a procedure for just such novice model builders. This thesis begins with some background on object oriented paradigm concepts. It then provides an overview of several different object oriented analysis techniques and attempts to define the common steps of these approaches. Several different commercial object-oriented simulation software are described, with an in depth description of the software selected, Silk, a java based simulation software. The general object oriented analysis approach is then adapted for simulation purposes, resulting in a proposed object oriented analysis technique for developing simulations, and an example is given. Object oriented analysis techniques such as use-case modeling and noun extraction are used to identify potential objects in a discrete manufacturing system to be simulated. These objects are then mapped to existing object classes in the Silk software for final model building.Dept. of Industrial and Manufacturing Systems Engineering. Paper copy at Leddy Library: Theses & Major Papers - Basement, West Bldg. / Call Number: Thesis2003 .Z36. Source: Masters Abstracts International, Volume: 42-03, page: 1031. Adviser: R. S. Lashkari. Thesis (M.A.Sc.)--University of Windsor (Canada), 2003