Leandro Antonelli

Early identification of crosscutting concerns in the domain model guided by states

By nature, software applications involve a myriad of different concerns, which many times crosscut each other. The problem of crosscutting concerns may be solved by aspect oriented techniques which allow to separate core functionality from aspects. This separation must be done as soon as possible during software construction in order to minimize reworking of the software artifacts. Our work identifies aspects very early in the software development process. This paper presents an approach for using the problem domain language captured by the Language Extended Lexicon to identify crosscutting concerns during the domain analysis stage.

CrowdMock: an approach for defining and evolving web augmentation requirements

Abstract Web Applications are accessed by millions of users with different needs, goals, concerns, or preferences. Several well-known Web Applications provide personalized features, e.g., they recommend specific content to users by contemplating individual characteristics or requirements. However, since most Web Application cannot consider all users’ requirements, many developers started to create their own mechanisms for adapting existing applications. One of the most popular techniques for third-party applications adaptation is Web Augmentation, which is based on the alteration of its original user interface, generally by using scripts running at the client side (e.g., the browser). In the context of Web Augmentation, two user roles have emerged: scripters who are those users able to create a new augmentation artifact, and endusers without programming skills, that just consume the artifacts that may satisfy totally or partially their needs. Scripters and end users generally do not know each other, and they have rarely a contact, beyond the fact that they use the same script repositories. When end users cannot get their needs covered with existing artifacts, they claim for new ones by specifying their requirements (called Web Augmentation requirements) using textual descriptions, which are usually hard to interpret by scripters. Web Augmentation requirements are a very particular kind of Web requirements for which there partially exist a solution implemented by the Web site owner, but still users need to change or augment that implementation with very specific purposes that they desire to be available in such site. In this paper, we propose an approach for defining and evolving Web Augmentation requirements using rich visual prototypes and textual descriptions that can be automatically mapped onto running software artifacts. We present a tool implemented to support this approach, and we show an evaluation of both the approach and the tool.

A Platform for Web Augmentation Requirements Specification

Web augmentation has emerged as a technique for customizing Web applications beyond the personalization mechanisms natively included in them. This technique usually manipulates existing Web sites on the client-side via scripts (commonly referred as userscripts) that can change its presentation and behavior. Large communities have surfaced around this technique and two main roles have been established. On the one hand there are userscripters, users with programming skills who create new scripts and share them with the community. On the other hand, there are users who download and install in their own Web Browsers some of those scripts that satisfy their customization requirements, adding features that the applications do not support out-of-the-box. It means that Web augmentation requirements are not formally specified and they are decided according to particular userscripters needs. In this paper we propose CrowdMock, a platform for managing requirements and scripts. The platform allows users to perform two activities: (i) specify their own scripts requirements by augmenting Web sites with high-fidelity mockups and (ii) upload these requirements into an online repository. Then, the platform allows the whole community (users and userscripters) to collaborate improving the definition of the augmentation requirements and building a concrete script that implements them. Two main tools have been developed and evaluated in this context. A client-side plugin called MockPlug used for augmenting Web sites with UI prototype widgets and UserRequirements, a repository enabling sharing and managing the requirements.

Early identification of crosscutting concerns with the Language Extended Lexicon

Large-scale software applications are complex systems that involve a myriad of different concerns. Ideally, these concerns should be organized into separated and different modules, but often some of these concerns overlap and crosscut each other. Such a situation is problematic, as concerns are tangled and scattered into different modules; thus, design and source code become difficult to produce and maintain. The Modularity community has been addressing crosscutting concerns by developing techniques based on separation of concerns. This separation must be done as early as possible during software construction to obtain a more modular and consequently better maintainable software, where evolution is performed with less effort and the possibility of introducing unforeseen mistakes is minimal. In this paper, we propose a strategy to identify crosscutting concerns at requirements level, i.e., at early stages in the software development process, by using the Language Extended Lexicon.

Language Extended Lexicon points: Estimating the size of an application using its language

Estimating the size of a software system is a critical task due to the implications the estimation has in the management of the development project. There are some widely accepted estimation techniques: Function Points, Use Case Points and Cosmic Points, but these techniques can only be applied after the availability of a requirements specification. In this paper, we propose an approach to estimate the size of an application previous to its requirements specification by using the application language itself, captured by the Language Extended Lexicon (LEL). Our approach is based on Use Case Points and on a technique which derives Use Cases from the LEL. The proposed approach provides a measure of the applications size earlier than the usual techniques, thus reducing the effort needed to apply them. An initial experiment was conducted to evaluate the proposal.

Software evolution and design patterns

The livings being are the most complex and evolved machines. They have been evolving during three thousands of millions of years from very simple elements to become sophisticated living machines. The livings being have been improving their constitution and capabilities adapting themselves to the restrictions imposed by the context. These restrictions include the fight for the supremacy within the same species as well as between different ones. This evolution could be performed because every living being has a record about all its essence: the DNA. With all the information of every living being in its DNA, as if it were requirements of a software system, the species have been transferring its constitutional information to its descendent. The concept of reutilization exists in software development too. Nevertheless, the reutilization of living being is extremely superior compared with the reutilization in software engineering. In this paper we analyze the evolution of the living being and with compared it with software development, in order to enrich the reutilization of knowledge in software development.These instructions give you guidelines for preparing papers for IEEE TRANSACTIONS and JOURNALS. Use this document as a template if you are using Microsoft Word 6.0 or later. Otherwise, use this document as an instruction set. The electronic file of your paper will be formatted further at IEEE. Define all symbols used in the abstract. Do not cite references in the abstract. Do not delete the blank line immediately above the abstract, it sets the footnote at the bottom of this column.

Embedding Security Patterns into a Domain Model

Incorporating security patterns at every stage of software development process is one of the most effective ways to build secure software. But how early in the software development process is it possible to apply security patterns? We present here an approach to define security requirements in order to identify security patterns in the very early stages of the software development process, we also show an experience with the method in a limited environment. We use natural language to express requirements (understandable to the Requirements Engineer as well as to the Domain Expert), from which it is possible to identify the security requirements and the corresponding security patterns. Language Extended Lexicon (LEL) and scenarios allow to understand, study, and model the security domain and to represent security patterns. To them we apply the Baseline Mentor Workbench (BMW) for deriving CRC (Class Responsibility Collaboration) cards that represent the security patterns and their contextual model domain. BMW is a tool to assist the domain expert during the requirements engineering stage.

Health Ontology and Information Systems: A Systematic Review

One of the most important aspects for the development of information systems is that they were interoperable, so many initiatives consider that ontologies as useful tools for their development, especially when the application is in complex and dynamic domains as the case of health. In this article, a systematic review (SR) of the existing literature related to ontologies used in the health sector is carried out, not only to interpret and synthesize the available studies but also to provide a framework as a basis for conducting new researches. Recent publications (2010- 2016) in which topics such as the use and impact of ontologies in the development of information systems are discussed, taking into account the organizational objectives and the involved stakeholders were considered. The number of published studies shows a growing interest by researchers because they consider ontologies artifacts that facilitate interoperability, understanding of information and communication structures.

A collaborative approach to describe the domain language through the language extended lexicon

Articulo publicado en: Journal of Object Technology, 15(3) June 2016. DOI: 10.5381/jot.2016.15.3.a3

Software secure building aspects in Computer Engineering

An application includes software and communications infrastructure. As for the latter there own solutions to focus on security, there to build secure software solutions. However, the construction of secure software remains a problem due to a strategy that proposes to incorporate security as an aspect to consider when it has implemented most or all of the functional requirements. The equal treatment of functional and security requirements is the starting point to ensure an improvement in software security. Incorporate security into every stage of Software Development Life Cycle (SDLC) is another criterion that contributes and leads to a conceptually Secure SDLC. To this we must add a special emphasis on including security from the elicitation of requirements. In all cases the security treatment should be approached with criteria to allow evidence to be used best practices for its construction and the best solutions to meet security requirements. This paper presents criteria used to build secure software, incorporating Security Patterns, since requirements elicitation phase.