Information and Data Modelling for Enterprise Interoperability

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.

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.

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.

Processing, besides being a language of sorts, is an integrated development environment (IDE)—an IDE created by artists for artists. The Processing development environment is simple to learn and use, and doesn’t add to the complexity of learning to program, as with many other IDEs. In fact, the Processing IDE really does substantially simplify the process of coding, even for absolute beginners. Even Flash, which is another very popular IDE of sorts, also geared toward artists, has a steep learning curve, and its complexity can get in the way on pure coding projects. In contrast, the Processing IDE has a well-designed interface and core functionality that allows you to work efficiently; it’s a huge improvement over working in your old text editorKeywordsVirtual MachineProcessing EnvironmentText EditorJava Virtual MachineJava ApplicationThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

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.

With the advent of the mobile Internet era, the quality of Android application software and the level of user experience have become the key factors that determine the success or failure of market competition. The construction of software development and testing environment is an important part of the whole software development process. It is imperative to use machines instead of manpower to complete complicated tests that require precision. The concept of automated testing arises at the historic moment. The construction of software development and testing environment is an important link in the whole software development process. Different versions of operating systems, databases, network servers and application services, combined with different system architectures, make the types of software testing environments to be constructed various. The opening of Android system makes the development of Android Software easier. Any developer, whether a professional company or an individual, can develop their own applications. The combination of automated testing and manual testing makes up for the shortcomings found in automated testing, which requires a lot of initial investment and special personnel to maintain.KeywordsSoftware developmentAndroidAutomation

Unified Modeling Language (UML) plays an important role in the modern software development process by offering standardized methods for visual modeling, analysis, and design of complex systems. This paper discusses the main aspects of storing, editing, and integrating UML documents with integrated development environments (IDEs). The main focus is on comparing the two main formats for storing UML models – XML Metadata Interchange (XMI) and JavaScript Object Notation (JSON). XMI, being an official standard developed by Object Management Group, provides a high degree of detail and compatibility with various UML tools, making it preferable for large and complex projects that require support for the full UML specification. At the same time, JSON is simple and flexible, which makes it suitable for projects where speed of development and ease of integration are important, although it is inferior to XMI in describing complex aspects of UML models. The paper analyzes in detail the methods of editing UML documents, including manual editing and automated approaches, using APIs and scripts. Manual editing is useful when you need to make small changes to the structure of a UML document, but it can be time-consuming and error-prone when working with large projects. Automation, on the other hand, provides effective tools for mass editing and generating UML elements, which significantly speeds up development and minimizes the likelihood of errors, especially since modern tools such as StarUML offer the necessary tools for programmatically modifying UML documents by integrating them into development processes. Combining of UML documents with integrated development environments also plays a key role in increasing development efficiency, as this allows automating code generation based on UML models, maintaining synchronization between code and diagrams, and facilitating visualization and documentation of architectural solutions. Despite the significant advantages, there are challenges associated with limited support for all UML features and potential conflicts between models and code. This only emphasizes the need for further research in this area. Prospects for further research include the development of new methods and tools for working with UML documents, improving their integration with development environments, and using artificial intelligence to automate the analysis and design of UML models. Attention should also be paid to the using of UML with continuous integration processes, which can significantly increase the flexibility and adaptability of software development. Thus, the study of the structure of storing, editing, and integrating UML documents is an important area for optimizing the design and development of modern software systems.

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

The growing importance of modeling and model transformation has attracted attention to create precise models and transformations. Visual model definitions have a tendency to be incomplete, or imprecise, thus, the definitions are often extended by textual constraints attached to the model items. Textual constraints can eliminate the incompleteness stemming from the limitations of the visual definitions. Object Constraint Language (OCL) is one of the most popular constraint languages in the field of UML, Domain Specific Modeling Languages, and model transformations. Efficient constraint handling needs the optimization of the constraints. Our research focuses on creating optimization algorithms for OCL constraint handling. This paper presents three algorithms that can accelerate the validation process, and thus, make the modeling more efficient. Proofs are also provided to show that the optimized and the unoptimized code are functionally equivalent, and the paper contains a simple case study to show the practica l relevance of the algorithms.

Evaluation of integrated software development environments: Challenges and results from three empirical studies

An important obstacle to the wide-spread adoption of model-driven development approaches in industry is the lack of proper debugging facilities. Software debugging support is provided by a combination of language and Integrated Development Environment (IDE) features which enable the monitoring and altering of a running program’s state. In Domain-Specific Modelling (DSM), debugging activities have a wider scope: designers debug model transformations (MTs) and synthesized artifacts, while domain-specific modellers debug their models, unaware of generated artifacts. This work surveys the state-of-the-art of debugging in the context of DSM and proposes a mapping between debugging concepts (e.g., breakpoints, assertions) in the software and DSM realms.

The Green Deal Data Space is born in the big data paradigm where there is a variety of data formats and data models that are exposed as files or web APIs. As a result, we need to default in simple data structure that is transversal enough to be able to represent most of the more specific data models, formats and API payloads. Many data models present a structure that can be represented as tables.TAPIS stands for "Tables from APIS". It is a JavaScript code that uses a common data model that is an array of objects with a list of properties that can contain a simple or a complex value. In TAPIS offers a series of operations that use one or more arrays of objects as inputs and produce a new array of objects as an output. There are operations that create the arrays of objects from files or API queries (a.k.a. data import), others that manipulate the objects (e.g. merge two arrays in a single one) and some operations that generate visual representations of the common data structure including tabular, a map, a graph, etc.TAPIS is limited by its own data model. While many of the data models can be mapped to the common data model, a multidimensional data cube or a data tree cannot be represented in a single table in an efficient way. In the context of the Green Deal Data Space, most of the sensor data, statistical data, geospatial feature based data and administrative data can be considered object based data and can be used in TAPIS. TAPIS is able to connect to Sensor Things API (the sensor protocol selected in AD4GD and CitiObs), S3 buckets (the internal cloud repository used in AD4GD), GeoNetwork (the geospatial metadata catalogue selected in AD4GD and more4nature), and the OGC API features and derivates (the modern web API interfaces standardized by the OGC) but other data inputs will be incorporated, such as Citizen Science data sources and other popular APIs used in the more4nature project. More analytical functionalities are going to be incorporated in the CitiObs project. As part of the AD4GD Green Deal Information Model, there is an operation to associate semantics to each column of a table by linking it to a URI that defines the concept in an external vocabulary (as well as units of measure if appropriate). In order to be compatible with the data space architecture recommended by the International Data Space Association, we are working on supporting the catalogue of the Eclipse Data Connector, and to be able to negotiate a digital contract as a previous step to request access to the relevant data offered in the data space. To do so, we are working on incorporating the data space protocol as part of the TAPIS operations for data import. TAPIS is available as open source at https://github.com/joanma747/TAPIS.AD4GD, CitiObs and more4nature are Horizon Europe projects co-funded by the European Union, Switzerland and the United Kingdom.

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. >

In this paper, we propose the components and an effective integrated development environment (IDE) of an Open software Platform for Robotic Services (OPRoS) that covers from the control of H/W devices to the execution of complicated application programs. Standardized components with data, service, and event ports are offered for developing robot S/W applications easily and efficiently by just combining several components in proper ways. Some design patterns are also provided for general reusable solutions to commonly occurring problems in developing the robot S/W applications. For an all-level development environment, the IDE of the OPRoS supports the development from low-level device controls to high-level contents composition. It turns out that, as a comprehensive platform for robot S/W applications, the proposed OPRoS provides convenient environments for all development steps from editing to execution.