Transformation Architecture for Multi-Layered WebApp Source Code Generation

In recent years, the World Wide Web has become an ideal platform for developing Internet applications. World Wide Web service and application engineering is a complex task. Many web applications at present are large-scale and involve hundreds or thousands of web pages and sophisticated interactions with users and databases. Thus, improving the quality of web applications and reducing development costs are important challenges for the Internet industry. One way to resolve the difficulty is to provide web application developers with an integrated development environment. In this paper, I propose an efficient methodology and development environment for web application programs. This environment includes a design model to represent data and navigational structure, a modeling language for the notation technique of the design model, and a process model to define development stages.

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.

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.

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.

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.

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.

The medical and technology fields are rapidly advancing, leading many people to use computers to help diagnose, prevent, and treat human diseases. One major issue in the medical world is the imbalance between the number of patients and doctors. Additionally, most people lack medical training, so when experiencing symptoms of a disease, it is often difficult to immediately know the correct steps to take. Eye diseases vary in severity, ranging from mild to severe. One common eye disorder affecting many people is refractive error, which generally falls into two categories: hyperopia (farsightedness) and myopia (nearsightedness). Early detection of symptoms related to refractive errors requires accurate and prompt diagnosis. Therefore, with the rapid development of technology, it is essential to develop systems capable of early detection of eye diseases, especially refractive errors, by using technology that mimics human expert capabilities, such as expert systems. This expert system integrates expert knowledge within two main environments: the development environment and the consultation environment, helping the community diagnose diseases more easily and efficiently. For example, the use of the Certainty Factor method in expert systems enables the calculation of diagnostic certainty levels based on the combination of symptoms reported by patients and expert knowledge, achieving a confidence level of up to 96.7%. This demonstrates that expert system technology can be a valuable tool in addressing the imbalance between patients and doctors while improving access to faster and more accurate diagnoses. To build such systems, Microsoft Visual Studio .NET provides a complete set of tools for developing ASP.NET web applications, XML Web Services, desktop applications, and mobile applications. Within Visual Studio, .NET programming languages such as Visual Basic, Visual C++, Visual C# (CSharp), and Visual J# (JSharp) are used in a unified integrated development environment (IDE), enabling developers to efficiently share tools and resources to create reliable and user-friendly expert system applications. The system was developed and tested using symptom data from 40 patients collected at the Tanjung Sarang Elang Community Health Center. The testing showed a diagnostic accuracy of up to 96.7% in detecting symptoms of both hyperopia and myopia.

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

T he Model Driven Development (MDD) is an approach that has gained more space in industry and academia, bringing great benefits such as increased productivity. One way of working in teams with MDD is using an IDE (Integrated Development Environment) with a versioning system. However, to collaboratively work with an IDE and a versioning system may have implications and problems for the development as: conflicts of models, documentation discontinued, difficulties for stakeholders to use versioning systems, etc. In this context, this work proposes an approach to use a wiki to develop MDD, so that the developer is able to create models, generate source code, sharing and versioning models and also to collaboratively document, in a more simple and easy way than the traditional approaches. This enables non developers can participate more in the development process and also allows increasing productivity. To try to show that a wiki can be used to develop software, we created a Domain Specific Language (DSL) in a wiki and were performed three case studies: one with high school students and represent the non developers, another one with four graduate students with experience in software development in the industry, and the last case study was conducted with 48 participants among developers and graduate students in Computer Science. The case studies showed the feasibility of using a wiki for development, that non developers adapted well to the approach and 86 % of the developers would use a wiki to develop MDD. The study also raised the main barriers to increase the acceptance of the approach. Therefore, this work presents also a relatively new approach in the literature and results on the use of versioning systems, IDEs and collaboratively development.

We investigate the scaling up of a class of single-user software development environments, which we call rule-based development environments (RBDEs), to support multiple developers cooperating together on a project. RBDEs model the software development process in terms of rules that encapsulate activities, and execute forward and backward chaining on the rules to provide assistance in carrying out the development process. There is a spectrum of assistance models, ranging from pure automation to strict consistency preservation. We describe three problems whose solutions are dependent on the choice of assistance model: (1) multiple views; (2) evolution; and (3) concurrency control. We discuss how the two extremes of the spectrum restrict the possible approaches to multiple views and evolution. In order to explore different aspects of the concurrency control problem across multiple points on the spectrum of RBDEs, we develop a maximalist assistance model and propose an approach to synchronization of cooperating developers within the context of this model.

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

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.

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