24,636 research outputs found
Monitoring-Oriented Programming: A Tool-Supported Methodology for Higher Quality Object-Oriented Software
This paper presents a tool-supported methodological paradigm for object-oriented software development, called monitoring-oriented programming and abbreviated MOP, in which runtime monitoring is a basic software design principle. The general idea underlying MOP is that software developers insert specifications in their code via annotations. Actual monitoring code is automatically synthesized from these annotations before compilation and integrated at appropriate places in the program, according to user-defined configuration attributes. This way, the specification is checked at runtime against the implementation. Moreover, violations and/or validations of specifications can trigger user-defined code at any points in the program, in particular recovery code, outputting or sending messages, or raising exceptions.
The MOP paradigm does not promote or enforce any specific formalism to specify requirements: it allows the users to plug-in their favorite or domain-specific specification formalisms via logic plug-in modules. There are two major technical challenges that MOP supporting tools unavoidably face: monitor synthesis and monitor integration. The former is heavily dependent on the specification formalism and comes as part of the corresponding logic plug-in, while the latter is uniform for all specification formalisms and depends only on the target programming language. An experimental prototype tool, called Java-MOP, is also discussed, which currently supports most but not all of the desired MOP features. MOP aims at reducing the gap between formal specification and implementation, by integrating the two and allowing them together to form a system
Proactive Empirical Assessment of New Language Feature Adoption via Automated Refactoring: The Case of Java 8 Default Methods
Programming languages and platforms improve over time, sometimes resulting in
new language features that offer many benefits. However, despite these
benefits, developers may not always be willing to adopt them in their projects
for various reasons. In this paper, we describe an empirical study where we
assess the adoption of a particular new language feature. Studying how
developers use (or do not use) new language features is important in
programming language research and engineering because it gives designers
insight into the usability of the language to create meaning programs in that
language. This knowledge, in turn, can drive future innovations in the area.
Here, we explore Java 8 default methods, which allow interfaces to contain
(instance) method implementations.
Default methods can ease interface evolution, make certain ubiquitous design
patterns redundant, and improve both modularity and maintainability. A focus of
this work is to discover, through a scientific approach and a novel technique,
situations where developers found these constructs useful and where they did
not, and the reasons for each. Although several studies center around assessing
new language features, to the best of our knowledge, this kind of construct has
not been previously considered.
Despite their benefits, we found that developers did not adopt default
methods in all situations. Our study consisted of submitting pull requests
introducing the language feature to 19 real-world, open source Java projects
without altering original program semantics. This novel assessment technique is
proactive in that the adoption was driven by an automatic refactoring approach
rather than waiting for developers to discover and integrate the feature
themselves. In this way, we set forth best practices and patterns of using the
language feature effectively earlier rather than later and are able to possibly
guide (near) future language evolution. We foresee this technique to be useful
in assessing other new language features, design patterns, and other
programming idioms
Italian center for Astronomical Archives publishing solution: modular and distributed
The Italian center for Astronomical Archives tries to provide astronomical
data resources as interoperable services based on IVOA standards. Its VO
expertise and knowledge comes from active participation within IVOA and VO at
European and international level, with a double-fold goal: learn from the
collaboration and provide inputs to the community. The first solution to build
an easy to configure and maintain resource publisher conformant to VO standards
proved to be too optimistic. For this reason it has been necessary to re-think
the architecture with a modular system built around the messaging concept,
where each modular component speaks to the other interested parties through a
system of broker-managed queues. The first implemented protocol, the Simple
Cone Search, shows the messaging task architecture connecting the parametric
HTTP interface to the database backend access module, the logging module, and
allows multiple cone search resources to be managed together through a
configuration manager module. Even if relatively young, it already proved the
flexibility required by the overall system when the database backend changed
from MySQL to PostgreSQL+PgSphere. Another implementation test has been made to
leverage task distribution over multiple servers to serve simultaneously: FITS
cubes direct linking, cubes cutout and cubes positional merging. Currently the
implementation of the SIA-2.0 standard protocol is ongoing while for TAP we
will be adapting the TAPlib library. Alongside these tools a first
administration tool (TASMAN) has been developed to ease the build up and
maintenance of TAP_SCHEMA-ta including also ObsCore maintenance capability.
Future work will be devoted at widening the range of VO protocols covered by
the set of available modules, improve the configuration management and develop
specific purpose modules common to all the service components.Comment: SPIE Astronomical Telescopes + Instrumentation 2018, Software and
Cyberinfrastructure for Astronomy V, pre-publishing draft proceeding (reduced
abstract
Modularizing and Specifying Protocols among Threads
We identify three problems with current techniques for implementing protocols
among threads, which complicate and impair the scalability of multicore
software development: implementing synchronization, implementing coordination,
and modularizing protocols. To mend these deficiencies, we argue for the use of
domain-specific languages (DSL) based on existing models of concurrency. To
demonstrate the feasibility of this proposal, we explain how to use the model
of concurrency Reo as a high-level protocol DSL, which offers appropriate
abstractions and a natural separation of protocols and computations. We
describe a Reo-to-Java compiler and illustrate its use through examples.Comment: In Proceedings PLACES 2012, arXiv:1302.579
- …