Search

The object of research is the modular approach to application development using SOA, as well as the comparison of synchronous and asynchronous request processing methodologies using a reactive programming architecture. SOA allows applications to be divided into independent components, ensuring easy integration and scalability in distributed computing environments. With SOA, it is possible to create a network of loosely coupled services, providing users with the flexibility to develop applications tailored to specific needs. One of the main issues is thread blocking and system instability under heavy loads when using synchronous methods. The study compares synchronous and asynchronous request processing methodologies using WebFlux, and examines key components of SOA, such as service discovery mechanisms and interaction models, particularly orchestration and choreography. The results show that asynchronous approaches, using a non-blocking, event-driven architecture, reduce the number of active threads, increase system resilience, and improve performance. This is because the proposed nonblocking, event-driven approach has several features, including reducing thread blocking and enhancing system stability under heavy loads. Synchronous methods, while straightforward, have drawbacks such as thread blocking and system instability under excessive loads. As a result, there is a high efficiency in processing a large number of requests in real-time. Compared to similar known approaches, this provides advantages such as increased system resilience and efficient resource utilization, making this approach particularly useful for scalable application architectures in distributed computing environments. [ABSTRACT FROM AUTHOR]

Local-first software manages and processes private data locally while still enabling collaboration between multiple parties connected via partially unreliable networks. Such software typically involves interactions with users and the execution environment (the outside world). The unpredictability of such interactions paired with their decentralized nature make reasoning about the correctness of local-first software a challenging endeavor. Yet, existing solutions to develop local-first software do not provide support for automated safety guarantees and instead expect developers to reason about concurrent interactions in an environment with unreliable network conditions. We propose LoRe, a programming model and compiler that automatically verifies developer-supplied safety properties for local-first applications. LoRe combines the declarative data flow of reactive programming with static analysis and verification techniques to precisely determine concurrent interactions that violate safety invariants and to selectively employ strong consistency through coordination where required. We propose a formalized proof principle and demonstrate how to automate the process in a prototype implementation that outputs verified executable code. Our evaluation shows that LoRe simplifies the development of safe local-first software when compared to state-of-the-art approaches and that verification times are acceptable. [ABSTRACT FROM AUTHOR]

Two recent studies addressed the problem of reducing transitional turbulence in applications developed in C# on.NET. The first study investigated this problem in desktop and Web GUI applications and the second in virtual and augmented reality applications using the Unity3D game engine. The studies used similar solution approaches, but both were somewhat embedded in the details of their applications and implementation platforms. This paper examines these two families of applications and seeks to extract the common aspects of their problem definitions and solution approaches and codify the problem-solution pair as a new software design pattern. To do so, the paper adopts Wellhausen and Fiesser's writer's path methodology and follows it systematically to discover and write the pattern, recording the reasoning at each step. To evaluate the pattern, the paper applies it to an arbitrary C#/.NET GUI application. The resulting design pattern is named Dynamically Coalescing Reactive Chains (DCRC). It enables the approach to transitional turbulence reduction to be reused across a range of related applications, languages, and user interface technologies. The detailed example of the writer's path can assist future pattern writers in navigating through the complications and subtleties of the pattern-writing process. [ABSTRACT FROM AUTHOR]

Copyright of Journal of Computer Sciences Institute is the property of Lublin University of Technology and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Embedded real-time systems are tightly integrated with their physical environment. Their correctness depends both on the outputs and timeliness of their computations. The increasing use of multi-core processors in such systems is pushing embedded programmers to be parallel programming experts. However, parallel programming is challenging because of the skills, experiences, and knowledge needed to avoid common parallel programming traps and pitfalls. This article proposes the ForeC synchronous multi-threaded programming language for the deterministic, parallel, and reactive programming of embedded multi-cores. The synchronous semantics of ForeC is designed to greatly simplify the understanding and debugging of parallel programs. ForeC ensures that ForeC programs can be compiled efficiently for parallel execution and be amenable to static timing analysis. ForeC’s main innovation is its shared variable semantics that provides thread isolation and deterministic thread communication. All ForeC programs are correct by construction and deadlock free because no non-deterministic constructs are needed. We have benchmarked our ForeC compiler with several medium-sized programs (e.g., a 2.274-line ForeC program with up to 26 threads and distributed on up to 10 cores, which was based on a 2.155-line non-multi-threaded C program). These benchmark programs show that ForeC can achieve better parallel performance than Esterel, a widely used imperative synchronous language for concurrent safety-critical systems, and is competitive in performance to OpenMP, a popular desktop solution for parallel programming (which implements classical multi-threading, hence is intrinsically non-deterministic). We also demonstrate that the worst-case execution time of ForeC programs can be estimated to a high degree of precision. [ABSTRACT FROM AUTHOR]

Two recent studies addressed the problem of reducing transitional turbulence in applications developed in C# on .NET. The first study investigated this problem in desktop and Web GUI applications and the second in virtual and augmented reality applications using the Unity3D game engine. The studies used similar solution approaches, but both were somewhat embedded in the details of their applications and implementation platforms. This paper examines these two families of applications and seeks to extract the common aspects of their problem definitions and solution approaches and codify the problem-solution pair as a new software design pattern. To do so, the paper adopts Wellhausen and Fiesser’s writer’s path methodology and follows it systematically to discover and write the pattern, recording the reasoning at each step. To evaluate the pattern, the paper applies it to an arbitrary C#/.NET GUI application. The resulting design pattern is named Dynamically Coalescing Reactive Chains (DCRC). It enables the approach to transitional turbulence reduction to be reused across a range of related applications, languages, and user interface technologies. The detailed example of the writer’s path can assist future pattern writers in navigating through the complications and subtleties of the pattern-writing process.

Reactive programming is a popular paradigm that has been used as a new solution in our proposed model for security in the cloud. In this context, we have been able to reduce the execution time compared to our previous work for the model proposed in cloud security, where the control of security depending on the ITSS (IT security specialist) of a certain organization based on selecting options. Some of the difficulties we encountered in our previous work while using traditional programming were the coordination of parallel processes and the modification of real-time data. This study provides results for two methods of programming based on the solutions of the proposed model for cloud security, with the first method of traditional programming and the use of reactive programming as the most suitable solution in our case. While taking the measurements in this paper, we used the same algorithms, and we present comparative results between the first and second methods of programming. The results in the paper are presented in tables and graphs, which show that reactive programming in the proposed model for cloud security offers better results compared to traditional programming. [ABSTRACT FROM AUTHOR]

The proliferation of on-demand internet services delivered over a network of a heterogeneous set of computing devices has created the need for high-performing dynamic systems in real-time. Services such as audio and video streaming, self-driving cars, the Internet of things (IoT), or instant communication on social networks have forced system designers to rethink the architectures and tools for implementing computer systems. Reactive programming has been advocated as a programming paradigm suitable for implementing dynamic applications with complex and heterogeneous architectural needs. However, there is no consensus on the core set of features that a reactive framework must-have. Furthermore, the current set of features proposed in reactive tools seems very restricted to cope with the actual needs for concurrency and distribution in modern systems. In this paper, several alternative semantics for distributed reactive languages are investigated, addressing complex open issues such as glitch avoidance, explicit distribution support, and constructs for explicit time management. First, we propose a reactive event-based programming language with explicit support for distribution, concurrency, and explicit time manipulation (ReactiveXD). Second, we present a reactive event-based semantic framework called Distributed Reactive Rewriting Framework (DRRF). The framework uses rewriting logic to model the components of a distributed base application, observables, and observers, and predicates supporting explicit time manipulation. Finally, to validate the proposal, the paper discusses the specification of the semantics of ReactiveXD and a scenario describing a case of intrusion detection on IoT networks.

Reactive programming is a popular paradigm that has been used as a new solution in our proposed model for security in the cloud. In this context, we have been able to reduce the execution time compared to our previous work for the model proposed in cloud security, where the control of security depending on the ITSS (IT security specialist) of a certain organization based on selecting options. Some of the difficulties we encountered in our previous work while using traditional programming were the coordination of parallel processes and the modification of real-time data. This study provides results for two methods of programming based on the solutions of the proposed model for cloud security, with the first method of traditional programming and the use of reactive programming as the most suitable solution in our case. While taking the measurements in this paper, we used the same algorithms, and we present comparative results between the first and second methods of programming. The results in the paper are presented in tables and graphs, which show that reactive programming in the proposed model for cloud security offers better results compared to traditional programming.

Software-Defined Networking (SDN) enables more dynamic and fine-grained network control. In particular, network operators can route traffic not only based on packet header fields, but also higher-level parameters such as user settings, traffic characteristics, and application-layer information extracted by virtualized network functions such as DPI, firewall and authentication servers. Integrating these higher-level parameters into an SDN programming framework brings substantial benefits but is still missing in the SDN community. In this paper, we articulate the challenges and then propose Trident, a novel unified SDN programming framework. Trident extends algorithmic SDN programming with a new abstraction called stream attribute, which integrates meta parameters into the match-action programming paradigm. Further, Trident adopts the idea of reactive value from function reactive programming, eliminating the complexity of manually handling dynamicity. To effectively and efficiently realize these novel ideas, Trident introduces reactive table as the basic processing unit and develops a domain-specific distributed update protocol to maintain consistency during updates. Evaluations show that Trident puts very little overhead on integrating existing network management tools and network functions, and can handle up to $O(10^{5})$ routing requests per second with $O(100)$ milliseconds latency. [ABSTRACT FROM AUTHOR]

scheduling consists of assignment resources in order to perform a set of tasks in a given time horizon, that optimizes the usage of available resources. Most of researches in open shop district (area) have stationary and certain status, means the situation that all data are certain and won't change in time horizon. Whereas real world scheduling problems are rarely stationary and certain. Reactive programming is a researching district that considers and peruses each changes and uncertain assumptions in real world scheduling problems, so in this paper, first we express a mixed integer programming model to produce­ initial scheduling for open shop problem, in continue we will generalize the presented model to it's equivalent reactive programming with due date's changing. Finally we will express an algorithm due to necessity for revise the primal scheduling. This algorithm and whole models have been implemented and ran in AIMMS software environment and the computational results have been reported.