Dieter Landes

Developing Knowledge-Based Systems with MIKE

The paper describes the MIKE (Model-based and Incremental Knowledge Engineering) approach for developing knowledge-based systems. MIKE integrates semiformal and formal specification techniques together with prototyping into a coherent framework. All activities in the building process of a knowledge-based system are embedded in a cyclic process model. For the semiformal representation we use a hypermedia-based formalism which serves as a communication basis between expert and knowledge engineer during knowledge acquisition. The semiformal knowledge representation is also the basis for formalization, resulting in a formal and executable model specified in the Knowledge Acquisition and Representation Language (KARL). Since KARL is executable, the model of expertise can be developed and validated by prototyping. A smooth transition from a semiformal to a formal specification and further on to design is achieved because all the description techniques rely on the same conceptual model to describe the functional and nonfunctional aspects of the system. Thus, the system is thoroughly documented at different description levels, each of which focuses on a distinct aspect of the entire development effort. Traceability of requirements is supported by linking the different models to each other.

The Treatment of Non-Functional Requirements in MIKE

Non-functional requirements significantly affect and determine the quality of software systems. In this paper it is shown how non-functional requirements are modelled in MIKE, an approach to the development of knowledge-based systems. A semi-formal hypermedia-based model is used to describe the results of the elicitation and interpretation of non-functional requirements and their relationships. Non-functional requirements are the driving force behind the decisions taken in the design phase of MIKE. The impact of non-functional requirements on design decisions and interdependencies between design decisions are explicitly recorded in an additional model in MIKE, thus resulting in a rich documentation of the rationale of design decisions and also providing an important contribution to the traceability of these requirements.

Combining KARL and CRLM for designing vertical transportation systems

Abstract This paper describes a solution to the Sisyphus-II elevator-design problem by combining the formal specification language KARL and the configurable role-limiting shell approach. A knowledge-based system configuring elevator systems is specified and implemented. First, the knowledge is described in a graphical and semi-formal manner influenced by the KADS models of expertise. A formal description is then gained by supplementing the semi-formal description with formal specifications which add a new level of precision and uniqueness. Finally, a generic shell for propose-and-revise systems is designed and implemented as the realization of the final system. This shell was derived by adapting the shellbox COKE, also used for the previous Sisyphus office-assignment problem. As a result of this integration, we get a description of the knowledge-based system at different levels corresponding to the different activities of its development process.

Software engineering body of skills (SWEBOS)

The development of complex software systems requires a mixture of various technical and non-technical competencies. While there are some guidelines what technical knowledge is required to make a good software engineer, there is a lack of insight as to which non-technical or soft skills are required to master complex software projects. This paper proposes a body of skills (SWEBOS) for software engineering. The collection of necessary skills is developed on the basis of a clear, data-driven research design. The resulting required soft skills for software engineering are described precisely and semantically rich in a three-level structure. This approach guarantees that skills are not just characterized in a broad and general manner, but rather they are specifically adapted to the domain of software engineering.

Learning and teaching software process models

Software process models are fairly abstract tools for organizing large, complex software development projects. Since particularly undergraduate students commonly do not have any experience in being part of such a project, their understanding of the benefits and shortcomings of particular process models is very limited. Even more, frequently they are not aware of the need to follow a particular process model since their previous one-person software assignments were too small for requiring any such model at all.

Using business process models to foster competencies in requirements engineering

Requirements are of paramount importance for the quality of software systems. For various reasons, however, university students encounter difficulties in understanding the role of requirements and appropriately applying relevant methods to deal with requirements. This paper describes the concept for teaching requirements engineering that was devised at Coburg University of Applied Sciences. As a key idea, teaching requirements starts out from business process models. From these models, requirements for a workflow application can be derived and specified in a requirements document. A main benefit of this approach lies in the fact that requirements are not just presented as an abstract concept. Furthermore, students are exposed to the complexity of an almost realistic workflow application. Being more realistic than a toy project, the latter also improves understanding why requirements should be described precisely and provides opportunities to also exercise non-technical competencies that are important for successful requirements engineering.

Active and inductive learning in software engineering education

If software engineering education is done in a traditional lecture-oriented style students have no other choice than believing that the solutions they are told actually work for a problem that they never encountered themselves. In order to overcome this problem, this paper describes an approach which allows students to better understand why software engineering and several of its core methods and techniques are needed, thus preparing them better for their professional life. This approach builds on active and inductive learning. Exercises that make students actively discover relevant software engineering issues are described in detail together with their pedagogical underpinning.

A multi-perspective framework for evaluating software engineering education by assessing students' competencies: SECAT — A software engineering competency assessment tool

Education invariably aims at developing competencies, technical as well as non-technical ones. As a consequence, there is also a need for methods that can be used to assess the quality of education faithfully. One possible approach is an assessment of whether intended learning outcomes are achieved, i.e. an investigation if the target audience possesses the desired competencies. Assessment of competencies, however, is tricky since competencies are often only vaguely defined. This paper presents SECAT, an approach to assess competencies, and particularly those needed for proper software engineering. To that end, SECAT builds on Rauners approach for competency assessment in vocational education. Rauners approach uses nine competency criteria, which are further refined by suitable issues that indicate to which extent a competency is, or should be, present. The main contribution of this paper lies in the adaptation and enhancement of this framework in order to make it useable in software engineering education. Adaptation and enhancements encompass issues such as team and individual assessments, integration of multiple perspectives from various groups of stakeholders, and product- and process-orientation. The paper also presents first insights from using SECAT in a pilot university course in software engineering.

Two Languages to Do the Same

In the paper we compare two languages originating from different areas of computer science. KARL is an executable specification language allowing explorative prototyping in the context of building knowledge-based systems (kbs). INCOME offers an executable specification language allowing explorative prototyping when building information systems. Our comparision shows very similar language primitives in both languages for modelling static knowledge. The main difference of the language offered by INCOME and KARL is the separation of data and control flow and the generic representation of the dynamical behavior of a modelled system in KARL.

ConDist: a context-driven categorical distance measure

A distance measure between objects is a key requirement for many data mining tasks like clustering, classification or outlier detection. However, for objects characterized by categorical attributes, defining meaningful distance measures is a challenging task since the values within such attributes have no inherent order, especially without additional domain knowledge. In this paper, we propose an unsupervised distance measure for objects with categorical attributes based on the idea that categorical attribute values are similar if they appear with similar value distributions on correlated context attributes. Thus, the distance measure is automatically derived from the given data set. We compare our new distance measure to existing categorical distance measures and evaluate on different data sets from the UCI machine-learning repository. The experiments show that our distance measure is recommendable, since it achieves similar or better results in a more robust way than previous approaches.