8,393 research outputs found
An Ontological Foundation for Agile Modeling with UML
Some proponents of agile systems development have advocated for agile conceptual modeling for requirements analysis. Agile modeling focuses on creating simple models that focus on key requirements. The Unified Modeling Language (UML) is used in agile modeling, but using UML in an agile fashion requires that modelers be selective in choosing constructs consistent with agile principles such as maintaining simplicity and minimal modeling. This research aims to provide a theoretical foundation for choosing UML constructs for agile modeling. We perform an ontology-based analysis of UML modeling constructs to prioritize them for use in agile modeling. We propose that UML constructs that correspond to more primitive ontological concepts are more useful for creating agile models than constructs that represent derived concepts. We have identified a core group of UML constructs that correspond to primitive ontological concepts and argue that agile modelers will find these constructs more useful in modeling problem domains
Incremental UML for Agile development: embedding UML class models in source code
Agile methods favor "working software over comprehensive documentation." The latter presumably includes Unified Modeling Language. UML is expensive to maintain, and it lacks good drill-down mechanisms, however, UML affords very useful visualizations. This paper describes a discipline for incrementally embedding graphical UML class models within source code for continuous agile development. The approach consists of identifying a main function, and having it drive the piece-wise creation of UML by explicitly including in its postconditions the placement of functions corresponding directly to requirements. The approach thus introduces higher order pre-and postconditions. A specific process is provided for carrying this out, together with examples. It enables UML class model visualization in rapid development, especially when tool-supported
Semantic Bridging between Conceptual Modeling Standards and Agile Software Projects Conceptualizations
Software engineering benefitted from modeling standards (e.g. UML, BPMN), but Agile Software Project Management tends to marginalize most forms of documentation including diagrammatic modeling, focusing instead on the tracking of a project\u27s backlog and related issues. Limited means are available for annotating Jira items with diagrams, however not on a granular and semantically traceable level. Business processes tend to get lost on the way between process analysis (if any) and backlog items; UML design decisions are often disconnected from the issue tracking environment. This paper proposes domain-specific conceptual modeling to obtain a diagrammatic view on a Jira project, motivated by past conceptualizations of the agile paradigm while also offering basic interoperability with Jira to switch between environments and views. The underlying conceptualization extends conceptual modeling languages (BPMN, UML) with an agile project management perspective to enrich contextual traceability of a project\u27s elements while ensuring that data structures handled by Jira can be captured and exposed to Jira if needed. Therefore, concepts underlying the typical software development project management are integrated with established modeling concepts and tailored (with metamodeling means) for the domain-specificity of agile project management. A Design Science approach was pursued to develop a modeling method artifact, resulting in a domain-specific modeling tool for software project managers that want to augment agile practices and enrich issue annotation
Iterative criteria-based approach to engineering the requirements of software development methodologies
Software engineering endeavours are typically based on and governed by the requirements of the target software; requirements identification is therefore an integral part of software development methodologies. Similarly, engineering a software development methodology (SDM) involves the identification of the requirements of the target methodology. Methodology engineering approaches pay special attention to this issue; however, they make little use of existing methodologies as sources of insight into methodology requirements. The authors propose an iterative method for eliciting and specifying the requirements of a SDM using existing methodologies as supplementary resources. The method is performed as the analysis phase of a methodology engineering process aimed at the ultimate design and implementation of a target methodology. An initial set of requirements is first identified through analysing the characteristics of the development situation at hand and/or via delineating the general features desirable in the target methodology. These initial requirements are used as evaluation criteria; refined through iterative application to a select set of relevant methodologies. The finalised criteria highlight the qualities that the target methodology is expected to possess, and are therefore used as a basis for de. ning the final set of requirements. In an example, the authors demonstrate how the proposed elicitation process can be used for identifying the requirements of a general object-oriented SDM. Owing to its basis in knowledge gained from existing methodologies and practices, the proposed method can help methodology engineers produce a set of requirements that is not only more complete in span, but also more concrete and rigorous
Object-oriented modelling with unified modelling language 2.0 for simple software application based on agile methodology
Unified modelling language (UML) 2.0 introduced in 2002 has been developing
and influencing object-oriented software engineering and has become a standard
and reference for information system analysis and design modelling. There are
many concepts and theories to model the information system or software
application with UML 2.0, which can make ambiguities and inconsistencies for a
novice to learn to how to model the system with UML especially with UML 2.0.
This article will discuss how to model the simple software application by using
some of the diagrams of UML 2.0 and not by using the whole diagrams as
suggested by agile methodology. Agile methodology is considered as convenient
for novices because it can deliver the information technology environment to
the end-user quickly and adaptively with minimal documentation. It also has the
ability to deliver best performance software application according to the
customer's needs. Agile methodology will make simple model with simple
documentation, simple team and simple tools.Comment: 15 pages, 30 figure
Modeling functional requirements using tacit knowledge: a design science research methodology informed approach
The research in this paper adds to the discussion linked to the challenge of capturing and modeling tacit knowledge throughout software development projects. The issue emerged when modeling functional requirements during a project for a client. However, using the design science research methodology at a particular point in the project helped to create an artifact, a functional requirements modeling technique, that resolved the issue with tacit knowledge. Accordingly, this paper includes research based upon the stages of the design science research methodology to design and test the artifact in an observable situation, empirically grounding the research undertaken. An integral component of the design science research methodology, the knowledge base, assimilated structuration and semiotic theories so that other researchers can test the validity of the artifact created. First, structuration theory helped to identify how tacit knowledge is communicated and can be understood when modeling functional requirements for new software. Second, structuration theory prescribed the application of semiotics which facilitated the development of the artifact. Additionally, following the stages of the design science research methodology and associated tasks allows the research to be reproduced in other software development contexts. As a positive outcome, using the functional requirements modeling technique created, specifically for obtaining tacit knowledge on the software development project, indicates that using such knowledge increases the likelihood of deploying software successfully
- …