Integrated Programming Environment Research Articles

Teaching object‐oriented programming with AEIOU

ABSTRACTAEIOU is an integrated programming environment developed to support the teaching–learning process of object‐oriented programming in a gradual way. AEIOU includes three modules, one for each level of students' expertise: novice, intermediate, and advanced. This article describes the features of each module of AEIOU and the experiences and results obtained using this programming environment to support the sequence of programming courses in two Mexican engineering schools. © 2011 Wiley Periodicals, Inc. Comput Appl Eng Educ 22:309–319, 2014; View this article online at wileyonlinelibrary.com/journal/cae; DOI 10.1002/cae.20556

Implementation and Analysis of Elliptic Curves-Based Cryptographic Algorithms in the Integrated Programming Environment

Implementation and Analysis of Elliptic Curves-Based Cryptographic Algorithms in the Integrated Programming Environment

MeTA studio: A cross platform, programmable IDE for computational chemist

The development of a cross-platform, programmable integrated development environment (IDE), MeTA Studio, specifically tailored but not restricted to computational chemists working in the area of quantum chemistry with an emphasis on handling large molecules is presented. The IDE consists of a number of modules which include a visualizer and a programming and collaborative framework. The inbuilt viewer assists in visualizing molecules, their scalar fields, manually fragmenting a molecule, and introduces some innovative but simple techniques for handling large molecules. These include a simple Find language and simultaneous multiple camera views of the molecule. Basic tools needed to handle collaborative computing effectively are also included opening up new vistas for sharing ideas and information among computational chemists working on similar problems. MeTA Studio is an integrated programming environment that provides a rich set of application programming interfaces (APIs) which can be used to easily extend its functionality or build new applications as needed by the users. (http://code.google.com/p/metastudio/).

EXOCHI

Future mainstream microprocessors will likely integrate specialized accelerators, such as GPUs, onto a single die to achieve better performance and power efficiency. However, it remains a keen challenge to program such a heterogeneous multicore platform, since these specialized accelerators feature ISAs and functionality that are significantly different from the general purpose CPU cores. In this paper, we present EXOCHI: (1) Exoskeleton Sequencer (EXO), an architecture to represent heterogeneous acceleratorsas ISA-based MIMD architecture resources, and a shared virtual memory heterogeneous multithreaded program execution model that tightly couples specialized accelerator cores with generalpurpose CPU cores, and (2) C for Heterogeneous Integration (CHI), an integrated C/C++ programming environment that supports accelerator-specific inline assembly and domain-specific languages. The CHI compiler extends the OpenMP pragma for heterogeneous multithreading programming, and produces a single fat binary with code sections corresponding to different instruction sets. The runtime can judiciously spread parallel computation across the heterogeneous cores to optimize performance and power. We have prototyped the EXO architecture on a physical heterogeneous platform consisting of an Intel® Core™ 2 Duo processor and an 8-core 32-thread Intel® Graphics Media Accelerator X3000. In addition, we have implemented the CHI integrated programming environment with the Intel® C++ Compiler, runtime toolset, and debugger. On the EXO prototype system, we have enhanced a suite of production-quality media kernels for video and image processing to utilize the accelerator through the CHI programming interface, achieving significant speedup (1.41X to10.97X) over execution on the IA32 CPU alone.

Two possible approaches for an intermediate GUI course

This poster presents the main pros and cons of two approaches for introducing intermediate students to the use of a complex class library in the context of Graphical User Interface programming. The approaches use different programming languages, integrated programming environments, and frameworks. The frameworks are used mainly for the development of application program interfaces for graphical user interfaces. These are useful in latter courses and are also important for student motivation.

An interactive environment for beginning Java programmers

Building upon years of evolution in object-oriented programming language design, Java has emerged as the language of choice among many educators for teaching introductory computer science. A clean, type-safe language, Java provides a garbage collected heap and a comprehensive exception-handling mechanism. However, in spite of this support, many students in introductory computer science courses still find programming to be an overwhelming source of frustration. Linguistic concerns and programming mechanics demand so much attention that deeper concepts are often postponed for later courses, leaving students in introductory courses with the mistaken impression that computer science is a shallow discipline, concerned only with transcribing ideas into code, and not with the ideas themselves. JPie is a tightly integrated programming environment for live software construction in Java. JPie treats programming as an application in its own right, providing a visual representation of class definitions and supporting direct manipulation of graphical representations of programming abstractions and constructs. Exploiting Java’s reflection mechanism, JPie supports the notion of a dynamic class that can be modified while the program is running, thereby eliminating the edit–compile–test cycle. Following years of experience using Java as the vehicle for teaching introductory computer science, we have designed JPie to provide a more natural and fluid software development process that both raises the level of abstraction and eliminates many of the common pitfalls that beginning Java programmers face. This paper studies JPie from an educational perspective. We systematically review key programming abstractions and explain how JPie supports them in ways that keep beginning programmers focused on important ideas. Our experience using JPie in an introductory computer science survey course for non-majors is briefly discussed.

A concepts-first introduction to computer science

We present a unique "concepts-first" curriculum that exposes students without programming experience to the intellectual depth and breadth of computer science through hands-on experience with software development. The curriculum is supported by JPie, a tightly integrated programming environment that enables live construction of Java applications through direct manipulation of graphical representations of programming abstractions. The curriculum, projects, and classroom experience are described.

E-Phys: a suite of intracellular neurophysiology programs integrating COM (Component Object Model) technologies

Current computer programs for intracellular recordings often lack advanced data management, are usually incompatible with other applications and are also difficult to adapt to new experiments. We have addressed these shortcomings in e-Phys, a suite of electrophysiology applications for intracellular recordings. The programs in e-Phys use Component Object Model (COM) technologies available in the Microsoft Windows operating system to provide enhanced data storage, increased interoperability between e-Phys and other COM-aware applications, and easy customization of data acquisition and analysis thanks to a script-based integrated programming environment. Data files are extensible, hierarchically organized and integrated in the Windows shell by using the Structured Storage technology. Data transfers to and from other programs are facilitated by implementing the ActiveX Automation standard and distributed COM (DCOM). ActiveX Scripting allows experimenters to write their own event-driven acquisition and analysis programs in the VBScript language from within e-Phys. Scripts can reuse components available from other programs on other machines to create distributed meta-applications. This paper describes the main features of e-Phys and how this package was used to determine the effect of the atypical antipsychotic drug clozapine on synaptic transmission at the neuromuscular junction.

Enhanced monitoring in the GRADE programming environment by using OMIS

To provide high-level graphical support for developing message passing programs, an integrated programming environment (GRADE) is being developed. GRADE provides tools to construct, execute, debug, monitor and visualise message-passing based parallel programs. The paper describes the integration of GRADE and an OMIS compliant monitor system. OMIS is a recent specification of a universal on-line monitoring interface for parallel and distributed programs. The integration provides GRADE with a more flexible monitoring support and makes possible the simultaneous usage of debugging and visualisation tools. The paper specifically addresses the requirements imposed by GRADE on the on-line event tracing mechanisms, as well as their implementation and performance.

A low-cost sound level meter based on personal computer

In this abstract a low-cost sound level meter is developed with the help of digital signal processing techniques and an integrated programming environment. The instrument is based on the use of a general purpose data acquisition PC card to acquire the signal and a powerful digital signal processing algorithm based on digital filters to compute a one-third octave band analysis conforming to ANSI S1.11-1986 in real time. The objective is made possible thanks to the use of optimized signal processing routines from Intel Signal Processing Library. The use of this library and an instrumentation specific integrated programming environment such as LabWindows/CVI (National Instruments) makes it possible to design a low-cost instrument in a very short time. The algorithm is a multirate filter bank implementation of the standard. The discussion is completed with several simulations and benchmarks are presented for different design situations. Execution time is also compared to that obtained with a popular digital signal processor (TMS820C30 from Texas Instruments). [For Engineering Acoustics Best Student Paper Award.]

The architecture of Montana

Montana is an open, extensible integrated programming environment for C++ that supports incremental compilation and linking, a persistent code cache called a CodeStore, and a set of programming interfaces to the CodeStore for tool writers. CodeStore serves as a central source of information for compiling, browsing, and debugging. CodeStore contains information about both the static and dynamic structure of the compiled program. This information spans files, macros, declarations, function bodies, templates and their instantiations, program fragment dependencies, linker relocation information, and debugging information.Montana allows the compilation process to be extended and modified [11]. Montana has been used as the basis of a number of tools [1,7], and is also used as the infrastructure of a production compiler, IBM's Visual Age C++ 4.0 [8].

An integrated performance analysis tool for SPMD data-parallel programs

A new generation of data parallel languages have been proposed whereby a user specifies how data structures are to be distributed amongst the processor nodes of a distributed-memory machine. Based on this information, the compiler then generates code for the parallel application. Although this approach significantly simplifies the development of the initial version of a parallel application, selection of good data distributions leading to efficient computations is often quite difficult. Therefore, performance debuggers are needed to yield insights into the data distribution effects. On the other hand, most of the existing approaches to performance debugging are very general and thus do not provide the user feedback in terms of the high level programming model or the source code of the parallel application. In this paper, we describe a novel approach to performance debugging of data parallel programs. The design and implementation of a visual performance debugger is described that is specifically targeted to meet the performance debugging requirements of a data-parallel programming model based on user-specified data distributions. The performance debugger is part of an integrated programming environment, called EPPP, which also supports a data parallel compiler and a parallel architecture simulator. Thus development and performance debugging of an application may be done either on the real hardware or by using the simulator. The code for EPPP can be obtained free of cost (contact web address, http://www.crim.ca/apar).

Blue—a language for teaching object-oriented programming

Teaching object-oriented programming has clearly become an important part of computer science education. We agree with many others that the best place to teach it is in the CS1 introductory course. Many problems with this have been reported in the literature. These mainly result from inadequate languages and environments. Blue is a new language and integrated programming environment, currently under development explicitly for object-oriented teaching. We expect clear advantages from the use of Blue for first year teaching compared to using other available languages. This paper describes the design principles on which the language was based and the most important aspects of the language itself.

Supporting software reuse within an integrated software development environment (position paper)

Significant gains in programmer productivity have been achieved through the use of simple abstraction mechanisms that enhance the reuse of code. There are other useful forms of abstraction (over arbitrary identifier bindings, for example) which could further increase reuse rates, but are not well supported by programming languages; such forms may be better expressed by exploiting mechanisms provided by an integrated programming environment. This paper outlines ongoing work which aims to provide programming environment mechanisms that support the reuse of code via various forms of abstraction that complement those traditionally provided by programming languages. The concept of derivation-based reuse is also defined, and a generic framework for its support is outlined. In addition, a collection of environment mechanisms, intended to fit within this framework, are outlined.

The M/sup 3/ multiprocessor laboratory

An integrated programming environment for the M/sup 3/ multiprocessor is discussed. Three tools support the software development cycle of a parallel program, including the programming, configuration, and debugging/performance measurement phases. Programmer support for performance analysis has been a primary motivation for the system. The sources of performance loss are identified and the ways in which this information is gathered and analyzed are described. As a case study, a fast maze router algorithm is used to show the functionality of the different tools. The M/sup 3/ environment is compared with other state-of-the-art projects. >

Framework of a multitasking C++ based programming environment MCPE

Development of integrated programming environments has faced two problems: response degression, with an incresing execution delay when more tools have been included in an environment, and poor extensibility, with difficulties in adding new tools to an environment. Framework of a multitasking C++ based programming environment MCPE has been presented here for solving these problems. MCPE contains several concurrent tasks (processes): one of them is interacting with the user and the others are simultaneously doing their jobs. Process scheduling and concurrency control in MCPE have been carefully designed: response time is then reduced, and unnecessary computations are avoided. An event-driven serving model providing flexible task communications eases the addition of tools. Shared data stores have been defined as monitor types with no nested monitor calls in preventing deadlock. Consistency among the tasks has also been assured. A prototype has also been presented to show feasibility.

IPRESPS - a Programming Environment for Partitioning and Scheduling of Time Critical Tasks

Abstract We have developed an integrated programming environment, called IPRESPS, for static partitioning of time critical tasks into concurrent modules and for scheduling those modules for the shortest possible execution time on a model of a macro dataflow computer (MMDFC). IPRESPS consists out of a program graph generation module, a partitioning module, a memory allocation module, a code generation module and a simulation module. The program graph generation module transforms a time critical task (written in DFCL) into a fine grained program graph The partitioning module transforms fine grained program graph into a near optimal grained program graph and schedules it's nodes on the MMDFC. A combination of an algorithm for aggregation of program statements or modules into grains, a DSH algorithm (Kruatrachue and Lewis 1987) and a heuristic algorihm which Increases node size with determination of node's nonstrict inputs (Ojstersek and Žumer 1990) is used for node size determination. A heuristic critical path multi-lists scheduling algorithm is developed for static scheduling of near optimal grained nodes on the MMDFC too. The memory allocation module depending on the static scheduling strategy reserves memory space in units of the MMDFC The code generation module generates sequential code for each node of a near optimal grained program graph. The simulation module (Ojstersek. Žumer, and Veleski 1992) is a loose event-driven block-level simulator that monitors the execution of time critical applications, written in DFCL, which are executed on the MMDFC It enables performance debugging and time critical task debugging at the programming language level, at the abstract machine level, at the model of the computation level and partially at the realization level.

GENIE: Developing and Assessing State-of-the-Art Integrated Programming Environments

This videotape demonstrates the functionality of Carnegie Mellon's GENIE programming environments. GENIE environment are publicly available on the Macintosh for Pascal and Richard Pattis' Karel the Robot teaching language. They are appropriate for use in introductory and intermediate computer programming methods courses at both the collegiate and secondary school levels. The Karel environment has been used successfully in group settings as early as the fourth grade.GENIE environments are built around syntax directed structure editors. [1, 2] Rather than edit only individual ASCII characters, the editors manipulate elements designated by a specific language grammar. Syntax errors are either prevented altogether or corrected immediately in context.Earlier structure editors often traded their syntax error prevention functionality for highly constrained and clumsy user interfaces. GENIE environments gracefully integrate text and structure editing, such that they have the "look and feel" of a good text editor, with the "intelligence" of a syntax directed structure editor.Through access to a common structure editor data base, GENIE environments combine many advanced tools for program design, comprehension and testing, all integrated in a single, uniform Macintosh user interface. Student program structures are maintained in "unparse" trees which can be mapped to and from text and graphics in many novel ways not constrained by a language's concrete syntax.[3] Different views of a common program database can be displayed and modified concurrently, emphasizing structure and design as well as implementation detail. [4] Similarly, arbitrary pieces of program structure can be hidden from view or displayed at will.At run time GENIE program can be traced at the level of expressions. Graphical data visualizations displaying arbitrary combinations of structured types are updated dynamically during run time and displayed in a representation of the program call stack. [5] Other notable GENIE features include an extensive contextual help system and a "notes" feature useful for project management, course assignments and "on-line" grading.User studies have been conducted at several universities and secondary schools throughout the United States. [6, 7, 8, 9] GENIE students in demanding courses have performed strikingly better than have students using other commercially available Macintosh software configurations.

Improving a time critical task execution time using an IPRESPS

An integrated programming environment for static partitioning of time critical tasks into concurrent modules, called grains, and scheduling those modules for the shortest execution time possible on a macro dataflow computer are presented in this paper. We have named above environment with an achronym IPRESPS. DFCL compiler, a program for static partitioning and scheduling of time critical task and a simulator of macro dataflow computer with a visual interface are parts of IPRESPS. Time critical tasks are represented with programs, written in DFCL (a relatively low level data flow control language which we have developed in our laboratory). The DFCL compiler transforms a program, written in DFCL, into a fine grained dataflow graph, which is transformed next into a program graph. The program for static partitioning and scheduling partitions a program graph into grains and schedules them on the basis of the latest possible execution time without increasing the execution time of the whole program graph. To investigate the execution of various time critical tasks on the model of a macro dataflow computer a simulation program was developed. It simulates the execution of program graphs on the macro dataflow real-time computer. Its outputs are various types of profiles, Gantt chart and other results of simulation.

A robust computer-aided design package for municipal stormwater drainage networks

In this paper a computer model for automation in the design of the municipal stormwater drainage system is developed and rigorously verified. Although the program is tailored for application and use in Hong Kong, it can be readily adapted to other situations. The numerical model, which is designed for use on IBM/PC/XT or PC/AT microcomputers, is written in PASCAL language and is compiled by PC software TURBO PASCAL version 5·0 due to the various advantages of the integrated programming environment supported. The computer-aided design package for flow prediction and drainage design applies the Colebrook Formula and the Rational Method to route pipe flows through tree-type drainage networks. By using the computer package, drainage pipe diameters are adjusted automatically to fulfill the flow criteria, namely, that the pipe capacities are large enough to convey the peak runoffs and that the backwater levels are not higher than the finished levels and hence ensure that flooding will not be resulted at all locations. The monotonous and iterative conventional method for designing municipal stormwater drainage networks can be taken over by this model. During the execution of the user-friendly and easily operated computer program, adequate user oriented information will be furnished. Its verification is effected by application of the program for municipal stormwater drainage design in a typical example.