Real-time collaborative programming tools synchronize source code as text, propagating keystrokes or text patches to other collaborators. This propagation of unstructured text often leads to syntactically invalid states, because edits take place by character position rather than by syntactic entity. Consequently, our key idea is to propagate syntactically valid changes only. This paper contributes a structure-aware synchronization substrate based on two complementary representations and a propagation algorithm: (i) A Lossless Syntax Tree stores source code in structured form while preserving program trivia, like whitespace and comments. This is necessary because collaborators must be able to reconstruct byte-identical source text from propagated (structural) changes; (ii) A Stable Syntax Tree extends this representation with persistent node identifiers to enable robust structural diffing between successive versions; (iii) Our propagation algorithm derives deterministic structural edit scripts for the following operations: insert, delete, move, and update. The algorithm can be used across grammars, because a lightweight per-language specification guides the stable reuse of node identifiers. The biggest achievement of our approach is to take unstructured text changes and extract structural edit operations that provide syntactically correct source code changes. We formalize our proposed representations, show how diffing extracts structural edits, and how these edit scripts are applied at the collaborator. Particularly complex is the resulting move of subtrees. Our approach minimizes within-parent move noise using a per-parent Longest Increasing Subsequence. We evaluate our approach using two languages (Java and JavaScript), three file sizes (small/medium/large), and five edit scenarios. Across all scenarios we observe byte-identical collaboration, node identity stability, and deterministic edit scripts. We demonstrate that applying Longest Increasing Subsequence is necessary for canonical minimality under sibling moves. We furthermore demonstrate that tree diffing cost is structure-sensitive: per-node cost increases with sibling fanout rather than depth. 95th percentile (p95) of end-to-end latencies meet the ≤ 1 second delay budget for small and medium files in both languages. Large Java is near 1 second (p95 ≈ 1.22 seconds) while JavaScript exceeds the 2 seconds hard-cap (p95 ≈ 2.86 seconds). Overall, our approach provides a deterministic, language-portable substrate for structure-aware real-time collaborative programming that separates structural propagation from unstructured keystrokes to preserve code correctness and developer intent.

Multiple programming tasks require synchronous collaboration between developers, giving rise to real-time collaborative programming tools that enable simultaneous editing of shared source code. However, most existing tools operate at the text level, propagating every keystroke–including syntactically invalid ones–without considering program structure. This results in excessive communication overhead, frequent propagation of build-breaking states, and poor synchronization. A major consequence is noticeable lag, especially under unstable network conditions, as collaborators are overwhelmed with unnecessary updates that disrupt their workflow and degrade the shared coding experience. In this paper, we introduce a novel structure-aware propagation model that transmits only syntactically valid code changes. For evaluation we implemented our tool as an IntelliJ plugin and evaluate it against three industry-standard tools–VS Code Live Share, Code With Me, and Replit–across eight representative programming scenarios. Our results show that it significantly lowers the number and size of propagated messages while maintaining consistent, buildable program states. Our findings demonstrate the potential of structure-aware propagation as a foundation for the next generation of real-time collaborative programming environments.

Sensor node faults are a serious threat to wireless sensor networks. They can cause node crashes or lead to the transmission of corrupted data. Especially the latter endangers the quality of subsequent data analyses. Most related fault detection approaches consider the sensor nodes as black boxes. They neglect vital information available on the node level. Consequently, most of these approaches can not distinguish between (i) irregular but correctly sensed data events and (ii) data corruption caused by soft faults. In contrast, our contribution integrates node-level diagnostics with the characteristics of the sensor data. We utilize this node-level diagnostic information to present our fault detection approach. Based on simulations and practical experiments, we show the correctness and efficiency of our approach. The results show that our approach offers a high fault detection rate and can differentiate between events and faults. Furthermore, it consumes a justifiably small overhead of resources and energy.

Over the last years, a significant amount of research papers based their practical evaluation of wireless sensor network-related topics on deployments consisting of Arduino-based sensor nodes. Arduino, on the other hand, offers prototyping boards not tailored for in-the-field deployments. Also, the boards are not specifically designed for ultra low power operation required for long-lasting wireless sensor nodes.We consequently raise the question, whether Arduino is indeed a suitable platform for wireless sensor nodes. For this reason, we evaluated recent Arduino boards by (i) comparing their specifications with common sensor nodes and (ii) analyzing their power consumption in active as well as different sleep modes. Additionally, we evaluated the software components provided by Arduino (i.e., bootloader and libraries).In conclusion, Arduino offers an easy-to-use and cheap basis for early development or analysis, but it falls short in terms of high power consumption as well as issues caused by the bootloader and other integrity issues in the libraries. Therefore, Arduino may be suitable to support the sensor node development but has noticeable drawbacks for actual deployments.

Faults in wireless sensor nodes tend to be the norm rather than the exception. Our paper addresses the following problems: How can we make sure the sensed data has not been distorted by faults? And when we experience anomalies in the sensed data, how can we distinguish between rare but correctly measured events and incorrect data due to faults? The focus of this paper is specifically on soft faults, because (i) they deteriorate the data quality and (ii) are hard to distinguish from irregular but correct events. Many papers on how to detect soft faults have been proposed, but they mostly rely on assumptions on the network's deployment or the nature of the collected data. Therefore, they are insufficient as they can miss faults or misinterpret correct data. In this paper, our key idea is to augment the existing fault-detection approaches with node-level information as additional input. Our contribution is to show the existence of such node-level information that can improve (i) the detection of soft faults and (ii) the distinction between faults and events. This node-level information - called fault indicators - can then be included in existing fault detection schemes. Based on practical experiments, we show that using such fault indicators indeed improves the detection rate and reduces the risk of missing fault-induced variations of sensor data.

Wireless sensor networks play an important role in today's world: When measuring physical conditions, the quality of the sensor readings ultimately impacts the quality of various data analytical services. To maintain data correctness and quality, run-time measures such as anomaly detection techniques are gaining significance. In particular, the detection of threatening node anomalies caused by sensor node faults has become a crucial task.

Today's Internet-scale computing systems often run at a low average load with only occasional peak performance demands. Consequently, computing resources are often overdimensioned, leading to high costs. While load control techniques between clients and servers can help to better utilize a given system, these techniques can place a significant communication and computation load on servers. To improve on these issues, we contribute with scalable techniques for client-request rate control, achieved through integration of (i) a scalable distributed feedback channel to transmit control information from the server to the clients with (ii) decoupling strategies that allow to constrain and filter client requests directly at the client, illustrated in the area of first-price sealed-bid online auctions, and (iii) a PID (Proportional-Integral-Derivative) controller that adaptively controls the input parameters of those decoupling strategies to facilitate an optimal server utilization. In contrast to related work, we can hence optimize server load directly at the source through rate control of the clients. Our evaluations show that this setup supports large sets of clients before the controller becomes unstable.

Abstract—Online auctions of governmental bonds and CO2 certificates are challenged by high availability requirements in face of high peak loads around the auction deadline. Traditionally, these requirements are addressed by cluster solutions. However, with strong requirements regarding hard-ware ownership and only a few auctions per owner per year hardware clusters are a rather ineffective solution. Consequently, we contribute with a solution that alleviates the dependability problems by shifting them into the security domain: Key idea is to provide a secure timestamp service that allows users to place bids locally until the deadline, independent of server availability. This allows to mitigate peak-loads and network or server outages as the transfer of bids to the server can be delayed until after a performance peak or the repair of a failed component. In this paper in particular, we contribute with a secure time synchronization and timestamping protocol tailored to online auctions where we apply secure timestamps on smart cards locally connected to the bidder’s computer. Moreover, our timestamping protocol is robust with respect to man-in-the-middle delay attacks. Finally, we prove the feasibility of our approach based on a.NET smart card implementation and conclude with a discussion of current smart card limitations.

The security of electronic transactions depends on the security of the user's terminal. An insecure terminal may allow an attacker to create or manipulate transactions. Several techniques have been developed that help to protect transactions performed over insecure terminals. TAN codes, security tokens, and smart cards prevent an attacker who obtained the user's password from signing transactions under the user's identity. However, usually these techniques do not allow a user to assert that the content of a transaction has not been manipulated. This paper contributes with the QR-TAN authentication technique. QR-TANs are a transaction authentication technique based on two-dimensional barcodes. Compared to other established techniques, QR-TANs show three advantages: First, QR-TANs allow the user to directly validate the content of a transaction within a trusted device. Second, validation is secure even if an attacker manages to gain full control over a userpsilas computer. Finally, QR-TANs in combination with smart cards can also be utilized for offline transactions that do not require any server.

Distributed real-time automotive embedded systems have to be highly dependable as well as cost-efficient due to the large number of manufactured units. To close the gap between raising complexity and cutting costs, upcoming software standards like AUTOSAR introduce a clear separation of concerns into their system architecture. An AUTOSAR application is built from components that deal with business logic only whereas infrastructural services are provided by standardized middleware. Unfortunately, this middleware tends to be heavy-weight due to its coarse-grained layered design. By applying a component based design to AUTOSAR's middleware, a custom-tailored version for each specific application and system node can be built to overcome this problem. This paper demonstrates how to automatically synthesize component based middleware via the connector transformation: component connectors in platform independent application models are utilized to automatically assemble platform- and application specific middleware. As a result, AUTOSAR middleware becomes custom-tailored and hence light-weight and flexible. In addition, the described synthesis algorithm is capable of incorporating timing annotations via interface contracts at model level, and thus reflects upcoming ambitions to cover real-time constraints at middleware level within AUTOSAR. To prove our approach we successfully synthesized middleware for a demonstrator application and compared it to its conventional counterpart.

The complexity of today's embedded real-time systems is continuously growing with high demands on dependability, resource-efficiency, and reusability. Two solution approaches address these needs: First, in the component based software engineering (CBSE) paradigm, software is decomposed into self-contained components with explicit interactions and context dependencies. Connectors represent the abstraction of interactions between these components. Second, components can be shifted from software to reconfigurable hardware, typically field programmable gate arrays (FPGAs), in order to meet real-time constraints. This paper proposes a component-based concept to support efficient hardware/software co-design: A hardware component together with the hardware/software connector can seamlessly replace a software component with the same functionality, while the particularities of the alternative interaction are encapsulated in the component connector. Our approach provides for tools that can generate all necessary interaction mechanisms between hardware and software components. A proof-of-concept application demonstrates the advantages of our concept: Rapid change and comparison of different partitioning decisions due to automated and faultless generation of the hardware/software connectors.

Integrity constraints are an important means to discover and specify application requirements. Although they are explicitly available and discussed during the system analysis and design phases, the constraint validation functionality is generally still tangled with other implementation code, e.g., the business logic, in today's systems. We contribute with an approach to decouple the integrity constraints from the business logic as well as the setpoints of constraint validation from the business activities. This allows us to balance dependability with respect to node and link failures by temporarily relaxing constraint consistency. Our prototype implementation indicates that this approach is typically worth its effort in systems where availability is of higher priority than strict consistency and a roll-forward approach to system repair, e.g., through compensating actions, is preferred over generic rollback-based solutions

Replication is used to enhance availability and performance in distributed systems. Replica consistency and data integrity (constraint consistency) are correctness criteria for data-centric distributed systems. If consistency needs to be ensured all time, such systems soon become (partially) unavailable if node and link failures occur. However, some applications exist (e.g., in control engineering) where consistency can be temporarily relaxed during degradation in order to achieve higher availability. Recently we proposed adaptive voting (AV), a novel replication protocol based on traditional quorum consensus (voting) that allows the configuration of this trade-off. AV allows non-critical operations (that cannot violate critical constraints) even if no quorum exists. Since this might impose replica conflicts and data integrity violations, different reconciliation policies are needed to re-establish correctness at repair time. The contribution of this paper is two-fold: First, we present an availability analysis of AV. Second, we present performance measurements of AV from our .NET-based proof-of-concept implementation. The availability analysis shows that AV provides better availability than traditional voting if (i) some data integrity constraints of the system are relaxable and (ii) reconciliation time is shorter than degradation time. The performance results indicate that a read-one/write-all configuration of AV is fastest for write-operations that involve checking of inter-object constraints and thus implicitly include read operations

To reduce cost and time to market of automotive software systems and simultaneously increase the products' quality, the component paradigm has achieved broad acceptance within the automotive industry over the last few years. This fact is reflected by upcoming domain specific software standards like AUTOSAR. In AUTOSAR application concerns are covered by software components, while infrastructural ones are handled within layered component middleware. The so obtained separation of concerns leads to an increase in application quality, reusability and maintainability, and hence to a reduction of cost and time to market. This paper contributes with the consequent application of the component paradigm to AUTOSAR's layered middleware, thereby gaining all benefits of CBSE not only for the application level, but for the whole automotive software system. The introduced component model for middleware components can flexibly be used to build resource-aware, AUTOSAR compliant, component middleware for distributed automotive software systems and can seamlessly be integrated within the AUTOSAR system architecture.

Integrity is a dependability attribute partially ensured through runtime validation of integrity constraints. A wide range of different constraint validation approaches exists-ranging from simple if conditions over explicit constraint validation methods and contract specifications to constraints as first class runtime entities of an application. However, increased support for explicitness and flexibility often comes at the price of increased performance costs. To address this issue, we contribute with an overview and evaluation of different constraint validation approaches for the Java programming language with respect to implementation, maintainability and performance. Our results show that the benefits of some of the more advanced approaches are certainly worth their costs by introducing a runtime overhead of only two to ten times the runtime of the fastest approach while other approaches introduce runtime overheads of more than 100, which might be simply too slow in certain applications.

Dependability is one of the most important challenges for service-oriented architectures if their success shall continue in critical settings such as air traffic control or finance and banking. Replication of services and the underlying resources is one of the primary fault tolerance techniques for achieving dependability. While replication is well known in traditional fields (e.g. databases), it is rather in its infancy in service-oriented environments. Thus, in order to reduce the dependability gap we are currently facing in service-oriented environments, we contribute with a replication middleware for Web services which is built upon the Java-based Axis2 SOAP engine and provides a variant of primary-backup replication. Performance evaluations of our middleware implementation show the relatively low overhead of replication if the number of replicas is small.

Replication combined with explicit management of data integrity constraints can be used to enhance availability of object-oriented, data-centric distributed systems when node and link failures occur. Our approach enhances availability by temporarily relaxing non-critical data integrity constraints during degraded situations. This requires new kinds of optimistic replication protocols that support the configuration of this trade-off. The contribution of this paper is a replication model called availability/consistency balancing replication model that allows replicas to diverge in degraded situations if data integrity can be temporarily relaxed and re-establishes both replica consistency and data integrity during repair time. The primary-per-partition-protocol and adaptive voting are two concrete protocols following our model. The feasibility of our approach has been shown by several prototype implementations.

During the last years, component based software development has become a well accepted software engineering paradigm within the automotive industry. This fact is not only reflected by upcoming development tools but also by newly arising automotive software standards. In component based software engineering, applications are built by assembling small reusable building blocks, the components. Typically more than one component implementation meets the application developer's requirements, so proper selection of the assembled components becomes a key element of the whole procurement and engineering process. This paper's contribution is twofold: First, a basic set of performance and dependability metrics and measures for automotive components is identified. Second, a unified benchmarking process is proposed, that allows an unambiguous comparison of distinct component implementations of a given component class.

Replication is a primary means to achieve fault tolerance in distributed systems. While replication techniques are well known and have been widely applied in distributed object and database systems, they have not yet been extensively used in service oriented systems. However, if the success of service oriented computing shall continue in critical settings, replication middleware will play a crucial role in service oriented infrastructures. Thus, we contribute with a discussion of our experiences in building distributed object and service replication middleware and present the main lessons learned. Our conclusions are drawn from several replication middleware implementations built upon J2EE, .NET, CORBA, and Axis2.

We present a system architecture which facilitates enhanced availability of tightly coupled distributed systems by temporarily relaxing constraint consistency. Three different types of consistency are distinguished in tightly coupled distributed systems - replica consistency, concurrency consistency, and constraint consistency. Constraint consistency defines the correctness of the system with respect to a set of data integrity rules (application defined predicates). Traditional systems either guarantee strong constraint consistency or no constraint consistency at all. However, a class of systems exists, where data integrity can be temporarily relaxed in order to enhance availability, i.e. constraint consistency can be traded against availability. This allows for a context- and situation-specific optimum of availability. This paper presents the basic concepts of the trading process and the proposed system architecture to enable a fine-grained tuning of the trade-off in tightly coupled distributed systems.

Data integrity is one of the dependability attributes in data-centric applications. However, applications exist, e.g., safety or mission critical systems, where availability is more important for dependability than strict data integrity. Consequently, in such systems availability can be increased by temporarily relaxing data integrity. Potential inconsistencies are accepted by constraint validation on replicated copies, which are potentially stale in the face of network partitions. Such consistency threats need to be bound and eventually resolved during reconciliation. The contribution of this paper is a solution approach to this trade-off between availability and integrity by means of explicit runtime-management of data integrity constraints and consistency threats as well as reconciliation support

Higher availability and better performance of data-centric applications can be achieved by replication of objects or data items. If data integrity, a correctness criterion for such systems, needs to be maintained even during degraded situations (node or link failures) the system soon becomes (partially) unavailable. However, some applications exist (e.g., in control engineering) where data integrity can be relaxed for higher availability during degraded situations. Traditional replication models do not support the balancing of these two properties. In this paper, we present a novel replication model that (i) allows replicas to diverge if data integrity can be temporarily relaxed and (ii) re-establishes both replica consistency and data integrity during repair time

Converging networks destined to handle voice and data traffic have created a need for novel transmission quality planning. In most cases, the end-to-end communication path requires measurement for tuning and continuous maintenance to achieve acceptable quality of service integration. Several sources of latency within a local network communication path are beneath notice or remain undiscovered when doing such measurements, thus biasing the result. We discuss such relevant sections and introduce a method that takes these sources into account to receive a more accurate measurement. Validation shows that this method has the performance and accuracy to evaluate quality of service limitations from any point in a network. This enables a more aimed and efficient tuning of local area networks destined to carry real-time services.

Our case study provides the most important conceptual lessons learned from the implementation of a Distributed Telecommunication Management System (DTMS), which controls a networked voice communication system. Major requirements for the DTMS are fault-tolerance against site or network failures, transactional safety, and reliable persistence. In order to provide distribution and persistence both transparently and fault-tolerant we introduce a two-layer architecture facilitating an asynchronous replication algorithm. Among the lessons learned are: component based software engineering poses a significant initial overhead but is worth it in the long term; a fault-tolerant naming service is a key requirement for fail-safe distribution; the reasonable granularity for persistence and concurrency control is one whole object; asynchronous replication on the database layer is superior to synchronous replication on the instance level in terms of robustness and consistency; semi-structured persistence with XML has drawbacks regarding consistency, performance and convenience; in contrast to an arbitrarily meshed object model, a accentuated hierarchical structure is more robust and feasible; a query engine has to provide a means for navigation through the object model; finally the propagation of deletion operation becomes more complex in an object-oriented model. By incorporating these lessons learned we are well underway to provide a highly available, distributed platform for persistent object systems.

Telecommunication applications are inherently distributed and the interface provided to third party applications is often complex and also distributed. Usually, these third party components need only a subset of the provided data, therefore a simple and standardized access method would be preferred. Such an interface is provided by the Lightweight Directory Access Protocol (LDAP) and we designed an LDAP to CORBA (Common Object Request Broker Architecture) gateway acting as a bridge between the involved technologies.

It is well known that company intranets are growing into ubiquitous communications media for everything. As a consequence, network traffic is notoriously dynamic, and unpredictable. In most scenarios, the data network requires tuning to achieve acceptable quality for voice integration. This paper introduces a performance measurement method based on widely used IP protocol elements, which allows measurement of network performance criteria to predict the voice transmission feasibility of a given local area network. The measurement does neither depend on special VoIP (Voice over IP) equipment, nor does it need network monitoring hardware. Rather it uses special payload samples to detect unloaded network conditions to receive reference values. These samples are followed by a typical VoIP application payload to obtain real-world measurement conditions. We successfully validate our method within a local area network and present all captured values that describe important aspects of voice quality.

We use HTML and Java to enable relational databases for the World Wide Web and provide a comparison between both techniques based on practical experiences. We introduce a novel design and implementation technique for database backed Web applications based on a state machine model. The key idea is to create a design language to describe the user interface layout, the functionality and the database transactions in a homogenous way. The implementation of such a system is then composed from several parts with potentially different techniques, for example either a pure HTML interface with all its functionality at the server side or a Java applet with more functionality at the client side. The goal is to generate the different implementations automatically from the design language. With this development framework the design and implementation of various database backed Web applications will be easier, faster and less error prone.