Self-Explanatory Objects: An Investigation of Object-Based Help

The thesis describes an investigation of on-line help provision for computer systems that have graphical object-oriented interfaces. It concentrates on object-based help facilities and describes the development of a method for obtaining object-based help information and the identification of useful types of object-based help information. The thesis demonstrates that it is both possible and practical to obtain object-based help information from the code of an appropriately programmed main system, and it describes observational studies that showed the usefulness of some types of object-based help information. The approach that was taken involved implementing two systems in object-oriented programming styles. Both systems have graphical object-oriented interfaces' and object-based help facilities. The object-based help facilities provide information about the objects displayed by the interfaces when the display objects are indicated. The object-based help information is drawn from system objects which are coded components of the systems. This method is practical when there are one-to-one correspondences between display objects and the system objects that generate and maintain them. The term 'self-explanatory objects' denotes system objects that have been written to be used as a source of object-based help information in this way. The first system is a simple proof-of-concept prototype in the form of a noughts and crosses game. The second system, a game of strategy called Partickles, includes both object-based and menu-based help. The usage of Partickles' help facilities was investigated in a series of three successive studies conducted with a total of nineteen school students aged 12 to 18. Evidence from the studies has shown the usefulness of menu-based overviews and reference facilities, and of object-based help information that explains what display objects would do if activated in the current context. The results include suggestions for implementing help facilities based on self-explanatory objects, a set of guidelines for the provision of help in systems that have graphical object-oriented interfaces, a framework for the provision of object-based help and four types of information that can be used as a template for object-based help messages

The automatic generation and execution of Lean Cuisine+ specifications : a thesis presented in partial fulfilment of the requirements for the degree of Master of Information Science in Computer Science at Massey University

Lean Cuisine+ (Phillips, 1995), a semi-formal graphical dialogue notation for describing the behaviour of event based direct manipulation GUIs, was developed at Massey University in the early 1990s. More recently, a software environment, SELCU (Scogings, 2003) has been built for Lean Cuisine+ which permits dialogue models to be manually constructed and edited using a drag and drop approach. The aim of the research presented in this thesis is to develop extensions to SELCU, which include the automatic generation of Lean Cuisine+ diagrams, and their execution. A shortcoming of current prototyping tools and user interface builders is that although they permit the designer to construct a mock up of the look and feel of the interface, they provide no model of the interaction. The Auto-Generation Software is a tool which can automatically generate a Lean Cuisine+ diagram for a graphical user interface developed using Delphi. The generated description is represented as a text file, and in a format compatible with the SELCU system. The Lean Cuisine+ Execution Environment is embedded in the SELCU application. It supports the execution of Lean Cuisine+ specifications, including meneme selection and task action sequence, and also takes account of triggers. The SELCU extensions successfully integrate a graphical dialogue notation (Lean Cuisine+), an object oriented development environment (Delphi), and an existing support environment (SELCU). This offers a more complete environment for the early stages of the design of graphical user interfaces

Introducing OO concepts from a class user perspective

The use of an object-oriented language as an introductory language is becoming more widespread (Biddle & Tempero, 1998). However, pedagogical issues relating to the incorporation of such a language are still not understood properly (Kolling, 2001). Approaches to incorporating an object-oriented language into a teaching program vary greatly. Some approaches avoid the issue of object-orientation by putting emphasis on the procedural aspects of the language (Koffman & Wolz, 1999). Others approach the subject from the perspective of a class developer, especially making use of the appeal graphical user interfaces and applets have for students. The approach that we take at the University of Ballarat is to introduce students to programming from the perspective of a class user. This approach is facilitated by the availability of BlueJ (Kolling & Rosenberg, 2001), a program development environment designed explicitly for teaching object-oriented principles using Java. This paper describes this approach and the students' reactions to it

Object-Oriented Modeling and Design Using DELTA, an Incremental Design Language.

Object-oriented technology has opened the doors for many new ideas in system development. The object-oriented paradigm has produced many new object-oriented programming languages. As with any new methodology, a need for formalism arises to remove ambiguities and inconsistencies and to bring a sense of continuity to software design. Formal languages provide a sound basis for software development throughout the software life cycle. This work presents a set of characteristic features for object-oriented design languages and defines a formal object-oriented design language, DELTA. The rapidly changing face of software has led to an ever increasing need to update out-of-date methods and user interfaces. Software developers want to be able to use the same type of visual interfaces available in application software. The introduction of windowing environments has led to a market for methodologies which incorporate graphical features to supplement textual components of software. The present genre of formal languages must evolve in the same direction to be considered as effective in the design process. DELTA meets this need by providing a modern development environment with graphical features to complement the text that is necessary in any design specification. Researchers and prominent software engineers have provided a litany of object-oriented methodologies. The commonality of these methods is the step-by-step approach to software development. Software engineers agree in theory that the best approach to designing software which will stand the test of time is one which has a sound established discipline. Such a discipline produces a design in incrementations. DELTA supports this theory by providing established levels of incremental design representation. The advent of computer-aided design has led to the evolution of rapid-prototyping. Changes in system requirements, detection of errors, competition in the market, and the ongoing maintenance of software systems can be addressed by the development of system prototypes. DELTA responds to this challenge by establishing a design specification representation which can be easily mapped to an object-oriented programming language. This transition from design to prototype can be enhanced by formal annotations to the chosen implementation language. Annotations have been developed for DELTA software designs prototyped in the object-oriented language Actor

Development of a client interface for a methodology independent object-oriented CASE tool : a thesis presented in partial fulfilment of the requirements for the degree of Master of Science in Computer Science at Massey University

The overall aim of the research presented in this thesis is the development of a prototype CASE Tool user interface that supports the use of arbitrary methodology notations for the construction of small-scale diagrams. This research is part of the larger CASE Tool project, MOOT (Massey's Object Oriented Tool). MOOT is a meta-system with a client-server architecture that provides a framework within which the semantics and syntax of methodologies can be described. The CASE Tool user interface is implemented in Java so it is as portable as possible and has a consistent look and feel. It has been designed as a client to the rest of the MOOT system (which acts as a server). A communications protocol has been designed to support the interaction between the CASE Tool client and a MOOT server. The user interface design of MOOT must support all possible graphical notations. No assumptions about the types of notations that a software engineer may use can be made. MOOT therefore provides a specification language called NDL for the definition of a methodology's syntax. Hence, the MOOT CASE Tool client described in this thesis is a shell that is parameterised by NDL specifications. The flexibility provided by such a high level of abstraction presents significant challenges in terms of designing effective human-computer interaction mechanisms for the MOOT user interface. Functional and non-functional requirements of the client user interface have been identified and applied during the construction of the prototype. A notation specification that defines the syntax for Coad and Yourdon OOA/OOD has been written in NDL and used as a test case. The thesis includes the iterative evaluation and extension of NDL resulting from the prototype development. The prototype has shown that the current approach to NDL is efficacious, and that the syntax and semantics of a methodology description can successfully be separated. The developed prototype has shown that it is possible to build a simple, non-intrusive, and efficient, yet flexible, useable, and helpful interface for meta-CASE tools. The development of the CASE Tool client, through its generic, methodology independent design, has provided a pilot with which future ideas may be explored

Knowledge-based Expressive Technologies within Cloud Computing Environments

Presented paper describes the development of comprehensive approach for knowledge processing within e-Sceince tasks. Considering the task solving within a simulation-driven approach a set of knowledge-based procedures for task definition and composite application processing can be identified. This procedures could be supported by the use of domain-specific knowledge being formalized and used for automation purpose. Within this work the developed conceptual and technological knowledge-based toolbox for complex multidisciplinary task solv-ing support is proposed. Using CLAVIRE cloud computing environment as a core platform a set of interconnected expressive technologies were developed.Comment: Proceedings of the 8th International Conference on Intelligent Systems and Knowledge Engineering (ISKE2013). 201

Business-oriented development of telecommunication services

The development of software for distributed systems, e.g. telecommunication services, is a complex activity. Numerous issues have to be resolved when developing such systems, examples of which are language/system heterogeneity and remoteness of components. Interface definition languages (IDLs) are used as the basis for addressing some of these issues. IDLs allow for the specification of the syntactic aspects of the interfaces of the components in the system to be made. Whilst lending itself to issues of heterogeneity and location transparency, dealing with IDL as the basis for system development is not without its problems. Two of the main problems with IDL are its lack of behaviour and its lack of abstraction. Thus designers should not be constrained to work within the syntactic notations used to implement their systems, nor should they be unaided in how they might better design their systems. In this paper we show how these issues are being addressed in the TOSCA project in its development of a service creation and validation environment

Engineering telecommunication services with SDL

If formal techniques are to be more widely accepted then they should evolve as current software engineering approaches evolve. Current techniques in the development of distributed systems use interface definition languages (IDLs) as a basis for the underlying communication and also as an abstraction tool. Object-oriented technologies [6] and the idea of engineering software through frameworks [5] are also widely accepted approaches in developing software. In this paper we show how the formal specification language SDL and associated tool support have been applied in the TOSCA1 project to engineer telecommunication services using these current techniques