An assurance case is a structured set of arguments supported by evidence, demonstrating that a system’s nonfunctional requirements (e.g., safety, security, reliability) have been correctly implemented. Assurance case patterns serve as templates derived from previous successful assurance cases, aimed at facilitating the creation of new assurance cases. Despite using these patterns to generate assurance cases, their instantiation remains a largely manual and error-prone process that heavily relies on domain expertise. Thus, exploring techniques to support their automatic instantiation becomes crucial. This study aims to investigate the potential of Large Language Models (LLMs) in automating the generation of assurance cases that comply with specific patterns. Specifically, we formalize assurance case patterns using predicate-based rules and then utilize LLMs, i.e., GPT- 4o and GPT-4 Turbo, to automatically instantiate assurance cases from these formalized patterns. Our findings suggest that LLMs can generate assurance cases that comply with the given patterns. However, this study also highlights that LLMs may struggle with understanding some nuances related to pattern-specific relationships. While LLMs exhibit potential in the automatic generation of assurance cases, their capabilities still fall short compared to human experts. Therefore, a semi-automatic approach to instantiating assurance cases may be more practical at this time.

An assurance case is a structured hierarchy of claims aiming at demonstrating that a mission-critical system supports specific requirements (e.g., safety, security, privacy). The presence of assurance weakeners (i.e., assurance deficits, logical fallacies) in assurance cases reflects insufficient evidence, knowledge, or gaps in reasoning. These weakeners can undermine confidence in assurance arguments, potentially hindering the verification of mission-critical system capabilities which could result in catastrophic outcomes (e.g., loss of lives). Given the growing interest in employing assurance cases to ensure that systems are developed to meet their requirements, exploring the management of assurance weakeners becomes beneficial. As a stepping stone for future research on assurance weakeners, we aim to initiate the first comprehensive systematic mapping study on this subject. We followed the well-established PRISMA 2020 and SEGRESS guidelines to conduct our systematic mapping study. We searched for primary studies in five digital libraries and focused on the 2012–2023 publication year range. Our selection criteria focused on studies addressing assurance weakeners from a qualitative standpoint, resulting in the inclusion of 39 primary studies in our systematic review. Our systematic mapping study reports a taxonomy (map) that provides a uniform categorization of assurance weakeners and approaches proposed to manage them from a qualitative perspective. The taxonomy classifies weakeners in four categories: aleatory, epistemic, ontological, and argument uncertainty. Additionally, it classifies approaches supporting the management of weakeners in three main categories: representation, identification and mitigation approaches. Our study findings suggest that the SACM (Structured Assurance Case Metamodel) – a standard specified by the OMG (Object Management Group) – offers a comprehensive range of capabilities to capture structured arguments and reason about their potential assurance weakeners. Our findings also suggest novel assurance weakener management approaches should be proposed to better assure mission-critical systems.

Abstract Modelling is an important activity in software development and it is essential that students learn the relevant skills. Modelling relies on dedicated tools and these can be complex to install, configure, and use—distracting students from learning key modelling concepts and creating accidental complexity for teachers. To address these challenges, we believe that modelling tools specifically aimed at use in teaching are required. Based on discussions at a working session organised at MODELS 2023 and the results from an internationally shared questionnaire, we report on requirements for such modelling tools for teaching. We also present examples of existing modelling tools for teaching and how they address some of the requirements identified.

Umple is an open-source software modeling tool and compiler. It incorporates textual language constructs for UML modeling, including associations and state machines. It includes traits, aspects, and mixins for separation of concerns. It supports embedding methods written in many object-oriented languages, enabling it to generate complete multilingual systems. It provides comprehensive analysis of models and generates many kinds of diagrams, some of which can be edited to update the Umple code. Umple runs on the command line, in a web browser or in integrated development environments. It is designed to help developers reduce code volume, while they develop in an agile, model-driven manner. Umple is also targeted at educational users where students are motivated by its ability to generate real systems from their software models.

In this tutorial we will discuss a method of teaching a variety of software engineering topics in an integrated and experiential manner. Topics covered include agile processes, software modeling, open source development tools and processes, code generation and testing. Our approach involves using a textual modeling language called Umple that enables agile, model-driven, test-driven development. Students are introduced to this tool in an introduction to software engineering course, where they learn the basics of the above topics. Then in their capstone course they are able to actually contribute to the tool itself.

We extend Umple, a model-oriented programming language, to incorporate text emission from templates as an integral feature. Umple as a template language (Umple-TL) is the term we use to describe the template sublanguage of Umple. Using Umple-TL, developers can benefit from synergies among UML modelling, templating and programming in several target languages (Java, C++), all in one textual language – Umple. Umple itself is written in Umple; using Umple-TL, we eliminated Umple's dependency on third-party libraries for text emission. We also support any other application developed in JET to be converted to use Umple-TL and attain benefits such as smaller and faster executables, target-language independence and IDE independence. The word ‘template’ in this paper refers to patterns for the generation of output, and not to generic types, another common use of the term.

We present the results of a survey of 228 software practitioners conducted on two phases ten years apart. The goal of the study is to uncover trends in the practice of software design and the adoption patterns of modeling languages such as UML. The first phase was conducted in April-December 2007 and included 113 responses. The second phase was conducted in March-November 2017 and included 115 responses. Both surveys were conducted online, employed identical solicitation mechanisms, and included the same set of questions. The survey results are analyzed within each phase and across phases. We present the results and analysis of the data identifying upward and downward trends in design and modeling practices. The results suggest some increase in formal and informal modeling and identify key challenges with modeling platforms and tools. The results can help researchers, practitioners, and educators to focus efforts on issues of relevance and significance to the profession.

We nominate the University of Ottawa Software Engineering Program for the 2017 CSEE&T Hall of Fame. This was one of the first three undergraduate software engineering programs in Canada. It was used to help guide the development of the IEEE/ACM SE2004 curriculum recommendations. It is accredited by both the Canadian Engineering Accreditation Board and the Computer Science Accreditation Council of Canada. It is a bilingual English-French program that has undergone continuous improvement over the years, and now is co-op only, meaning that all its students are required to have three work terms of job experience before graduating.

We present the results of a survey of tool use in software modeling education conducted from December 2016 to March 2017. The survey was conducted among 150 professors who taught modeling in 30 countries from all regions of the world. Professors reported using 32 modeling tools. Top motivations for choosing tools are simplicity of learning and installing, as well as the tools being free and supporting the most important notations. Top complaints about tools included not interacting with other tools, not supporting sufficient modeling aspects, and being complex to use. Seven of the tools were used by more than one professor as their main tools, and we analyzed these in more depth. Among these 7, lack of feedback about models emerged as another key weakness. The tools varied very considerably regarding which of these strengths and weaknesses they exhibited. The key lessons from the paper are a) that tool developers have many opportunities to improve their products, and b) that educators might benefit from introducing students to multiple different tools.

Component-based development enforces separation of concern to improve reusability and maintainability. In this paper, we show how we extended Umple (http://try.umple.org) to support component-based development. The development of components, ports, and connectors is enabled using easy-to-comprehend keywords. Development is supported in both textual and visual representations. The design pattern followed in our implementation is the active object pattern. We show a comparison between Umple and other modelling tools. We show that Umple has a set of component features comparable to commercial modelling tools, but is the most complete, particularly with regard to code generation, among the open source tools.

Huge benefits are gained when Model Driven Engineering are adopted to develop software systems. However, it remains a challenge for software modelers to embrace the MDE approach. In this paper, we present Umple, a framework for Model Driven Development in Object-Oriented Systems that can be used to generate entire software systems (Model Driven Forward Engineering) or to recover the models from existing software systems (Model Driven Reverse Engineering). Umple models are written using a friendly human-readable modeling notation seamlessly integrated with algorithmic code. In other words, we present a model-is-the-code approach, where developers are more likely to maintain and evolve the code as the system matures simply by the fact that both model and code are integrated as aspects of the same system. Finally, we demonstrate how the framework can be used to elaborate on solutions supporting different scenarios such as software modernization and program comprehension.

Umple is a model-oriented programming technology designed to teach modeling while at the same time being practical for industrial application. In this paper we discuss six principles we followed in order to ensure Umple can be effective as a learning resource: being highly usable, facilitating incremental learning, providing an experience of positive reinforcement in learners, convincing learners about the value of the material, broadening learning opportunities, and being inexpensive.

Developers using model driven development (MDD) to develop systems lack the ability to specify traces that operate at the model level. This results in specification of traces at the generated code level. In this paper, we are proposing trace directives that operate at the model level to specify the tracing of UML attributes and state machines. Trace directives are implemented as part of the Umple textual modeling language, thus these directives can be expressed in a textual form. Trace code will be injected into system source code that corresponds to trace directives specified at the model level.

Test-Driven Development (TDD) is the practice of attempting to use the software you intend to write, before you write it. The premise is straightforward, but the specifics of applying it in different domains can be complex. In this paper, we provide aTDD approach for language development. The essence is to apply TDD at each of four levels of language processing, hence we call our approach Multi-Level TDD, or MLTDD. MLTDD can be applied to programming languages, preprocessors, domain specific languages, and transformation engines. MLTDD was used to build Umple, a model-oriented programming language available for Java, Ruby, and PHP. We present two case studies where this approach was implemented to develop two other domain specific languages.

Model Driven Architecture (MDA) advocates the use of models, rather than code, as the main development artifact. Yet model versioning and merging tools still lag in capabilities, ease of use and adoption relative to source code versioning and merging tools. This forces many teams to avoid model-based collaboration and concurrent model modifications. In this paper, we highlight the main challenges behind the relatively small adoption of model merging approaches. We present a novel model-based programming technology that addresses many of those challenges. The approach treats code and models uniformly, effectively enabling modelers to version and merge models using existing text-based technologies.

We analyze the current direction of UML Action Language development and provide a classification of the proposed action language structure and statements. We also present a functioning implementation of an action language and discuss our platform for experimenting with Action Language based systems. We propose a novel approach that adopts a bottom-up technique to defining an action language. This approach embeds the action language into a textual environment that includes the UML modeling elements. Unlike current action languages that typically address class diagrams only, our proposal includes class and state machine modeling abstractions as part of the action language. We tackle the problem of modeling-in-text not by introducing yet another programming language, but instead by providing an increased level of abstraction to existing high level programming languages. Both, a textual representation of the model and its visual view represent the same underlying model but from different vantage points.

Abstract: UML modelling tools provide poor support for composite state machine code generation. Generated code is typically complex and large, especially for composite state machines. Existing approaches either do not handle this case at all or handle it by flattening the composite state machine into a simple one with a combinatorial ex-plosion of states, and excessive generated code. This paper presents a new approach that transforms a composite state machine into an equivalent set of simple state machines before code generation. This avoids the combinato-rial explosion and leads to more concise and scalable generated code. We implement our approach in Umple.We report on a case study, comparing our approach to others in terms of code size and scalability. 1

Model Driven Engineering proposes the use of models as the main development artifacts. This methodology involves generating code from models and then perhaps adding some details to the generated code. Frequently, it is required to also reverse-engineer code to generate models. Despite the wide acceptance of modeling benefits, the use of Model Driven Engineering practices remains limited. We present model oriented programming as a new paradigm to reduce the ever-present tension between model-centric and code-centric development styles. The core of this approach is to add UML abstractions such as associations and state machines directly into a high-level programming language code. In this approach, model diagrams become just another abstract view of the code. The need for reverse engineering is eliminated, since everything in the diagram is represented directly in the code. Model orientation is illustrated using Umple, a working model oriented programming platform. A functional layer of an airline reservation system is presented as a case study.

SUMMARY The emergence of model‐driven software development brings new opportunities and challenges for rapid prototyping. On the one hand, the modeling process is inherently abstract, removing the prototyper from details, and letting him or her focus on exploring design alternatives for various aspects of the system. On the other hand, the most popular modeling languages and tools entirely omit the modeling and generating of user interfaces. As a result, the benefit of user interface prototypes as a medium for interaction with the user and customer is lost. This paper presents a model‐oriented technology called Umple that can be used for prototyping and also supporting model driven engineering. Umple allows end users to quickly create class and state machine models and to incrementally embed implementation artifacts. At any point in the modeling process, users can quickly generate a fully functional prototype that exposes modeling implications on the user interface, and allows stakeholders to get a feel of how the full system will behave. Copyright © 2011 John Wiley & Sons, Ltd.

We show how a technology called Umple can be used to improve teaching UML and modeling. Umple allows UML to be viewed both textually and graphically, with updates to one view reflected in the other. It allows UML concepts to be added to programming languages, plus web-based code generation from UML to those languages. We have used Umple in student laboratories and assignments for two years, and also live in the classroom. In a survey, students showed enthusiasm about Umple, and indicated they believe it helps them understand UML better. Improvements in their grades also support our approach.

In order to reduce the risk of failure in software projects, it is critical to achieve a true understanding of the problem and requirements. Several requirements engineering tools and techniques have been proposed amongst which, problem-oriented approaches are recognized as techniques that start with problem analysis rather than solution analysis. Such approaches are distinguished by their ability of solving a software-related problem based on the category the problem falls into. In this paper, a mapping from problem frames (PF) as one problem-oriented approach to use cases as the most popular requirements engineering technique is provided. Bridging problem frames with use cases is important for benefiting from the popularity of use cases while observing the advantages of problem frames. It can also build up a trust to PF approaches within the software engineering community.

Our research tool, Umple, has the objective of raising the abstraction level of programming languages by adding modeling abstractions such as UML associations, attributes and state machines. My research focuses on the syntax and semantics of state machines in Umple plus the empirical validation of Umple. The latter consists of a grounded theory study of Umple users, and action research involving the use of Umple in an industrial sitting. The grounded theory study is guiding our research and development of Umple. The action research is enlarging the pool of Umple users and contributing to the validation of Umple's approach.

Umple is a set of extensions to object-oriented languages that provides a concrete syntax for UML abstractions like associations. We argue that Umple will help increase program comprehension by allowing developers to describe a system at a more abstract level, and by reducing the volume of code.

We present some results of a survey of 113 software practitioners conducted between April and December 2007. The aim of the survey was to uncover their attitudes and experiences regarding software modeling, and development approaches that avoid modeling. We were motivated by observations that modeling is not widely adopted; many developers continue to take a code-centric approach. Key findings overall include: Modeling tools are primarily used to create documentation and for up-front design with little code generation; and participants believe that model-centric approaches to software engineering are easier but are currently not very popular as most participants currently work in code-centric environments. Key findings from sub-samples include: problems identified with model-centric approaches are similar regardless of a participant's country. Programmers that model extensively (versus those that do not model much) are more likely to agree that models become out of date and inconsistent with code.

Putting aside the marketing hype of Web2.0, a few central themes have emerged: user generated content, software to enable users (not restrict them), building a community and instant feedback. Many of these concepts can equally apply to rich client applications and a focus on software development teams. The initial motivation for Code Snippets was to fulfill the personal needs of software developers. At times, they need to reuse the same coding constructs, library access, method calls, and Web services. Recalling (or finding) this information is sometimes difficult. Drawing on similar success as online tagging libraries like del.icio.us and flickr.com, we have developed an Eclipse plug-in called CodeSnippets that allows software teams to document, store, share and search communal code to help answer the question, "How do I code that? ".

In this paper, we present a semi-automatic approach for summarizing the content of large execution traces. Similar to text summarization, where abstracts can be extracted from large documents, the aim of trace summarization is to take an execution trace as input and return a summary of its main content as output. The resulting summary can then be converted into a UML sequence diagram and used by software engineers to understand the main behavioural aspects of the system. Our approach to trace summarization is based on the removal of implementation details such as utilities from execution traces. To achieve our goal, we have developed a metric based on fan-in and fan-out to rank the system components according to whether they implement key system concepts or they are mere implementation details. We applied our approach to a trace generated from an object-oriented system called Weka that initially contains 97413 method calls. We succeeded to extract a summary from this trace that contains 453 calls. According to the developers of the Weka system, the resulting summary is an adequate high-level representation of the main interactions of the traced scenario

Summary form only given, as follows. The complete presentation was not made available for publication as part of the conference proceedings. The workshop has three objectives: To address the question: what constitutes research in software engineering education (SEE)? What areas of SEE needs to be systematically investigated? Methods of course delivery? Industrial needs? Curriculum improvement? Furthermore, how should the result of such investigation to be evaluated and most effectively organized? To address the question: what are the best outlets, beyond CSEE&T, for publishing the result of research in SEE? In particular, does the SEE community need its own SEE journal? To discuss synergy between research in SEE and research in related disciplines. What learning theories, teaching frameworks, and training practices from other disciplines can be transitioned into the SEE? We will discuss each of the above items in turn. Furthermore, we will review the researchers guide prepared for this conference. Participants will be asked to suggest improvements to it and to comment on how it has affected the quality and rigor of the research presented at the conference.

Understanding the behavior of a software system by studying its execution traces can be extremely difficult due to the sheer size and complexity of typical traces. In this paper, we propose that if various aspects that contribute to a trace's complexity could be measured and if this information could be used by tools, then trace analysis could be facilitated. For this purpose, we present a set of simple and practical metrics that aim at measuring various properties of execution traces. We also show the results of applying these metrics to traces of three software systems and suggest how the results could be used to improve existing trace analysis tools.

This paper is an overview of Software Engineering 2004, the Software Engineering volume of the Computing Curricula 2001 project. We briefly describe the contents of the volume, the process used in developing the volume's guidelines, and how we expect the volume to be used in practice.

The Software Engineering Volume is part of the IEEE-CS/ACM Computing Curricula effort that began in the fall of 1998 when a group of dedicated individuals from the IEEE Computer Society and the ACM were appointed by the two societies to begin work on what was then called Computing Curriculum 2001. This Steering Committee came to the conclusion that the area of computing had gone beyond the boundaries of computer science and that one volume would not effectively contain all of the newer areas of computing that had been developed. It was decided to split the Computing Curriculum effort into several volumes: namely, Computer Science, Computer Engineering, Software Engineering, and Information Systems volumes. The main goals of the IEEE-CS/ACM Computing Curricula effort are to provide guidance to academic institutions and accreditation agencies about what should constitute an undergraduate education in one of the aforementioned areas.

Article Share on IEEE-CS/ACM computing curricula: computer engineering & software engineering volumes Authors: John Impagliazzo Hofstra University, Hempstead, NY Hofstra University, Hempstead, NYView Profile , Esther A. Hughes Virginia Commonwealth University, Richmond, VA Virginia Commonwealth University, Richmond, VAView Profile , Richard LeBlanc Georgia Tech, Atlanta, GA Georgia Tech, Atlanta, GAView Profile , Tim Lethbridge University of Ottawa, Ottawa, Ontario, Canada University of Ottawa, Ottawa, Ontario, CanadaView Profile , Andrew McGettrick University of Strathclyde, Glasgow, United Kingdom University of Strathclyde, Glasgow, United KingdomView Profile , Ann E. K. Sobel Miami University, Oxford, OH Miami University, Oxford, OHView Profile , Pradip K. Srimani Clemson University, Clemson, SC Clemson University, Clemson, SCView Profile , Mitchell D. Theys University of Illinois at Chicago, Chicago, IL University of Illinois at Chicago, Chicago, ILView Profile Authors Info & Claims SIGCSE '04: Proceedings of the 35th SIGCSE technical symposium on Computer science educationMarch 2004 Pages 450–452https://doi.org/10.1145/971300.971453Published:01 March 2004Publication History 0citation798DownloadsMetricsTotal Citations0Total Downloads798Last 12 Months4Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access

The Software Engineering Volume is part of the IEEE-CS/ACM Computing Curriculum effort that began in the Fall of 1998 when individuals from the IEEE Computer Society and the ACM formed a Steering Committee and began work on the Computer Science Volume. This Steering Committee came to the conclusion that the area of computing had gone beyond the boundaries of computer science and that one volume could not effectively cover the newer areas that had been developed. It was decided to split the Computing Curriculum effort into several volumes; to cover Computer Engineering, Software Engineering, and Information Systems. The Steering Committee continued to work on the Computer Science Volume and appointed others to work on the other volumes.

It is widely acknowledged that group or team projects are a staple of undergraduate and graduate software engineering courses. Such projects provide students with experiences that better prepare them for their careers, so teamwork is often required or strongly encouraged by accreditation agencies. While there are a multitude of educational benefits of group projects, they also pose considerable challenge in fairly and accurately discerning individual contribution for evaluation purposes. Issues, approaches, and best practices for evaluating individual contribution are presented from the perspectives of the University of Kentucky, University of Ottawa, University of Southern California, and others. The techniques utilized within a particular course generally are a mix of (1) the group mark is everybody's mark, (2) everybody reports what they personally did, (3) other group members report the relative contributions of other group members, (4) pop quizzes on project details, and (5) cross-validating with the results of individual work.

A considerable amount of system maintenance experience can be found in bug tracking and source code configuration management systems. Data mining and machine learning techniques allow one to extract models from past experience that can be used in future predictions. By mining the software change record, one can therefore generate models that can be used in future maintenance activities. In this paper, we present an example of such a model that represents a relation between pairs of files and show how it can be extracted from the software update records of a real world legacy system. We show how different sources of data can be used to extract sets of features useful in describing this model, as well as how results are affected by these different feature sets and their combinations. Our best results were obtained from text-based features, i.e. those extracted from words in the problem reports as opposed to syntactic structures in the source code.

One of the problems in advancing the state of the software engineering discipline is the inadequate preparation of students entering the profession from undergraduate computing programs. This panel reports on the IEEE-CS/ACM Computing Curricula project and the guidance it will provide for developing undergraduate software engineering programs. In particular, the panel will address the development process used to construct the Software Engineering Volume, the contents of the first draft of the Volume, and the application of the software engineering curriculum guidelines to international curriculum models.

No abstract available.

This paper highlights the results of a survey of software professionals. One of the goals of this survey was to uncover the perceived relevance (or lack thereof) of software documentation, and the tools and technologies used to maintain, verify and validate such documents. The survey results highlight the preferences for and aversions against software documentation tools. Participants agree that documentation tools should seek to better extract knowledge from core resources. These resources include the system's source code, test code and changes to both. Resulting technologies could then help reduce the effort required for documentation maintenance, something that is shown to rarely occur. Our data reports compelling evidence that software professionals value technologies that improve automation of the documentation process, as well as facilitating its maintenance.

The IEEE/ACM CCSE initiative to propose guidelines for an undergraduate program in software engineering provides an opportunity to rethink the role of software maintenance and evolution in software engineering curricula. The purpose of this panel is to share experiences and discuss novel ways in which evolution and maintenance can be incorporated in an undergraduate software engineering curriculum.

This paper describes the application of inductive methods to data extracted from both source code and software maintenance records. We would like to extract relations that indicate which files in, a legacy system, are relevant to each other in the context of program maintenance. We call these relations maintenance relevance relations. Such a relation could reveal existing complex interconnections among files in the system, which may in turn be useful in comprehending them. We discuss the methodology we employed to extract and evaluate the relations. We also point out some of the problems we encountered and our solutions for them. Finally, we present some of the results that we have obtained.

We discuss how to extract a useful set of subsystems from a set of existing source-code file names. This problem is challenging because many legacy systems use thousands of files names, including some that are very short and cryptic. At the same time the problem is important because software maintainers often find it difficult to understand such systems. We propose a general algorithm to cluster files based on their names, and a set of alternative methods for implementing the algorithm. One of the key tasks is picking candidate words to try to identify in file names. We do this by (a) iteratively decomposing file names, (b) finding common substrings, and (c) choosing words in routine names, in an English dictionary or in source-code comments. In addition, we investigate generating abbreviations from the candidate words in order to find matches in file names, as well as how to split file names into components given no word markers. To compare and evaluate our five approaches, we present two experiments. The first compares the ‘concepts’ found in each file name by each method with the results of manually decomposing file names. The second experiment compares automatically generated subsystems with subsystem examples proposed by experts. We conclude that two methods are most effective: extracting concepts using common substrings and extracting those concepts that relate to the names of routines in the files. Copyright © 1999 John Wiley & Sons, Ltd.

We describe a study of 168 software professionals to determine how relevant their education has been to their careers. Starting with a list of 57 topics, we asked the participants to indicate how much they learned in university, how much they know now, how useful the material has been and whether they would like to learn more. We conclude from the results that certain software engineering topics should be given more emphasis, while the emphasis on certain mathematics topics should be changed.

Decomposing complex software systems into conceptually independent subsystems is a significant software engineering activity which received considerable research attention. Most of the research in this domain considers the body of the source code; trying to cluster together files which are conceptually related. We discuss techniques for extracting concepts (abbreviations) from a more informal source of information: file names. The task is difficult because nothing indicates where to split the file names into substrings. In general, finding abbreviations would require domain knowledge to identify the concepts that are referred to in a name and intuition to recognize such concepts in abbreviated forms. We show by experiment that the techniques we propose allow about 90% of the abbreviations to be found automatically.

Metrics are widely researched and used in software engineering; however there is little analogous work in the field of knowledge engineering. In other words, there are no widely-known metrics that the developers of knowledge bases can use to monitor and improve their work. In this paper we adapt the GQM (Goals-Questions-Metrics) methodology that is used to select and develop software metrics. We use the methodology to develop a series of metrics that measure the size and complexity of concept-oriented knowledge bases. Two of the metrics measure raw size; seven measure various aspects of complexity on scales of 0 to 1, and are shown to be largely independent of each other. The remaining three are compound metrics that combine aspects of the other nine in an attempt to measure the overall 'difficulty' or 'complexity' of a knowledge base. The metrics have been implemented and tested in the context of a knowledge management system called CODE4.

This paper discusses an undergraduate option in software engineering which is currently in the approval process at the University of Ottawa. The proposed option represents a close collaboration between the Department of Computer Science and the Department of Electrical and Computer Engineering. In this paper we present an analysis of the weaknesses of the graduates of existing programs and some criteria for the choice of courses in the new option. In particular, we examine why a significant amount of additional project-based experience should be required in the software engineering option. The resulting option differs from those at other universities in that it has a somewhat greater emphasis on both human factors and the object oriented approach.