物件導向軟體之架構(Object-Oriented Software Construction)探討

[서평]「Component Software」 - Beyond Object-Oriented Programming -

A new class of models, formalisms and mechanisms has recently evolved for describing concurrent and distributed computations based on the concept of ``coordination''''. The purpose of a coordination model and associated language is to provide a means of integrating a number of possibly heterogeneous components together, by interfacing with each component in such a way that the collective set forms a single application that can execute on and take advantage of parallel and distributed systems. In this chapter we initially define and present in sufficient detail the fundamental concepts of what constitutes a coordination model or language. We then go on to classify these models and languages as either ``data-driven'''' or ``control-driven'''' (also called ``process-'''' or ``task-oriented''''). Next, the main existing coordination models and languages are described in sufficient detail to let the reader appreciate their features and put them into perspective with respect to each other. The chapter ends with a discussion comparing the various models and some conclusions.

/pdf/coordination-models-and-languages-4p4lzj3oar.pdf

Coordination models and languages

A super-peer is a node in a peer-to-peer network that operates both as a server to a set of clients, and as an equal in a network of super-peers. Super-peer networks strike a balance between the efficiency of centralized search, and the autonomy, load balancing and robustness to attacks provided by distributed search. Furthermore, they take advantage of the heterogeneity of capabilities (e.g., bandwidth, processing power) across peers, which recent studies have shown to be enormous. Hence, new and old P2P systems like KaZaA and Gnutella are adopting super-peers in their design. Despite their growing popularity, the behavior of super-peer networks is not well understood. For example, what are the potential drawbacks of super-peer networks? How can super-peers be made more reliable? How many clients should a super-peer take on to maximize efficiency? we examine super-peer networks in detail, gaming an understanding of their fundamental characteristics and performance tradeoffs. We also present practical guidelines and a general procedure for the design of an efficient super-peer network.

Designing an Super-Peer Network

All one needs to know about fog computing and related edge computing paradigms: A complete survey

Continuous reasoning has proven effective in incrementally analysing changes in application codebases within Continuous Integration/Continuous Deployment (CI/CD) software release pipelines. In this article, we present a novel declarative continuous reasoning approach to support the management of multi-service applications over the Cloud-IoT continuum, in particular when infrastructure variations impede meeting application's hardware, software, IoT or network QoS requirements. We show how such an approach brings considerable speed-ups compared to non-incremental reasoning.

Continuous Reasoning for Managing Next-Gen Distributed Applications.

https://www.di.unipi.it/~brogi/papers/BBT05.pdf

A framework for specifying and verifying the behaviour of open systems

Cloud applications typically consist of multiple interacting components, each requiring a virtualised runtime environment providing the needed software support (eg, operating system, libraries) In this paper, we show how TOSCA and Docker can be effectively exploited to orchestrate multi-component applications, even if their (runtime) specification is incomplete More precisely, we first propose a TOSCA-based representation for multi-component applications, and we show how to use it to specify only the components forming an application We then present a way to automatically complete TOSCA application specifications, by discovering Docker-based runtime environments that provide the software support needed by the application components We also discuss how the obtained specifications can be automatically orchestrated by existing TOSCA engines

From (Incomplete) TOSCA Specifications to Running Applications, with Docker

We provide a simple formulation of a framework where three main extensions of logic programming for non-monotonic reasoning are treated uniformly: Negation-by-default, explicit negation and abduction. The resulting semantics is purely model-theoretic and gives meaning to any consistent abductive logic program. Moreover, it embeds and generalises existing semantics which deal with negation and abduction separately. The abductive framework is equipped with a correct top-down proof procedure.

An Abductive Framework for Extended Logic Programming

We present a methodology for the automated selection and aggregation of (Web) services with the purpose of satisfying client queries. A key ingredient of our approach is the notion of service contract, which consists of signature (WSDL), 
ontology information (OWL), and behaviour specification (YAWL). 
The methodology inputs a registry of service contracts and a client service contract, and it automatically generates aggregated contracts that fulfil the request. By trace inspection we first individuate candidate sets of contracts that 
could satisfy the query collectively. For each candidate set, we generate the contract of the aggregate by suitably building its control- and data-flow, and we verify whether it actually complies with the request.

Antonio Brogi

Papers

Continuous Reasoning for Managing Next-Gen Distributed Applications.

A framework for specifying and verifying the behaviour of open systems

From (Incomplete) TOSCA Specifications to Running Applications, with Docker

An Abductive Framework for Extended Logic Programming

Contract-based Service Aggregation