242,503 research outputs found
A general framework for positioning, evaluating and selecting the new generation of development tools.
This paper focuses on the evaluation and positioning of a new generation of development tools containing subtools (report generators, browsers, debuggers, GUI-builders, ...) and programming languages that are designed to work together and have a common graphical user interface and are therefore called environments. Several trends in IT have led to a pluriform range of developments tools that can be classified in numerous categories. Examples are: object-oriented tools, GUI-tools, upper- and lower CASE-tools, client/server tools and 4GL environments. This classification does not sufficiently cover the tools subject in this paper for the simple reason that only one criterion is used to distinguish them. Modern visual development environments often fit in several categories because to a certain extent, several criteria can be applied to evaluate them. In this study, we will offer a broad classification scheme with which tools can be positioned and which can be refined through further research.
Process-Oriented Parallel Programming with an Application to Data-Intensive Computing
We introduce process-oriented programming as a natural extension of
object-oriented programming for parallel computing. It is based on the
observation that every class of an object-oriented language can be instantiated
as a process, accessible via a remote pointer. The introduction of process
pointers requires no syntax extension, identifies processes with programming
objects, and enables processes to exchange information simply by executing
remote methods. Process-oriented programming is a high-level language
alternative to multithreading, MPI and many other languages, environments and
tools currently used for parallel computations. It implements natural
object-based parallelism using only minimal syntax extension of existing
languages, such as C++ and Python, and has therefore the potential to lead to
widespread adoption of parallel programming. We implemented a prototype system
for running processes using C++ with MPI and used it to compute a large
three-dimensional Fourier transform on a computer cluster built of commodity
hardware components. Three-dimensional Fourier transform is a prototype of a
data-intensive application with a complex data-access pattern. The
process-oriented code is only a few hundred lines long, and attains very high
data throughput by achieving massive parallelism and maximizing hardware
utilization.Comment: 20 pages, 1 figur
Strategic Directions in Object-Oriented Programming
This paper has provided an overview of the field of object-oriented programming. After presenting a historical perspective and some major achievements in the field, four research directions were introduced: technologies integration, software components, distributed programming, and new paradigms. In general there is a need to continue research in traditional areas:\ud
(1) as computer systems become more and more complex, there is a need to further develop the work on architecture and design; \ud
(2) to support the development of complex systems, there is a need for better languages, environments, and tools; \ud
(3) foundations in the form of the conceptual framework and other theories must be extended to enhance the means for modeling and formal analysis, as well as for understanding future computer systems
Recommended from our members
Object-oriented views: a novel approach for tool integration in design environments (dissertation)
Object-oriented databases have been proposed to serve as the data management component of integrated design environments. One central database represents a bottleneck, however, requiring all design tools to work on the same information model and preventing the extensibility of the system over time. In this dissertation, I propose a view-based object server that successfully addresses these problems by supporting design views tailored to the needs of individual design tools.A view on an object-oriented schema corresponds to a virtual subschema graph with restructured generalization and property decomposition hierarchies. I present a methodology for supporting multiple view schemata, called MutliView. MultiView is anchored on the following four ideas: (1) the customization of individual classes using object algebra, (2) the integration of these derived classes into one global schema graoh, (3) the extraction of virtual and base classes from the global schema as required by the view, and (4) the generation of a class hierarchy for these selected view classes. MutliView's division of view specification into these well-defined tasks, some of which have been successfully automated, makes it a powerful tool for supporting the specification of views by non-database experts while enforcing view consistency.In this dissertation, I describe solutions for all four tasks underlying MultiView. For the first task, I have formulated class derivatin operators modeled after the well-known relational algebra operators. For the second task, I have developed a classification algorithm that automatically integrates derived classes into one global schema. For the third task, I have designed a view definition language that can be used to declaratively specify the view classes required for a particular view. For the last task, I have developed an algorithm that generates a complete, minimal and consistent view schema. I present proofs of correctness, complexity analysis, and numerous illustrative examples for all algorithms.MultiView is applied to address the tool integration problem in a behavioral synthesis system. For this purpose, I first develop a unified design object model for behavioral synthesis. I then formulate customized design views of this model tailored to the needs of particular design tools. The resulting system allows the design tools to work on their view of the information model, while MultiView assures the consistent integration of the diverse design data into one object model
Case-Based Reasoning Tools from Shells to Object-Oriented Frameworks
A Case-Based Reasoning (CBR) tool is software that can be used to develop several applications that
require cased-based reasoning methodology. CBR shells are kind of application generators with graphical user
interface. They can be used by non-programmer users but the extension or integration of new components in
these tools is not possible. In this paper we analyzed three CBR object-oriented framework development
environments CBR*Tools, CAT-CBR, and JColibri. These frameworks work as open software development
environment and facilitate the reuse of their design as well as implementations
Employing Object Technology to Expose Fundamental Object Concepts
We explore technical issues in the design of programming tools, development environments, simulations, code examples, user interface frameworks and pedagogies for a university-level course on object-oriented software development. The course, M206 Computing: An Object-Oriented Approach has been specifically developed for distance learning, and is enrolling over 5,000 students per year (average age 37) in the UK, Europe and Singapore. The course introduces computing via an object-oriented approach. M206 is substantial in extent representing one sixth of a degree. It embodies a practical, industry oriented view of computing and includes programming, analysis, design and group working. Considerable effort has been invested in making the simplicity, consistency and power of object technology accessible to and capable of being applied by beginners. A diverse set of educational media, such as CD-ROMs, TV and the Web, have been deployed as learning resources. We describe the agenda for the course; its object-oriented pedagogy and our strategy for delivery. We explain measures taken to avoid misconceptions about objects, our analysis and design method, and the Smalltalk programming environment we have developed specifically for learners and which is crucial to our approach. We outline how our adherence to the separation of view and domain model leads to technical innovations. Concluding remarks reflect on the benefits a reflexive strategy, both in education and training
From Alice to BlueJ: a transition to Java.
The teaching of introductory courses in computing has seen several changes over the last decade. These changes not only affected the curricula when the emphasis was shifted from Imperative (also Procedural) to Object-Oriented Programming (OOP) but also reignited debates regarding which is the better programming language. Furthermore, the shift in emphasis also has encountered challenges with the object-oriented pedagogy. More recently, the assessment procedure for how students are learning object-oriented concepts has been given attention. When the programming language Java was adopted to teach object-oriented programming, it was not without difficulties. Various studies cited the development environment for Java, which was designed for professional programmers and its complex syntax structures as the main source of Javas difficulties (Kolling & Rosenberg 2001). The studies were not only limited to identifying the problems of teaching and learning Java but they also identified solutions. One of these included the creation of programming tools and environment to help novice programmers learn object-oriented concepts effectively. Among the integrated development environments created for teaching object-oriented programming using Java is BlueJ. Another programming tool for teaching object-oriented programming is Alice. The technology of animated program visualization keeps the focus on objects while teaching about behaviour and state (Dann et al 2003). The study concerns how the different programming tools help students in learning object-oriented concepts. One is classified as a text-based tool, BlueJ, and the other is graphical-based tool, Alice. There are three main questions for this study: 1. Does the process of learning object-oriented concepts using graphical-based tools differ from using text-based tools? 2. Do graphical-based tools support text-based tools in learning object-oriented concepts? 3. Do graphical-based tools offer more help in understanding object-oriented concepts than text-based tools? To answer the questions, the researcher conducted a survey whereby two sets of questionnaires were distributed to the students of Robert Gordon module entitled Object-Oriented Programming Techniques (CM1011). The student respondents found significant difference in the use of the graphical-based and text-based programming tools in understanding the following object-oriented concepts: Message Passing, Encapsulation and Polymorphism. The data gathered were also indicative that a graphical-based programming tool like Alice is helpful in learning object-oriented concepts with the use of a text-based programming tool like BlueJ. Whether graphical tools like Alice help more in understanding object-oriented concepts than text-based tools like BlueJ was inconclusive. The initial study suggests that there was no significant difference with students confidence in learning the various object-oriented concepts using the programming tools. The student respondents appeared to recognise that both programming tools are useful in learning various object-oriented concepts. However, it seems that they expected Alice to be a more sophisticated animation tool and that the animations produced would be of a cinematic calibre. The study aspires to contribute to the improvement of the object-oriented pedagogy. Specifically, it aims to contribute in the development of teaching methodologies for object-oriented programming and then create learning strategies for object-oriented programming and, not to forget, make the assessment of object-oriented programming more effective and suitable. Alongside the improvement of object-oriented programming pedagogy, the study also tries to make the computing course curricula more appropriate and flexible with the use of the various programming tools. Suggestions on how the study can be made more rigorous have been listed including use of additional data gathering instruments and methodology. Also, recommendations on how else the questions can be written were incorporated
An Aspect Refactoring Tool for The Observer Pattern
Current integrated development environments such as Eclipse provide strong support for object- oriented automatic refactorings; however, the same cannot be said about aspect-oriented refactor- ings. Refactoring of design patterns is one area where aspect refactoring automation remains to be explored in depth and few current tools are available to support it. To support aspect refactoring tools we present the AJRefactor plug-in, a semi-automatic refactoring tool for the observer pattern, a widely-used solution in the design of object-oriented programs. Aspect refactoring of the observer pattern allows aspects to capture pattern-specific code into a more modularized unit, and local- izes the code of participating classes. After applying AJRefactor on two Java projects JHotDraw and Prevayler, the results showed that AJRefactor was able to refactor 75% of the total observer instances found in both projects. Also, the refactoring enhanced the modularity and loosens the coupling of the pattern classes. Finally, the results showed a significant time savings and a small reduction in code size when refactoring with AJRefactor
Reengineering legacy software to object-oriented systems
NASA has a legacy of complex software systems that are becoming increasingly expensive to maintain. Reengineering is one approach to modemizing these systems. Object-oriented technology, other modem software engineering principles, and automated tools can be used to reengineer the systems and will help to keep maintenance costs of the modemized systems down. The Software Technology Branch at the NASA/Johnson Space Center has been developing and testing reengineering methods and tools for several years. The Software Technology Branch is currently providing training and consulting support to several large reengineering projects at JSC, including the Reusable Objects Software Environment (ROSE) project, which is reengineering the flight analysis and design system (over 2 million lines of FORTRAN code) into object-oriented C++. Many important lessons have been learned during the past years; one of these is that the design must never be allowed to diverge from the code during maintenance and enhancement. Future work on open, integrated environments to support reengineering is being actively planned
Data Migration in an Object-Oriented Software Development Environment
As software systems grow from small systems developed by a handful of people to large, complex systems developed by hundreds of people, the environment in which they are developed evolves. Large software systems contain vast quantities of data that must migrate to new development environments. Object-oriented software development environments (OOSDEs) have received research attention recently, and seem destined to become commonplace for software development of these large systems. System growth involves data migration, a problem that must be solved before OOSDEs become practical tools. Data migration includes immigration (import) of systems developed using traditional facilities, reorganization of systems supported by object-oriented databases (objectbases), and schema evolution as the class structure of the objectbase changes. This thesis presents graphics-oriented tools -- Marvelizer and Organ -- that solve the first two problems for the Marvel OOSDE. Marvelizer and Organ have been implemented and used on Marvel itself
- …