Software flexibility in a web environment

Flexible software systems are designed to be able to adapt to changes in their environment without the need for programmer intervention. This allows companies and institutions to avoid the cost of hiring a programmer every time a business rule changes or a data structure is modified. The techniques of designing and implementing flexible 3GL software systems have been proven as a means of reducing the high cost of software maintenance caused by the changing of systems requirements. Such systems have been in operation in the European finance sector since the early 1980\u27s. Edith Cowan University is participating in current research investigating the effectiveness of porting these techniques into the realm of modem 4GL environments such as Oracle. The explosion in popularity of the World Wide Web in recent years means that software developers will now be looking at the Web as the primary means of deployment for many of their applications. Web application developers will face the same high maintenance costs that have always plagued software developers. This study investigates the porting of techniques of software flexibility from 3GL and 4GL environments to the World Wide Well environment, and any benefits that this may bring to users and administrators of World Wide Web systems. This investigation involved the development of a flexible, Web-enabled system to allow unit coordinators at Edith Cowan University to manage access to Web-enabled unit materials. University staff were invited to comment on the usefulness of the flexibility of the system

Categorizing Non-Functional Requirements Using a Hierarchy in UML.

Non-functional requirements (NFRs) are a subset of requirements, the means by which software system developers and clients communicate about the functionality of the system to be built. This paper has three main parts: first, an overview of how non-functional requirements relate to software engineering is given, along with a survey of NFRs in the software engineering literature. Second, a collection of 161 NFRs is diagrammed using the Unified Modelling Language, forming a tool with which developers may more easily identify and write additional NFRs. Third, a lesson plan is presented, a learning module intended for an undergraduate software engineering curriculum. The results of presenting this learning module to a class in Spring, 2003 is presented

Implementing flexible software techniques in a 4GL environment

Today more IT professionals arc employed on the maintenance of existing software applications than are employed to develop new systems. Why is there such a need for this maintenance? Part of the problem is that developers have traditionally seen system requirements as fixed from the time they have been \u27signed off. In reality requirements arc dynamic and subject to change as an organisation\u27s environment changes. Flexible software techniques recognise that software requirements are subject to future changes. Flexibility is seen as an important design goal criterion with true or strong flexibility implying that an application\u27s behaviour can be altered without the need for changing program code. The purpose of this study is to: - Identify flexible software techniques described in the current literature. - Identify features present in the Oracle suite of tools that can lead to flexibility. - Design and implement a demonstration application that demonstrates both the flexible techniques and features identified

Meeting the Challenge of Dynamic User Requirements Using Data-Driven Techniques on a 4GL-Database Environment

Accompanying the ever-growing reliance on computers within contemporary organisations, the task of software maintenance is, increasingly, becoming a resource burden. The author has identified that there is a need for proven techniques to allow the modelling of flexible/changing user requirement, to enable systems to cope with requirements creep without suffering major code change and associated down-time from rebuilds of the database. This study ascertains the applicability of extension to current data modelling techniques that allows innate flexibility within the data model. The extension of the data model is analysed for potential benefits in the provision of such a dynamic/flexible base to realise \u27maintenance friendly\u27 systems and, in consequence, alleviate the cost of later, expensive maintenance

A framework for the analysis and evaluation of software development methodologies based on formal, intrinsic and pragmatic criteria

Includes bibliographical references (leaves 143-151)

Arash : a re-structuring environment for building software systems from reusable components

Arash is a rule-based tool for re-structuring source programs in order to build software systems from reusable components. Arash incorporates a collection of Generalizers which transform source code modules into abstracted modules. Conversely, a collection of Refiners produce a concrete instance from an abstracted source module . Both Generalizers and Refiners operate on source code components called fragments to restructure existing programs, documentation, and associated text. The main significance of Arash is that it is a rule-based tool which can be applied to a family of programming languages, e.g. Pascal, Modula-2, and C. In this paper we describe how to use Arash to restructure Modula-2 source code modules taken from a programmer's database of reusable components in order to construct new software systems, quickly and correctly .Keywords : Programming environment, program transformation, source code mutation, syntax directed tools, code fragments, code selection, customizing, general software, generic systems, program generation, tailoring, reuse of software

A rule based approach to program development

A rule based transformational model for program development and a metatool based on the above model is presented. The meta-tool can be instantiated to create various program development tools such as tools for building reusable software components, language directed editors, language to language translators, program instrumentation, structured document generator, and adaptive language based prettyprinters. This new rule based approach has two important features: 1) it is language independent and can be applied to various languages, and 2) provides a powerful escape mechanism for extending the semantics of the rules. Instances of the meta-tool for restructuring source programs for building abstract components and their refinement to concrete instances, source-to-source translation, and source contraction and expansion tools for improving readability and understanding are described