Hernán Astudillo

Conception, development and implementation of an e-Government maturity model in public agencies

Abstract Governments worldwide are encouraging public agencies to join e-Government initiatives in order to provide better services to their citizens and businesses; hence, methods of evaluating the readiness of individual public agencies to execute specific e-Government programs and directives are a key ingredient in the successful expansion of e-Government. To satisfy this need, a model called the eGovernment Maturity Model (eGov-MM) was developed, integrating the assessment of technological, organizational, operational, and human capital capabilities, under a multi-dimensional, holistic, and evolutionary approach. The model is strongly supported by international best practices, and provides tuning mechanisms to enable its alignment with nation-wide directives on e-Government. This article describes how the model was conceived, designed, developed, field tested by expert public officials from several government agencies, and finally applied to a selection of 30 public agencies in Chile, generating the first formal measurements, assessments, and rankings of their readiness for e-Government. The implementation of the model also provided several recommendations to policymakers at the national and agency levels.

Bridging the gap between software architecture rationale formalisms and actual architecture documents: An ontology-driven approach

Documenting software architecture rationale is essential to reuse and evaluate architectures, and several modeling and documentation guidelines have been proposed in the literature. However, in practice creating and updating these documents rarely is a primary activity in most software projects, and rationale remains hidden in casual and semi-structured records, such as e-mails, meeting notes, wikis, and specialized documents. This paper describes the TREx (Toeska Rationale Extraction) approach to recover, represent and explore rationale information from text documents, combining: (1) pattern-based information extraction to recover rationale; (2) ontology-based representation of rationale and architectural concepts; and (3) facet-based interactive exploration of rationale. Initial results from TRExs application suggest that some kinds of architecture rationale can be semi-automatically extracted from a projects unstructured text documents, namely decisions, alternatives and requirements. The approach and some tools are illustrated with a case study of rationale recovery for a financial securities settlement system.

Visualization and comparison of architecture rationale with semantic web technologies

Deciding how to operationalize non-functional requirements (NFR) is a complex task, and several formalisms have been proposed to represent design decisions and their rationale. Unfortunately, these models can become complex (even unreadable) for designs with many alternatives and/or a well-documented rationale, which makes very hard to review and compare rationale. This paper introduces a Semantic Web-based technique to visualize and compare architecture rationale, combining Softgoal Interdependency Graphs (SIGs) with ontologies reified as named graphs. Reuse of rationale is thus facilitated by allowing architects to understand rationale of previous decisions and/or projects, though automated reuse remains unfeasible until extensive automated capture rationale happens. The approach is illustrated with a case study of Contexta, a museum integration project, using Toeska/Review, a Semantic Web-based tool.

Explicit architectural policies to satisfy NFRs using COTS

Software architecture decisions hinge more on non-functional requirements (NFRs) than on functional ones, since the architecture stipulates which software to build. Model-Driven Architecture (MDA) aims to automate the derivation/generation of software from high level architectural specifications, but most current MDA implementations start from software design (i.e. how to build a software piece) rather than software architecture. This article presents an approach to extend MDA through the concepts of architectural policies and mechanisms. The key ideas are representation of NFRs through architectural concerns using architectural policies, systematic reification of policies into mechanisms, and multi-dimensional description of components as implementations of mechanisms. A detailed illustrative example is provided. Azimut framework realizes these ideas, supports larger-scale work through catalogs of policies, mechanisms and components, and allows traceability and reuse of architecture by enabling these architecture-level descriptions and reasoning using incomplete characterizations of requirements and COTS.

Evaluating alternative COTS assemblies from imperfect component information

Component-based approaches to elaborate software must deal with the fact that in practical settings, components information may be incomplete, imprecise and uncertain, and requirements may be likewise. Architects wanting to evaluate candidate architectures regarding requirements satisfaction need to use whatever information be available about components, however imperfect. Imperfect information can be dealt with using specialized analytical formalisms, such as fuzzy values for imprecision and rough sets for incompleteness; but if used, evaluations need to compare and rank using non-scalar, non-symbolic values. This article presents an approach to systematically describe components’ imperfect information, and to evaluate and rank whole component assemblies, by using credibility values-based “support scores” that aggregate imperfect information about requirements, mechanisms and components. The approach builds on the Azimut framework, which offers progressive refinement of architectural entities via architectural policies, architectural mechanisms, components, and component assemblies. An example of the proposed approach and “what-if” analysis are illustrated.

Web metadata extraction and semantic indexing for learning objects extraction

In this work, a new approach to automatic metadata extraction and semantic indexing for educational purposes is proposed to identify learning objects that may assist educators to prepare pedagogical materials from the Web. The model combines natural language processing techniques and machine learning methods to deal with semi-structured information on the web from which metadata are extracted. Experiments show the promise of the approach to effectively extract metadata web resources containing educational materials.

Identifying emerging security concepts using software artifacts through an experimental case

The development of secure software systems is an increasingly important research topic in software engineering. Several authors have proposed methods, techniques and tools to software development practices in order to identify and/or mitigate security threats. These methods and techniques are based in traditional software engineering artifacts, such as Use Cases, Activity Diagrams and Domain Models. However, the lack of scientific evidence of the quality or efficiency of these methods, leads us to question if this approach is necessary for software security experts. This article proposes an experimental approach to explore if software development artifacts are relevant when making security decisions in software development, and how are they used. We have designed a survey in order to ask these questions to software security and architecture experts. We used the Constant Comparison Method in order to find emerging security theories about software artifacts, grounded in the answers of the experts. Our results add experimental evidence into the use and usefullness of software development artifacts in helping to reduce security vulnerabilities in practice, from the experts point of view. Our results add experimental evidence into the use and usefulness of software development artifacts to evaluate the security from the point of view of the experts. Our evidence suggests that not all software artifacts are equally useful in the design of secure architectures , considering the Use Cases and Class Diagrams as the most useful artifacts according to our respondents. Also, our evidence suggest that experts do not agree in the importance of analyzing security concerns through the whole software life cycle, nor in the abstraction level required for this task.

Web service compositions which emerge from virtual organizations with fair agreements

By wrapping services as active software agents, constantly bidding to consumers requests, self-organizing web service compositions can become real. But they still lack a negotiation capability. In this paper, we add to our Multiagent component composition system (MACOCO) the negotiation behavior of non-functional requirements, by implementing a modified version of the Zeuthen strategy, which allows both parties to get a fair agreement without knowing the utility function of the counterpart. We study the tradeoff of extra overhead versus a fair agreement, showing the feasibility and performance of this approach. A web prototype tool is available.

FIVE ONTOLOGICAL LEVELS TO DESCRIBE AND EVALUATE SOFTWARE ARCHITECTURES

Quality models for software architecture are taxonomies of quality attributes, commonly used to specify and evaluate nonfunctional requirements. Most quality models offer a two-level approach, distinguishing externally observable and internally measurable attributes, yielding stakeholder-specific composite quality criteria. Much effort is devoted to determine which internal attributes influence which external ones, and most models stick to a two-level hierarchy. This paper argues that this apparent dual order obscures the fact that requirements are made by different stakeholder about different subjects, and the word “architecture” means different things to each of them: the organization of a system, a description of such organization, and the process of elaborating such descriptions. The proposed scheme organizes architecture attributes according to five ontological (descriptive) levels, each of them with different concerns, types of users and available measurement techniques: computations, deployables (binaries/configurations), software (texts), specifications (of architecture and/or design), and architecture process. Finally, levels and stakeholders are related to specific architecture views.