Requirements of object-oriented databases for tool integration in IPSEs

Software development environments (SDEs) are examined from the environment architect's perspective. The main interest is in investigating two related issues of building SDEs: open architecture and tool integration. A taxonomy of architectural mechanisms that solely determine the underlying architecture of an SDE is presented. The significance of this taxonomy is that it makes it possible to study the intrinsic properties of SDE architecture with respect to technical issues such as portability, tool integration, tool construction, tailorability, and evolution of SDEs. Four types of mechanisms are identified: modeling and schema-definition mechanisms, access mechanisms, interprocess communication mechanisms, and execution mechanisms. These four types of mechanisms reflect the relationship of tools to the SDE architecture. For each type of mechanism, various approaches proposed in the literature are compared and openness and integration are discussed. It is suggested that truly open and integrated SDEs can be achieved through careful selection of architectural mechanisms and good implementation strategies of these mechanisms. >

Programming is an important course for any IT or engineering-related course. However, previous research shows that students face difficulties in learning programming due to its abstract concepts. This study aims to evaluate the acceptance of a developed Integrated Development Environment (IDE), namely C-SOLVIS which is a web-based application that specifically intends to facilitate the teaching and learning of the C programming fundamentals in Malaysian tertiary education. The C-SOLVIS integrates problem-solving into a program development environment for the C language. The goal is to guide the users in problem-solving and help them write C programs based on problem-solving algorithms. The Rapid Application Development (RAD) Model was employed in the C-SOLVIS development process. Based on this model, the requirement planning phase was carried out through the triangulation technique by applying qualitative approaches comprising a literature review supported by semi-structured interviews, document reviews, and content validation by expert programming lecturers. Subsequently, the design of the application was accomplished through the iterative prototyping process which was then followed by the application construction. Then, the C-SOLVIS is deployed to be used by several programming lecturers to evaluate its usability by adopting a quantitative method using the System Usability Scale (SUS) questionnaire. The study has discovered several suitable techniques and designs for the problem-solving and program development environment. For the problem-solving environment, the Computational Thinking (CT) concepts were applied which were supported by the Input-Process-Output (IPO) Model through Scientific Instructions and Inquiries. Meanwhile, the program development environment was designed and developed based on frame-based programming using a set of developed Code Patterns. The C-SOLVIS evaluation using the SUS instrument has yielded a SUS mean score of 86.07. This score is interpreted by SUS as an A grade that indicates C-SOLVIS as a highly usable application and thus is accepted for C programming learning. Hence, the development process of the C-SOLVIS can be used as a guideline for educational software development, especially in the field of programming education.

When provided with the support of proper development and maintenance tools, programmers are more likely to work efficiently and produce high-quality software [1,2]. A mature and professional Integrated Development Environment (IDE) provides the required tools in an integrated manner and allows those tools to be easily adapted for use in new contexts as well [3]. Providing these capabilities for agent-oriented programming (AOP) is not trivial. Specific features of agents like decision cycles, rule-based evaluations, mental states, external environments, and embedded knowledge representation (KR) technologies pose specific challenges to the design and development of an IDE for AOP. These challenges significantly differ from object-oriented or functional programming for example, as those paradigms do not (inherently) deal with for instance distributed execution, database inspection, and logic inference. In this paper, we present a mature and professional IDE for the multiagent programming language GOAL [4]. In contrast to other AOP development environments, our approach is novel, as we fully integrate all agent and agent-environment development tools within one environment. Other AOP development environments are generally composed of several standalone tools [5]. For instance, running or debugging an agent after editing its program code is usually performed in a separate application (pop-up).

Responding to the fact that software systems become more and more complex and mutable, not only the software-standards-related technologies should be adopted, but the environments for software development and evolution should also be flexible and integratable. These facts make software development and maintenance difficult and costly. In this chapter, we first illustrate the activities and studies for software standards, processes, CASE toolsets, and environments. Then, we propose a process and an environment for evolution-oriented software development, called the PRocess and Agent-based Integrated Software development Environment (PRAISE). PRAISE advocates software development with popular software methodologies, and it uses an XML-based mechanism to unify the various paradigms with different standards. It integrates processes, roles, toolsets, and work products to make software development more efficient. With PRAISE, users are encouraged to adopt familiar mechanisms and formal approaches as they wish. PRAISE maintains the consistency of the paradigms so that users do not need to worry about conflicts with other paradigms that are built in or added later. PRAISE meets the need for evolving software development and maintenance.

Responding to the fact that software systems become more and more complex and mutable, not only the software-standards-related technologies should be adopted, but the environments for software development and evolution should also be flexible and integratable. These facts make software development and maintenance difficult and costly. In this chapter, we first illustrate the activities and studies for software standards, processes, CASE toolsets, and environments. Then, we propose a process and an environment for evolution-oriented software development, called the PRocess and Agent-based Integrated Software development Environment (PRAISE). PRAISE advocates software development with popular software methodologies, and it uses an XML-based mechanism to unify the various paradigms with different standards. It integrates processes, roles, toolsets, and work products to make software development more efficient. With PRAISE, users are encouraged to adopt familiar mechanisms and formal approaches as they wish. PRAISE maintains the consistency of the paradigms so that users do not need to worry about conflicts with other paradigms that are built in or added later. PRAISE meets the need for evolving software development and maintenance.

We describe some of the novel aspects and motivations behind the design and implementation of the Ciao multiparadigm programming system. An important aspect of Ciao is that it provides the programmer with a large number of useful features from different programming paradigms and styles, and that the use of each of these features can be turned on and off at will for each program module. Thus, a given module may be using e.g. higher order functions and constraints, while another module may be using objects, predicates, and concurrency. Furthermore, the language is designed to be extensible in a simple and modular way. Another important aspect of Ciao is its programming environment, which provides a powerful preprocessor (with an associated assertion language) capable of statically finding non-trivial bugs, verifying that programs comply with specifications, and performing many types of program optimizations. Such optimizations produce code that is highly competitive with other dynamic languages or, when the highest levels of optimization are used, even that of static languages, all while retaining the interactive development environment of a dynamic language. The environment also includes a powerful auto-documenter. The paper provides an informal overview of the language and program development environment. It aims at illustrating the design philosophy rather than at being exhaustive, which would be impossible in the format of a paper, pointing instead to the existing literature on the system.

SUMMARYIntegrating tools implemented as plug‐ins is a complex and time‐consuming activity that requires good programming skills and a deep understanding of the underlying plug‐in architecture for successful completion. Even when tools are implemented as plug‐ins for a same integrated development environment (IDE), users frequently prefer to manually perform the same inefficient operations every time they use the tools rather than implementing automated tool integration.In our vision, IDE users must be able to flexibly execute plug‐ins and easily integrate their results by designing workflows that can be persisted, automatically executed, and reused in other workflows.This paper therefore presents MASH, a framework that extends IDEs with task‐based plug‐ins (TB‐plug‐ins) and workflows. A TB‐plug‐in is a plug‐in that exposes its functionalities as executable tasks in a workflow. TB‐plug‐in workflows are processes that automatically execute multiple tools and integrate their results. IDE users can turn regular plug‐ins into TB‐plug‐ins by writing simple scripts or using the GUI capturing feature that MASH offers.We validated our idea with two case studies examining the design of two data‐driven analyses as tool integration. We discovered that workflows can be easily designed by knowing little about the IDE or plug‐ins API, saving significant effort otherwise devoted to implementing additional plug‐ins and glue code, and they produce analyses that can be quickly modified and reused. Copyright © 2012 John Wiley & Sons, Ltd.

This paper presents the design and implementation of a Microprocessor without Interlocked Pipeline Stages (MIPS) pipelined simulator build on top of the MIPS Assembler and Runtime Simulator (MARS) as a plug-in. The MARS Simulator is a lightweight interactive development environment (IDE) for programming in MIPS assembly language, intended for education-level use. This plug-in called "Pipelined Simulator and Branch Explainer (PBSE)" provides the MARS users with the ability to simulate a pipelined processor execution of MIPS assembly instruction which the original MARS simulator does not support. The tool also provides additional functionality as such Branch Prediction. With the use of the plug-in, MARS users can better analyze the assembly codes executed in a pipelined processor with branch prediction and improve their understanding of Computer Architecture.

The ULowell Data Flow Project combines dataflow hardware, dataflow software, and a data flow development environment. The hardware component, a data flow coprocessor card, utilizes seven NEC 7281 Image Pipelined Processors. Each chip models a static dataflow computation and is programmable. The coprocessor was designed and implemented by ULowell personnel and uses an AMIGA 2000 as a host. The software component currently consists of a library of data flow image processing algorithms and an evolving software development environment. Currently the image processing library includes typical imaging operations such as: edge enhancement, filtering, histogramming, and affine transformation. The software development environment (SDE) is depicted in Figure 1. The SDE contains a Data Flow Graph Editor which programmers use to design their data flow code. The data flow algorithm can then be converted directly into NEC data flow assembly code which is then assembled using the ULowell Data Flow Assembler. The assembler differs from NEC's assembler in that it can produce relocatable code. The object code output of the assembler is given to the Data Flow Resource Manager. The resource manager monitors the available resources within the chips. Thus, if a single process does not totally utilize a chip's table space or memory, then a second process may be concurrently loaded onto the same chip. The ability to have multiple data flow processes coexisting within a single chip is unique to the ULowell environment. The data flow resource manager can download and monitor code to either the hardware or to a software simulator/debugger. The simulator/debugger can monitor and trace data flow tokens as they proceed through the chip. Output of the simulator/debugger can be fed back into the data flow graph editior to visually trace token flow through the original program design. The last component of our SDE is a High Level Language translator which can compile programs written in SISAL, a high level language for parallel computation, down to NEC 7281 assembly language. We have already implemented the relocatable assembler, and the data flow resource manager. Prototype versions of the high level translator, simulator/debugger and graph/editor are currently being implemented.

Many Integrated Development Environment (IDE) can be used to create Android Apps. Android Studio with Java programming language is an IDE and native programming language that is officially supported by Google. As a supported IDE, AS becomes the best IDE that can be used to build apps. Nevertheless, many novice programmers find it difficult to get started especially by starting a new programming concept for mobile devices. Android Studio is also known as an IDE that requires a high specs computer requirement and also has sophisticated features. This research purposed to develop applications with IDEs that are more user-friendly and more emphasize the big concept of programming without much difficulty regarding compiling the program code and also the complexity of IDE as well as Android Studio. The IDE used in this study is App Inventor 2 (AI2), a cloud-based IDE managed by the Massachusetts Institute of Technology (MIT). The next goal is to test the capabilities of the application by conducting Blackbox Testing and User Testing. In this research has been developed an app called Receptionist that is used to test the ability of the codes generated by AI2. The results show that AI2 can be used to build complex applications such as Text Message Service (SMS) broadcasting, performing local database queries and retrieving data on the server. However, some features such as database processing should run in the background still run on the UI thread, thereby reducing the user experience when Application Not Responding (ANR) occurs. Keywords: App Inventor 2, Android Application, Cloud Programming, visual programming

Software is rapidly moving from the desktop to the Web. The Web provides a generic user interface that allows ubiquitous access, instant collaboration, integration with other online services, and avoids installation and configuration on desktop computers. For software development, the Web presents a shift away from developer workstations as a silo, and has the promise of closer collaboration and improved feedback through innovations in Web-based interactive development environments (IDEs). Moving IDEs to the Web is not just a matter of porting desktop IDEs; a fundamental reconsideration of the IDE architecture is necessary in order to realize the full potential that the combination of modern IDEs and the Web can offer. This paper discusses research challenges and opportunities in this area, guided by a pilot study of a web IDE implementation.

Teaching and learning programming is a challenge. Although several learning and programming environments have been proposed for classes, there seems to be more dissent than consensus as to which tools are preferable over others. This paper investigates teachers’ perspectives on popular learning and programming environments used in secondary computer science education in Germany. The environments investigated are: BlueJ, Scratch, Greenfoot, Eclipse, MIT App Inventor, Processing IDE, and Alice. Based on prior research, a catalogue of environment features supporting the learning processes of students was constructed. Using these criteria, an online-survey was conducted with computer science teachers in North Rhine-Westphalia, Germany. In the survey, the participating teachers evaluated the selected tools’ adequacy for teaching object-oriented programming. The findings support the results of prior research conducted with students, stressing the importance of a simple and user-friendly graphical user interface (GUI) as well as the option to visualise classes and objects. Contrary to prior studies, the results show that teachers do not see the editor as equally important, as students do, and that there is no consensus about the role of the area of application for choosing an integrated development environment (IDE). Student-friendly debugging messages as well as a step-by-step execution of programs were identified as important features. Although no tool excelled for every criterion, the clear favourite was BlueJ.

Pipeline image processing systems are increasingly being used in industrial vision systems, in particular in manufacture visual inspection. There has been little work done in the study of the appropriate software environment for rapid program development for these machines. In this paper, an approach to improve software programmability of these systems was proposed. The software features reflecting the hardware capabilities as well as the nature of image processing applications were discussed. A preprocessor was developed to support the high level programming environment and the abstract data structures. The preprocessor also analyzed the image processing tasks expressed as expressions and generate the hardware setup and connections necessary for multipass operations through the pipeline processor. A prototype implementation of the preprocessor and an example were also discussed.

Distributed software development is becoming a common practice among developers. Factors such as the development environments improvement, their extensibility, and the emergence of social networking software are leading factors. They lead the development process (both co-located and geographically distributed) to a practice that: 1) improves the team’s productivity, and 2) encourages and supports the social interaction among the teams’ members. The above factors along with the distributed development emergence, Integrated Development Environments (IDEs) evolution, and the social media advances got the attention of the software development teams, and made them consider how to better assist the social nature of software developers, and the social aspects of software development, including activity awareness of team members’ progress, their presence, collaboration, communication, and coordination around shared artifacts. IDEs are the most commonly used tools by developers and programmers. Integrating the most needed development tools inside the IDE, makes it a Collaborative Development Environment (CDE), and embedding a variety of social software features within a CDE helps support distributed development teams. It also creates a new genera of tools called Social Development Environments or “SDEs” as it is commonly called. This article discusses the origins and development of “SDEs”. It reflects and presents the research into development environments, explaining their role in supporting the communication and coordination needs of development teams. Also, it presents the effect of embedding social network features in such environments. It presents some emerging SDEs and future work. Finally, it concludes by introducing a new model named 5-star that classifies, and helps to evaluate and compare the collaborative tools. 5-star presents a new way to compare and evaluate the SDE systems based on their supported features. It bases the comparison on five major categories including: Communication, Coordination, Collaboration, Awareness & Presence, and Social networking (SN) tools.

This paper describes the environment for developing and executing Warp* programs. The center of the program development environment is a customized shell that ties together a compiler for the Warp array, the Warp run-time system, and a debugger. The compiler translates high-level language programs to microcode for the Warp machine. It achieves a high utilization of the computation power of the processor. The run-time system supports remote execution of Warp programs across a network and makes the Warp machine available as a shareable resource. The debugger permits symbolic debugging of Warp programs. The Warp programming environment makes the Warp machine an easily programmable and accessible attached processor in a UNIX™ environment .