Paradigms for design and implementation in ADA
Communications of the ACM
Software engineering (2nd ed.)
Software engineering (2nd ed.)
Software engineering with Ada
Programming language landscape: syntax, semantics, and implementation
Programming language landscape: syntax, semantics, and implementation
IEEE Transactions on Software Engineering
Toward a general object-oriented software development methodology
ACM SIGAda Ada Letters
Object-oriented design and PAMELA
ACM SIGAda Ada Letters
Encapsulation and inheritance in object-oriented programming languages
OOPLSA '86 Conference proceedings on Object-oriented programming systems, languages and applications
Object-oriented systems analysis: modeling the world in data
Object-oriented systems analysis: modeling the world in data
Introduction to systems analysis and design
Introduction to systems analysis and design
A Strategy for Comparing Alternative Software Development Life Cycle Models
IEEE Transactions on Software Engineering
Understanding the elements of system design
Critical issues in information systems research
A taxonomy for the early stages of the software development life cycle
Journal of Systems and Software
Transformation of data flow analysis models to object oriented design
OOPSLA '88 Conference proceedings on Object-oriented programming systems, languages and applications
General object-oriented software development: background and experience
Journal of Systems and Software
An object-oriented requirements specifications method
Communications of the ACM
A development in Eiffel: design and implementation of a network simulator
Journal of Object-Oriented Programming
Functional Refinement and Nested Objects for Object-Oriented Design
IEEE Transactions on Software Engineering
Object-oriented design: a responsibility-driven approach
OOPSLA '89 Conference proceedings on Object-oriented programming systems, languages and applications
Object-oriented analysis
Understanding object-oriented: a unifying paradigm
Communications of the ACM
Lessons from the design of the Eiffel libraries
Communications of the ACM
Class management for software communities
Communications of the ACM
Surveying current research in object-oriented design
Communications of the ACM
Concurrent object-oriented programming
Communications of the ACM
Information systems for managers (2nd ed.)
Information systems for managers (2nd ed.)
Object-oriented software construction (2nd ed.)
Object-oriented software construction (2nd ed.)
On the criteria to be used in decomposing systems into modules
Communications of the ACM
Structured Development for Real-Time Systems
Structured Development for Real-Time Systems
Describing software design in Ada
ACM SIGPLAN Notices
Principles of Program Design
System development (Prentice-Hall International series in computer science)
System development (Prentice-Hall International series in computer science)
Structured Analysis and System Specification
Structured Analysis and System Specification
Understanding object-oriented: a unifying paradigm
Communications of the ACM
A research typology for object-oriented analysis and design
Communications of the ACM - Special issue on analysis and modeling in software development
ACM SIGSOFT Software Engineering Notes
The process of object-oriented design
OOPSLA '92 conference proceedings on Object-oriented programming systems, languages, and applications
CHI '92 Proceedings of the SIGCHI Conference on Human Factors in Computing Systems
Identifying a complete object oriented life cycle for large systems development
TRI-Ada '92 Proceedings of the conference on TRI-Ada '92
SIGCPR '93 Proceedings of the 1993 conference on Computer personnel research
The O-O-O methodology for the object-oriented life cycle
ACM SIGSOFT Software Engineering Notes
On the purpose of object-oriented analysis
OOPSLA '93 Proceedings of the eighth annual conference on Object-oriented programming systems, languages, and applications
Model reusability in a graphical simulation package
WSC '92 Proceedings of the 24th conference on Winter simulation
The notion of inheritance in object-oriented programming
Communications of the ACM
There's more to OOP than syntax!
SIGCSE '94 Proceedings of the twenty-fifth SIGCSE symposium on Computer science education
Towards an integrated organization and technology development
Proceedings of the 1st conference on Designing interactive systems: processes, practices, methods, & techniques
The promise and the cost of object technology: a five-year forecast
Communications of the ACM - Special issue on object-oriented experiences and future trends
The fountain model and its impact on project schedule
ACM SIGSOFT Software Engineering Notes
Mapping a functional specification to an object-oriented specification in software re-engineering
CSC '96 Proceedings of the 1996 ACM 24th annual conference on Computer science
How to make software softer—designing tailorable applications
DIS '97 Proceedings of the 2nd conference on Designing interactive systems: processes, practices, methods, and techniques
Using an object-oriented software life-cycle model in the software engineering course
SIGCSE '98 Proceedings of the twenty-ninth SIGCSE technical symposium on Computer science education
Re-engineering legacy Cobol programs
Communications of the ACM
A reference model for workflow application development processes
WACC '99 Proceedings of the international joint conference on Work activities coordination and collaboration
A survey of structured and object-oriented software specification methods and techniques
ACM Computing Surveys (CSUR)
Doing object oriented simulations: advantages, new development tools
ANSS '91 Proceedings of the 24th annual symposium on Simulation
GAME: an object-oriented approach to computer animation in flexible manufacturing system modelling
ANSS '91 Proceedings of the 24th annual symposium on Simulation
CSC '91 Proceedings of the 19th annual conference on Computer Science
How difficult is the transition from OOA to OOD? (panel session)
OOPSLA '00 Addendum to the 2000 proceedings of the conference on Object-oriented programming, systems, languages, and applications (Addendum)
Communications of the ACM
Iterative design and testing within the software development life cycle
Software Quality Control
Evolutionary modelling of software systems: its application to agent-based and hypermedia systems
IWPSE '01 Proceedings of the 4th International Workshop on Principles of Software Evolution
Reusing Specifications in OO Applications
IEEE Software
IEEE Software
Distributed Information Systems: An Advanced Methodology
IEEE Transactions on Software Engineering
Reusing Software: Issues and Research Directions
IEEE Transactions on Software Engineering
Estimation and Prediction Metrics for Adaptive Maintenance Effort of Object-Oriented Systems
IEEE Transactions on Software Engineering
A brief history of the object-oriented approach
ACM SIGSOFT Software Engineering Notes
EHCI '01 Proceedings of the 8th IFIP International Conference on Engineering for Human-Computer Interaction
A Multi-variant Approach to Software Process Modelling
CAiSE '99 Proceedings of the 11th International Conference on Advanced Information Systems Engineering
Development productivity for commercial software using object-oriented methods
CASCON '95 Proceedings of the 1995 conference of the Centre for Advanced Studies on Collaborative research
Paradigm shift in software re-engineering: an experience report
CASCON '96 Proceedings of the 1996 conference of the Centre for Advanced Studies on Collaborative research
Managing the Software Development by Using the Recursive Multi- Threaded (RMT) Tool
TOOLS '99 Proceedings of the Technology of Object-Oriented Languages and Systems
Object Model Driven Code Generation for the Enterprise
RSP '01 Proceedings of the 12th International Workshop on Rapid System Prototyping
A conceptual model completely independent of the implementation paradigm
Journal of Systems and Software - Special issue: Best papers on Software Engineering from the SEKE'01 Conference
Box-structured methods for systems development with objects
IBM Systems Journal
An aspect-oriented UML tool for software development with early aspects
Proceedings of the 2006 international workshop on Early aspects at ICSE
The design and validation of a hybrid information system for the auditor's going concern decision
Journal of Management Information Systems - Special section: Managing virtual workplaces and teleworking with information technology
A framework supporting the utilization of domain knowledge embedded in software
ER '07 Tutorials, posters, panels and industrial contributions at the 26th international conference on Conceptual modeling - Volume 83
Object-oriented analysis and design in software project teams
Human-Computer Interaction
Some issues on scheduling estimation model for object-oriented software projects
ACM SIGSOFT Software Engineering Notes
The reengineering of a software system for glaucoma analysis
Computer Methods and Programs in Biomedicine
A navigational data model for object modeling technique development environment
Information Sciences: an International Journal
A theoretical framework of component-based software development phases
ACM SIGMIS Database
Modified development process of component-based software engineering
ACM SIGSOFT Software Engineering Notes
Business process modeling languages: Sorting through the alphabet soup
ACM Computing Surveys (CSUR)
Performance criteria of a sound office analysis methodology
International Journal of Information Management: The Journal for Information Professionals
A builder's introduction to executive information systems
International Journal of Information Management: The Journal for Information Professionals
Developing Knowledge-Based Systems: An Object-Oriented Organizational Approach
Information Resources Management Journal
A Model of the Motivation for IT Retraining
Information Resources Management Journal
A taxonomy of design methods process models
Information and Software Technology
Hi-index | 48.28 |
In software engineering, the traditional description of the software life cycle is based on an underlying model, commonly referred to as the “waterfall” model (e.g., [4]). This model initially attempts to discretize the identifiable activities within the software development process as a linear series of actions, each of which must be completed before the next is commenced. Further refinements to this model appreciate that such completion is seldom absolute and that iteration back to a previous stage is likely. Various authors' descriptions of this model relate to the detailed level at which the software building process is viewed. At the most general level, three phases to the life cycle are generally agreed upon: 1) analysis, 2) design and 3) construction/implementation (e.g., [36], p. 262; [42]) (Figure 1(a)). The analysis phase covers from the initiation of the project, through to users-needs analysis and feasibility study (cf. [15]); the design phase covers the various concepts of system design, broad design, logical design, detailed design, program design and physical design. Following from the design stage(s), the computer program is written, the program tested, in terms of verification, validation and sensitivity testing, and when found acceptable, put into use and then maintained well into the future.In the more detailed description of the life cycle a number of subdivisions are identified (Figure 1(b)). The number of these subdivisions varies between authors. In general, the problem is first defined and an analysis of the requirements of current and future users undertaken, usually by direct and indirect questioning and iterative discussion. Included in this stage should be a feasibility study. Following this a user requirements definition and a software requirements specification, (SRS) [15], are written. The users requirements definition is in the language of the users so that this can be agreed upon by both the software engineer and the software user. The software requirements specification is written in the language of the programmer and details the precise requirements of the system. These two stages comprise an answer to the question of WHAT? (viz. problem definition). The user-needs analysis stage and examination of the solution space are still within the overall phase of analysis but are beginning to move toward not only problem decomposition, but also highlighting concepts which are likely to be of use in the subsequent system design; thus beginning to answer the question HOW? On the other hand, Davis [15] notes that this division into “what” and “how” can be subject to individual perception, giving six different what/how interpretations of an example telephone system. At this requirements stage, however, the domain of interest is still very much that of the problem space. Not until we move from (real-world) systems analysis to (software) systems design do we move from the problem space to the solution space (Figure 2). It is important to observe the occurrence and location of this interface. As noted by Booth [6], this provides a useful framework in object-oriented analysis and design.The design stage is perhaps the most loosely defined since it is a phase of progressive decomposition toward more and more detail (e.g., [41]) and is essentially a creative, not a mechanistic, process [42]. Consequently, systems design may also be referred to as “broad design” and program design as “detailed design” [20]. Brookes et al. [9] refer to these phases as “logical design” and “physical design.” In the traditional life cycle these two design stages can become both blurred and iterative; but in the object-oriented life cycle the boundary becomes even more indistinct.The software life cycle, as described above, is frequently implemented based on a view of the world interpreted in terms of a functional decomposition; that is, the primary question addressed by the systems analysis and design is WHAT does the system do viz. what is its function? Functional design, and the functional decomposition techniques used to achieve this, is based on the interpretation of the problem space and its translation to solution space as an interdependent set of functions or procedures. The final system is seen as a set of procedures which, apparently secondarily, operate on data.Functional decomposition is also a top-down analysis and design methodology. Although the two are not synonymous, most of the recently published systems analysis and design methods exhibit both characteristics (e.g., [14, 17]) and some also add a real-time component (e.g., [44]). Top-down design does impose some discipline on the systems analyst and program designer; yet it can be criticized as being too restrictive to support contemporary software engineering designs. Meyer [29] summarizes the flaws in top-down system design as follows:1. top-down design takes no account of evolutionary changes;2. in top-down design, the system is characterized by a single function—a questionable concept;3. top-down design is based on a functional mindset, and consequently the data structure aspect is often completely neglected;4. top-down design does not encourage reusability. (See also discussion in [41], p. 352 et seq.)