99,243 research outputs found
Analyzing Consistency of Behavioral REST Web Service Interfaces
REST web services can offer complex operations that do more than just simply
creating, retrieving, updating and deleting information from a database. We
have proposed an approach to design the interfaces of behavioral REST web
services by defining a resource and a behavioral model using UML. In this paper
we discuss the consistency between the resource and behavioral models that
represent service states using state invariants. The state invariants are
defined as predicates over resources and describe what are the valid state
configurations of a behavioral model. If a state invariant is unsatisfiable
then there is no valid state configuration containing the state and there is no
service that can implement the service interface. We also show how we can use
reasoning tools to determine the consistency between these design models.Comment: In Proceedings WWV 2012, arXiv:1210.578
Are Convolutional Neural Networks or Transformers more like human vision?
Modern machine learning models for computer vision exceed humans in accuracy
on specific visual recognition tasks, notably on datasets like ImageNet.
However, high accuracy can be achieved in many ways. The particular decision
function found by a machine learning system is determined not only by the data
to which the system is exposed, but also the inductive biases of the model,
which are typically harder to characterize. In this work, we follow a recent
trend of in-depth behavioral analyses of neural network models that go beyond
accuracy as an evaluation metric by looking at patterns of errors. Our focus is
on comparing a suite of standard Convolutional Neural Networks (CNNs) and a
recently-proposed attention-based network, the Vision Transformer (ViT), which
relaxes the translation-invariance constraint of CNNs and therefore represents
a model with a weaker set of inductive biases. Attention-based networks have
previously been shown to achieve higher accuracy than CNNs on vision tasks, and
we demonstrate, using new metrics for examining error consistency with more
granularity, that their errors are also more consistent with those of humans.
These results have implications both for building more human-like vision
models, as well as for understanding visual object recognition in humans.Comment: Accepted at CogSci 2021. Source code and fine-tuned models are
available at https://github.com/shikhartuli/cnn_txf_bia
Towards Consistency Management for a Business-Driven Development of SOA
The usage of the Service Oriented Architecture
(SOA) along with the Business Process Management has emerged
as a valuable solution for the complex (business process driven)
system engineering. With a Model Driven Engineering where the
business process models drive the supporting service component
architectures, less effort is gone into the Business/IT alignment
during the initial development activities, and the IT developers
can rapidly proceed with the SOA implementation. However, the
difference between the design principles of the emerging domainspecific
languages imposes serious challenges in the following
re-design phases. Moreover, enabling evolutions on the business
process models while keeping them synchronized with the underlying
software architecture models is of high relevance to the key
elements of any Business Driven Development (BDD). Given a
business process update, this paper introduces an incremental
model transformation approach that propagates this update
to the related service component configurations. It, therefore,
supports the change propagation among heterogenous domainspecific
languages, e.g., the BPMN and the SCA. As a major
contribution, our approach makes model transformation more
tractable to reconfigure system architecture without disrupting its
structural consistency. We propose a synchronizer that provides
the BPMN-to-SCA model synchronization with the help of the
conditional graph rewriting
Property specification and static verification of UML models
We present a static verification tool (SVT), a system that performs static verification on UML models composed of UML class and state machine diagrams. Additionally, the SVT allows the user to add extra behavior specification in the form of guards and effects by defining a small action language. UML models are checked against properties written in a special-purpose property language that allows the user to specify linear temporal logic formulas that explicitly reason about UML components. Thus, the SVT provides a strong foundation for the design of reliable systems and a step towards model-driven security
Web Services: A Process Algebra Approach
It is now well-admitted that formal methods are helpful for many issues
raised in the Web service area. In this paper we present a framework for the
design and verification of WSs using process algebras and their tools. We
define a two-way mapping between abstract specifications written using these
calculi and executable Web services written in BPEL4WS. Several choices are
available: design and correct errors in BPEL4WS, using process algebra
verification tools, or design and correct in process algebra and automatically
obtaining the corresponding BPEL4WS code. The approaches can be combined.
Process algebra are not useful only for temporal logic verification: we remark
the use of simulation/bisimulation both for verification and for the
hierarchical refinement design method. It is worth noting that our approach
allows the use of any process algebra depending on the needs of the user at
different levels (expressiveness, existence of reasoning tools, user
expertise)
Automated verification of model transformations based on visual contracts
The final publication is available at Springer via http://dx.doi.org/10.1007/s10515-012-0102-yModel-Driven Engineering promotes the use of models to conduct the different phases of the software development. In this way, models are transformed between different languages and notations until code is generated for the final application. Hence, the construction of correct Model-to-Model (M2M) transformations becomes a crucial aspect in this approach.
Even though many languages and tools have been proposed to build and execute M2M transformations, there is scarce support to specify correctness requirements for such transformations in an implementation-independent way, i.e., irrespective of the actual transformation language used.
In this paper we fill this gap by proposing a declarative language for the specification of visual contracts, enabling the verification of transformations defined with any transformation language. The verification is performed by compiling the contracts into QVT to detect disconformities of transformation results with respect to the contracts. As a proof of concept, we also report on a graphical modeling environment for the specification of contracts, and on its use for the verification of transformations in several case studies.This work has been funded by the Austrian Science Fund (FWF) under grant P21374-N13,
the Spanish Ministry of Science under grants TIN2008-02081 and TIN2011-24139, and the
R&D programme of the Madrid Region under project S2009/TIC-1650
- …