75 research outputs found
Reasoning about Knowledge and Strategies under Hierarchical Information
Two distinct semantics have been considered for knowledge in the context of
strategic reasoning, depending on whether players know each other's strategy or
not. The problem of distributed synthesis for epistemic temporal specifications
is known to be undecidable for the latter semantics, already on systems with
hierarchical information. However, for the other, uninformed semantics, the
problem is decidable on such systems. In this work we generalise this result by
introducing an epistemic extension of Strategy Logic with imperfect
information. The semantics of knowledge operators is uninformed, and captures
agents that can change observation power when they change strategies. We solve
the model-checking problem on a class of "hierarchical instances", which
provides a solution to a vast class of strategic problems with epistemic
temporal specifications on hierarchical systems, such as distributed synthesis
or rational synthesis
Transformación de modelos con Eclectic
Versión electrónica de la ponencia presentada en la XVII Jornadas de Ingeniería del Software y de Bases de Datos (JISBD’2012), celebrada en 2012 en AlmeríaLas transformaciones de modelos son un elemento clave del
Desarrollo de Software Dirigido por Modelos. En los últimos años se han
propuesto varios lenguajes de transformación de diferente naturaleza,
siendo cada uno de ellos adecuado para un determinado tipo de tarea de
transformación. Sin embargo, una transformación compleja normalmente
implica abordar una serie de sub-problemas que corresponden a diferentes
estilos de transformación , y por tanto no toda la transformación
puede desarrollarse de forma natural en el lenguaje elegido.
En esta demostración se presentará el entorno de transformación de
modelos Eclectic, que trata de abordar el desarrollo de transformaciones
de modelos ofreciendo una familia de lenguajes de transformación. Cada
lenguaje tiene como objetivo abordar un determinado tipo de transformaciones,
y está específicamente diseñado para ello. La demostración se
ilustrar´a con un ejemplo de aplicación que utiliza diferentes lenguajes, se
mostrar´a el entorno de desarrollo y se comentarán características de la
aproximación tales como interoperabilidad entre lenguajes e integración
con programas Java.Este trabajo ha sido financiado por el Ministerio de Educación y Ciencia (TIN2011-24139) y la Comunidad de Madrid (S2009/TIC-1650)
Towards a family of model transformation languages
Abstract. Many model transformation languages of different nature have been proposed during the last years, each one of them suitable for a certain kind of transformation task. However, a complex transformation problem may not fall into a single transformation category, making the solution written in the chosen transformation language suboptimal, as some concerns cannot be handled naturally. To tackle this issue, we propose to define a model transformation tool as a family of model transformation languages. Each member of the family is a simple language intended to deal with a particular kind of transformation task. In this paper we discuss the different issues involved, such as design decisions, interoperability among languages, and composability. We illustrate the paper with a transformation from UML and OCL to Java, in which languages for pattern matching, mapping, attribution and target-oriented transformations are used. Finally, the approach is validated with a proof-of-concept implementation
Annual Report 1981-1982 & 1982-1983
An administrative report of statistics and information pertaining to the University of North Florida Thomas G. Carpenter Library for the years 1981-1983. The report includes summaries and charts on library budgets, library collection, serials and cataloging workloads, circulation, interlibrary loan, and public services
Model-Driven Aspect-Oriented Software Security Hardening
Security is of paramount importance in software engineering. Nevertheless, security solutions are generally fitted into existing software as an afterthought phase of the development process. However, given the complexity and the pervasiveness of today's software systems, adding security as an afterthought leads to huge cost in retrofitting security into the software and further can introduce additional vulnerabilities. Furthermore, security is a crosscutting concern that pervades the entire software. Consequently, the manual addition of security solutions may result in the scattering and the tangling of security features throughout the entire software design. Additionally, adding security manually is tedious and generally may lead to other security flaws. In this context, the need for a systematic approach to integrate security practices into the early phases of the software development process becomes crucial. In this thesis, we elaborate an aspect-oriented modeling framework for software security hardening at the UML design level. More precisely, the main contributions of our research are the following: (i) We define a UML profile for the specification of security hardening mechanisms as aspects. (ii) We design and implement a weaving framework for the systematic injection of security aspects into UML design models. (iii) We explore the theoretical foundations for aspect matching and weaving. (iv) We conduct real-life case studies to demonstrate the viability and the scalability of the proposed framework
SIMULATION OF A MULTIHOP WIRELESS LAN USING OMNET++
This project serves as a study of implementing multihop design in wireless local area
network (WLAN) technology. The WLAN technology has seen a growth in
popularity over the past few years. This project is divided into two parts. The first
part of the project is to understand the theory behind the WLAN technology. Most of
the materials for this research are taken from lEEEXPLORE website and several
books on wireless LAN and wireless data structure. The fundamental of networking
that touches on OSI layer and data services are also studied. The second part of the
project concentrated on simulating the multihop design. The simulation method uses a
network simulator that can be found freely on the internet. The simulation is
important as we want to simulate the system that has been built and to see whether the
implementation is suitable or not. A good knowledge on C++ language is essential as
most of the building process to achieve a credible simulation uses C++ programming
codes. The network simulator offers a great dynamics to simulate the network and
results can be plotted easily. The main focus of this study is the wireless standard;
IEEE 802.11 that is used for wireless communication. The standard focuses on the
MAC and PHY layers for Access Point based networks and ad hoc networks. There
are certain objectives to be achieved which to study IEEE 802.11 WLANs standard;
to analyze the problems occurred in multihop design in WLANs and to design a
simulation platform to implement multihop design. The methodology used in this
project is simulation using OMNeT++. The result of the simulation showed in a
histogram of the node multihop between the nodes. From this project the possibilities
of implementing a multihop design in WLAN could be analyzed and further works
can be applied to improve its performance
Finding The Lazy Programmer's Bugs
Traditionally developers and testers created huge numbers of explicit tests, enumerating interesting cases, perhaps
biased by what they believe to be the current boundary conditions of the function being tested. Or at
least, they were supposed to.
A major step forward was the development of property testing. Property testing requires the user to write a few
functional properties that are used to generate tests, and requires an external library or tool to create test data
for the tests. As such many thousands of tests can be created for a single property. For the purely functional
programming language Haskell there are several such libraries; for example QuickCheck [CH00], SmallCheck
and Lazy SmallCheck [RNL08].
Unfortunately, property testing still requires the user to write explicit tests. Fortunately, we note there are
already many implicit tests present in programs. Developers may throw assertion errors, or the compiler may
silently insert runtime exceptions for incomplete pattern matches.
We attempt to automate the testing process using these implicit tests. Our contributions are in four main
areas: (1) We have developed algorithms to automatically infer appropriate constructors and functions needed
to generate test data without requiring additional programmer work or annotations. (2) To combine the
constructors and functions into test expressions we take advantage of Haskell's lazy evaluation semantics by
applying the techniques of needed narrowing and lazy instantiation to guide generation. (3) We keep the type
of test data at its most general, in order to prevent committing too early to monomorphic types that cause
needless wasted tests. (4) We have developed novel ways of creating Haskell case expressions to inspect elements
inside returned data structures, in order to discover exceptions that may be hidden by laziness, and to make
our test data generation algorithm more expressive.
In order to validate our claims, we have implemented these techniques in Irulan, a fully automatic tool for
generating systematic black-box unit tests for Haskell library code. We have designed Irulan to generate high
coverage test suites and detect common programming errors in the process
Special Libraries, September 1970
Volume 61, Issue 7https://scholarworks.sjsu.edu/sla_sl_1970/1006/thumbnail.jp
Northeast Harness News, February 1983
https://digitalmaine.com/northeast_harness_news/1113/thumbnail.jp
- …