Object-oriented Development Environment Research Articles

The Design and Implementation of Network Assistant System for Physical Education

Sports teaching is a bilateral teaching activity, reflected in the process of the practice is very significant, the teaching process teachers should also carry out explanation and demonstration, through the vivid teaching methods to deepen students’ understanding, so that students have a higher and more comprehensive quality, adapt to future sports training and teaching, teaching more advanced the content of training and scientific research and management. The sports network teaching system in this paper, is based on the campus network, the Internet and other hardware based, and the efficiency of the network to play out, spread and the use of network teaching new teaching mode in the real sense, it is at this stage the industry needs to pay great attention to the problem and the solution. This paper describes the teaching effect of computer network technology in the sports teaching, and then combined with the specific application, detailed analysis of user needs; put forward the development scheme of PE teaching network aided system and Realization method. This system adopts the three layer system structure, good scalability, using modular design method, which is divided into teaching resources, online answering, course work and examination of four functional modules, easy to select the object-oriented ASP programming language, development environment and SQL Server database system extended the implementation of these key technologies include file upload processing technology, Active X programming technology and application, the file upload component development technology etc.

Formalizing UML/OCL structural features with FoCaLiZe

Unified Modeling Language (UML) is the de facto standard for the development of software models, and Object Constraint Language (OCL) is used within UML models to specify model constraints. Several UML/OCL tools provide Model-Driven Engineering transformation into general object-oriented programming languages such as Java and C++. But the latter did not provide mechanisms for the specification and the verification of OCL constraints. In this context, formal methods are largely used for the specification of UML/OCL models and the verification of their OCL constraints. However, the divergence between UML (object-oriented modeling) and formal methods (mathematical- and logical-based tools) leads in general to ignore most UML/OCL architectural and conceptual features such as OCL constraints simple and multiple inheritance, late binding, template binding and dependencies. To address the formalization of these features, we have used FoCaLiZe, an object-oriented development environment using a proof-based formal approach. More precisely, we propose a formal transformation of the essential UML/OCL features into FoCaLiZe specifications. The derived formal model reflects perfectly the structural features of the original UML/OCL model. In addition, it is possible to check and prove model properties using Zenon, the automatic theorem prover of FoCaLiZe.

Modelling UML state machines with FoCaLiZe

UML and OCL are largely adopted as a standard to describe the static and the dynamic aspects of systems and to specify their properties. Model driven engineering (MDE) techniques can be used to automatically generate code from such models. For critical systems, formal methods are frequently used together with UML/OCL models in order to analyse and check model properties. In this paper, we propose a combination of UML/OCL and FoCaLiZe, an object-oriented development environment using a proof-based formal approach. More specifically, we propose a formal transformation of UML state machines conditioned with OCL constraints into FoCaLiZe specifications that can be refined to generate executable code. The proposed transformation supports communication between a class structure and its state machine. Thanks to Zenon, the automatic theorem prover of FoCaLiZe, errors of the original UML/OCL model, if any, are automatically detected. We illustrate our translation with a concrete case study.

Modelling UML state machines with FoCaLiZe

UML and OCL are largely adopted as a standard to describe the static and the dynamic aspects of systems and to specify their properties. Model driven engineering (MDE) techniques can be used to automatically generate code from such models. For critical systems, formal methods are frequently used together with UML/OCL models in order to analyse and check model properties. In this paper, we propose a combination of UML/OCL and FoCaLiZe, an object-oriented development environment using a proof-based formal approach. More specifically, we propose a formal transformation of UML state machines conditioned with OCL constraints into FoCaLiZe specifications that can be refined to generate executable code. The proposed transformation supports communication between a class structure and its state machine. Thanks to Zenon, the automatic theorem prover of FoCaLiZe, errors of the original UML/OCL model, if any, are automatically detected. We illustrate our translation with a concrete case study.

An object-oriented development environment to optimally design cyclic storage systems

Cyclic storage system (CSS) is defined as physically interconnected and operationally integrated surface water and groundwater subsystems with full direct interactions between the subsystems. Mathematical development and implementation of a CSS model is very complex and all previous works are fully case dependent with a minimum possibility of generalization. This article proposes an integrated development environment called CSSDev, which assists researchers to create and design object-oriented CSS models more easily. Using CSSDev, researchers may skip regeneration of repetitive simulation codes for common elements of a CSS. CSSDev employs NSGA-II to optimally select the design parameters of the models. Two objective functions of the optimization problem are system's total costs and total loss associated with the development alternatives. A real-world large-scale CSS has been modeled and optimized to illustrate the performance of CSSDev. The final Pareto-front is presented and two selected solutions from the set of optimal non-dominated ones are evaluated and discussed.

Editorial

Our first paper in this issue of the ISJ investigates the possibilities and constraints of ubiquitous computing technology on an organization, and explains these impacts using the value chain model and the value constellation model. As a form of newly emerging technology, ubiquitous computing has raised a new research direction for information systems (IS) researchers, and social scientists more generally, to explain organization forms and the business models enabled by ubiquitous computing. The study of Katrin Jonsson, Ulrika Westergren and Jonny Holmström (Jonsson et al., 2008) uses semi-structured interviews as the primary means of data collection, and open, axial and selective coding techniques are used to code the interview data. This relates to remote diagnostics systems in a manufacturing company that proved to be an early adopter of this technology. The value chain model is focused on the internal activities of the firm, while the value constellation model is focused on empowering customers to create value for themselves. The discussion provides valuable insights for this company as well as showing how the ubiquitous information environment can have an impact that stretches beyond single organizations. The topic is new, interesting and important, and the empirical study data provided in this paper is especially valuable. Whereas information technology (IT) innovation research has examined the organizational and technological factors that determine IT adoption and diffusion, including firm size and scope, technological competency and expected benefits, the paper of Nigel Melville and Ronald Ramirez (Melville & Ramirez, 2008) extends the literature by focusing on information requirements as a driver of IT innovation adoption and diffusion. In their study, two industries (wood products and beverage manufacturing) provide empirical background, and the paper focuses on how supply chain characteristics (process complexity, clock speed and supply chain complexity) determine information processing requirements. The authors show that these, in turn, influence the development of IT capabilities and the rate and scale of IT innovation adoption. The comparison across the two industries illustrates the usefulness of the developed model. The authors conclude that the model shows that information processing requirements are a major influence on whether companies choose to be early and deep adopters of new technology. Teresa Shaft, Leslie Albert and Jon Jasperson (Shaft et al., 2008) help us understand the complicated cognitive transition of IS developers as they change from a structured to an object-oriented development environment in order to take advantage of the ease of development and maintenance and support for software reuse claimed by object-oriented development. Four hypotheses are developed in the research, and these are tested through a longitudinal study of a team of eight software developers going through this transition at an international petroleum company engaged in the firm's pilot object-oriented development project. The researchers utilize a multi-method approach that incorporates in-person group interviews, email logs and responses to a survey instrument. This field-based study of an IS development project provides many insights. Interestingly, one conclusion is that knowledge of structured development is positively related to knowledge of object-oriented development. This contradicts the often-cited notion that structured development needs to be unlearned in order to learn object-oriented concepts. Our last paper, by Ernst Kesseler (Kesseler, 2008), explores the issue of how to deploy commercial off-the-shelf (COTS) software in safety-critical domains. The deployment of COTS software should bring with it low costs and shorter time-to-market, but an organization within the safety-critical domain is targeted in this study as this domain is known for its rigid regulations and slow introduction of new technology. In his paper, the author argues for the technical feasibility of COTS software and its general relevance for safety-critical domains, yet in exploring the development and implementation of a COTS-based prototype in the civil air transport industry, the expected benefits did not occur; indeed, in comparison with custom-made software, the COTS-based software took both a longer time to develop and was more expensive in terms of resources. The author discusses management style and team communication to explain this result, at least in part.

A programming environment for the development of modular 3D biomedical image processing applications

ImageLib is a free object-oriented development environment destined to biomedical image processing. The software package contains a programming library (C++ language) and an MDI user interface (kernel). The major interest is to allow the creation of fully modular applications. Both user processing functions and image read/write facilities are separately compiled as DLLs, and the resulting plugin objects are dynamically imported into the kernel. The library provides all the required wrapping material to incorporate all find of image processing functions into user-written components. A rapid prototyping application is provided to communicate with the kernel communication interface. No graphics programming skills is required to manage advanced user interactions, image display (e.g. OpenGL), and generic image processing functions based on C++ templates. The component-oriented software architecture makes it possible to share image processing and handling resources for light Windows processing applications.

Customisation of industrial training through standardised databases and object-oriented development environments

Currently, companies operate on a global basis, emphasising horizontal integration, innovation and customer satisfaction, while just focusing on the small number of business areas. Therefore, continuous personnel training is a vital part of the competitiveness. In this paper, we will introduce how business game, operating in a real time, through local area networks, could be customised for industrial training purposes. Items/tools such as standardised databases, information exchange and object-oriented programming have enabled the development of this application. According to our empirical results, we argue that companies are not necessarily only interested in directly copying their operations in a form of a business game, but have an interest in the same type of decisions and problems to be dealt during the training sessions.

Weathering MindStorms with drizzle and DIODE in CS0

We introduce Drizzle, our new simple object-oriented scripting language for programming LEGO MindStorms robots, and DIODE, the Drizzle Integrated Object-Oriented Development Environment. Drizzle and DIODE have evolved from a student project into useful resources for our CS0 course. In this work we describe Drizzle and DIODE and discuss our experiences with them in our CS0 course.We are dismayed by the low retention rates of undergraduate majors in CS1 and CS2. To attempt to alleviate this problem, we introduced a new required CS0 course in Fall 2004. Its goals are to give students a breadth-first overview of CS and to expose them to algorithmic problem solving before immersing them in Java. We decided to use the MindStorms robots to accommodate student diversity, to introduce a fun element to the course, and to force the students to focus on problem analysis instead of detailed syntax. Our approach complements [2].Drizzle is a simple object-oriented scripting language. It supports repetition, selection, simple assignment statements, logical operators, numeric variables, and predefined objects representing components of a robot, i.e., sensors, motors, and the LCD display. Drizzle is purposely minimal to be suitable for students without prior programming experience. To encourage documentation, Drizzle supports comments.DIODE is the IDE that allows a MindStorms robot to be programmed in Drizzle. To achieve this, we used the leJOS API [3] to implement method call abstractions supporting the predefined objects. The IDE includes an intuitive GUI. It allows for automatic compilation of Drizzle code, including a translator from Drizzle to Java utilizing the predefined MindStorms objects. DIODE also directly interfaces to the robot's IR device. We provided these features because our typical user was familiar with text editing but was not familiar with command-line tools.Our CS0 course is currently taught in one 120-student section and meets 3 hours per week for 14 weeks. At least 3 hours are spent on each of algorithmic thinking and concepts of programming languages before Drizzle and DIODE are formally presented. The students see an actual problem with pseudocode and the corresponding Drizzle solution. A problem is then posed as a "Drizzle Team Challenge". Students must complete individual solution plans. The instructor then forms the student groups. Next, the teams produce solution plans. Finally, they are allowed to program with the actual robot. The lab has 3 computers with DIODE installed and 6 robots with 6 tracks. During the Fall 2004 offering, the 14 teams consisted of between 5 and 8 students. The large class size and small number of robots made smaller groups infeasible. No team solved the problem totally correctly during the first lab session. Not surprisingly, the smaller groups were more effective. All teams submitted at least a partial solution to the problem; 12 completed the solution. Students were excited about working with the robots.We are using Drizzle (and DIODE) again during Spring 2005. We expect to have smaller groups. We hope to evaluate the effectiveness of Drizzle; some possible approaches are additional questions in the course evaluation, surveys at the beginning and end of CS1, and analyses of CS1/CS2 retention rates. We may also compare the usage of Drizzle with the standard MindStorms approach and Alice [1].

Java Distributed Separate Objects.

Java supports distributed programming using threads and Remote Method Invocation (JRMI). However, a Java thread does not match well with the object concept, and JRMI cannot easily used to synchronize distributed objects. This work proposes a more object oriented model for concurrent and distributed programming using the notion of separate objects. Separate objects are asynchronous objects maybe running on different processors. These objects are also used for synchronization. The presented approach should encourage more seamless designs. The implementation is supported by JOODE (Java Object Oriented Development Environment) which supports the use of an adaptable platform of a net of processors.

Automatic derivation of software performance models from CASE documents

Lifecycle validation of software performance (or prediction of the product ability to satisfy the user performance-requirements) is based on the automatic derivation of software performance models from CASE documents or rapid prototypes. This paper deals with the CASE document alternative. After a brief overview of existing automatic derivation methods, it introduces a method that unifies existing techniques that use CASE documents. The method is step-wise clear, can be used from the early phases of the software lifecycle, is distributed-software oriented, and can be easily incorporated into modern (e.g., UML-based) CASE tools. The method enables the software designer with no specific knowledge of performance theory to predict at design time the performance of various final product alternatives. The designer does only need to feed the CASE documents into the performance model generator. The paper carries on an application case study that deals with the development of distributed software, where the method is used to predict the performance of different distributed architectures the designer could select at preliminary design time to obtain the best performing final product. The method can be easily incorporated into modern object-oriented software development environments to encourage software designers to introduce lifecycle performance validation into their development best practices.

Grainger Engineering Library: An Object-Enhanced User Interface for Information Retrieval

Summary Telnet and HTML-based information retrieval user interfaces provide searchers with neither the power nor the flexibility required for effectively searching multiple databases. Nor do they exploit the existing power of PCs or make good use of client-server technology as a whole. lODyne is an example of an information retrieval client that views databases and queries as objects which you can combine arbitrarily. It has a commandless, hypertextual user interface incorporating modelessness, direct manipulation, feedback, and object persistence. It uses multiple windows to show multiple views of databases simultaneously, and allows you to arbitrarily juxtapose these views. Besides bibliographic retrieval, lODyne provides navigational tools for subject thesauri, classification systems, keyword-in-context (KWIC) databases, and other term suggestion services, represented as distributed objects which are all integrated into a seamless drag-and-drop environment. Persistent representations of sets of queries and repositories can be saved and shared among lODyne users. 10-Dyne demonstrates that, with recent advances in computer and network hardware, as well as object-oriented development environments, entire information systems can be designed around the needs of users rather than the limitations of technology.

BlackBox

This paper describes the BlackBox framework, an object-oriented application development environment, and our experience with its use over the past several years in the CS1/CS2 course. This little-known framework features: (1) a graphical user interface that is simple enough for beginning students to program, (2) true cross-platform capability, (3) guaranteed memory-safe pointers with automatic garbage collection, (4) a new language, Component Pascal, that combines the best of Java and Pascal, (5) fast, native-code compilation, and (6) lowest possible cost (free to educational users). The paper concludes with a guide to further resources for those who wish to pursue this promising new framework in their curricula for the first year.

Object oriented representation of design decisions

During the course of a design project numerous design decisions are made, usually with little attention paid to documenting them or keeping track of them. Systematic documentation and representation of design decisions can not only be invaluable in learning from past design experiences, but can also be good tools in teaching architectural design. By using abstraction and analogy to analyze a design precedent, a problem/sub-problem hierarchy can be built where similarities and differences between the precedent problem and the target problem, goals, constraints and solutions are identified for each level of the hierarchy. Each one of these can be represented as objects in an object oriented programming environment, allowing the construction of a hierarchic structure. This model was incorporated into a computer assisted learning system called `DesignRep' which was created by using Toolbook® (Asymetrix) object oriented development environment.

Implementing reusable, instrument independent test programs in the factory

Development of computer programs that control test sequences on Automatic Test Equipment (ATE) is costly and time consuming. Test Programs are usually written by specifying the instruments to be used in the ATE and the sequence of the setup and measurement parameters for these instruments. Reuse of test program software on other ATE is usually not possible without rewriting, revalidating and re-releasing the programs. This paper describes an implementation of a test program software development system and a standard of software runtime architecture used in our factories. The object-oriented development environment and its associated class libraries allow test programs to be written without knowledge of the ATE on which they will be run. Two main principles guided the design: the software architecture was based on recognized formal and industry standards; and our implementation used commercial off-the-shelf software products when possible. Emerging standards such as the IEEE-1226 (ABBET) as well as defacto industry standards including VXI Plug and Play have made our implementation possible. The current draft of the ABBET and P&P standards do not promote this instrument independence, but it is hoped that this will be added as the standards mature. Three immediate benefits are: cost savings that result from reusing validated test programs; cycle time reductions that result from concurrently developing test program software and ATE; and software defect reductions that result from using proven software.

Eco System: an Internet commerce architecture

Robust electronic commerce will require several proprietary systems to interoperate. CommerceNet is proposing Eco System, a cross industry effort to build a framework of frameworks, involving both e-commerce vendors and end users. Eco System will consist of an extensible object oriented framework (class libraries, application programming interfaces and shared services) from which developers can assemble applications quickly from existing components. These applications could subsequently be reused in other applications. We are also developing a Common Business Language (CBL) that lets application agents communicate using messages and objects that model communications in the real business world. A network services architecture (protocols, APIs, and data formats) will insulate application agents from each other and from platform dependencies, while facilitating their interoperation. Functionally, Eco System fills three distinct roles. It is: a layer of middleware that facilitates agent interoperation through services such as authentication, billing, payment, and directories; an object oriented development environment that encourages the reuse of e-commerce modules (even modules that represent the product line of an entire company); and an industry roadmap and interoperability example that promotes open standards and helps technology vendors communicate with end users about product features.

An IDSS development environment based on consistent language

This paper describes the architecture of an object-oriented and open intelligent decision support system (IDSS) development environment (IDSS DE), in which parts of the IDSS system can be integrated consistently. A consistent objectoriented representation language, Knonit, is proposed. Its concept, grammar, execution and other major characteristics are discussed as well.

A Framework for the Object-Oriented Design and Simulation of Information System Dynamics

A framework for the object-oriented (00) design and simulation of information system (IS) dynamics is proposed, supported by an object-oriented simulation (OOS) mapping tool and a prototype object-oriented integrated development environment (OOIDE). The objective is to make the design and simulation of IS design dynamics a common and integral part of the 00 systems development process by implementing the framework within an integrated and computer-aided systems development environment. The framework proposes a series of steps to follow for the developer who has decided to look at the dynamics of an information system's (IS) logical design and is using an 00 methodology for the development of the new system. The use of the framework, the OOS mapping tool and the prototype OOIDE are validated using an existing IS.

Overview of an Industrial Inspection Workbench

This paper describes an industrial-based research project which is developing a flexible machine vision workbench environment for the rapid-prototyping of real-time industrial inspection systems. This will provide for the rapid configuration of systems by an engineer and, using novel verification techniques, allow rapid assessment of candidate solutions. The objective is to support the development of advanced machine vision systems which offer a high degree of reliability, together with known logical and temporal performance. The whole project has been designed using Rumbaugh's OMT methodology and has been developed using Kappa - an object-oriented development environment with an integral inference engine. All designs and code were generated in compliance with international standards.This paper provides an in-depth look at the functionality of the system, and what benefits it provides to "real" engineers.

An object-oriented program development environment for the first programming course

Over the last ten years there has been a major shift in programming language design from procedural languages to object-oriented languages. Most universities have adopted an object-oriented language for their first programming course. However, far less consideration has been given to the program development environment. In this paper we argue that the environment is possibly more important than the language and existing environments fail to fully support the object-oriented paradigm. We describe a new program development environment and show how it has been specifically designed to support object-oriented design and programming.