Leveraging Applications of Formal Methods,

Verification and Validation: Engineering

Principles: 9th International Symposium on
Leveraging Applications of Formal Methods, ISoLA
2020, Rhodes, Greece, October 20–30, 2020,
https://textbookfull.com/product/leveraging-applications-of-
Proceedings, Part II Tiziana Margaria download
formal-methods-verification-and-validation-engineering-
principles-9th-international-symposium-on-leveraging-
applications-of-formal-methods-isola-2020-rhodes-greece-oc/

Download more ebook from https://textbookfull.com

 Tiziana Margaria · Bernhard Steffen (Eds.)

Leveraging Applications
of Formal Methods,
LNCS 12477

Verification and Validation

Engineering Principles
9th International Symposium
on Leveraging Applications of Formal Methods, ISoLA 2020
Rhodes, Greece, October 20–30, 2020, Proceedings, Part II
Lecture Notes in Computer Science 12477

Founding Editors
Gerhard Goos
Karlsruhe Institute of Technology, Karlsruhe, Germany
Juris Hartmanis
Cornell University, Ithaca, NY, USA

Editorial Board Members

Elisa Bertino
Purdue University, West Lafayette, IN, USA
Wen Gao
Peking University, Beijing, China
Bernhard Steffen
TU Dortmund University, Dortmund, Germany
Gerhard Woeginger
RWTH Aachen, Aachen, Germany
Moti Yung
Columbia University, New York, NY, USA
More information about this series at http://www.springer.com/series/7407
Tiziana Margaria Bernhard Steffen (Eds.)
•

Leveraging Applications
of Formal Methods,
Verification and Validation
Engineering Principles
9th International Symposium
on Leveraging Applications of Formal Methods, ISoLA 2020
Rhodes, Greece, October 20–30, 2020
Proceedings, Part II

123
Editors
Tiziana Margaria Bernhard Steffen
University of Limerick and Lero TU Dortmund
Limerick, Ireland Dortmund, Germany

ISSN 0302-9743 ISSN 1611-3349 (electronic)

Lecture Notes in Computer Science
ISBN 978-3-030-61469-0 ISBN 978-3-030-61470-6 (eBook)
https://doi.org/10.1007/978-3-030-61470-6
LNCS Sublibrary: SL1 – Theoretical Computer Science and General Issues

© Springer Nature Switzerland AG 2020

This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the
material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation,
broadcasting, reproduction on microfilms or in any other physical way, and transmission or information
storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now
known or hereafter developed.
The use of general descriptive names, registered names, trademarks, service marks, etc. in this publication
does not imply, even in the absence of a specific statement, that such names are exempt from the relevant
protective laws and regulations and therefore free for general use.
The publisher, the authors and the editors are safe to assume that the advice and information in this book are
believed to be true and accurate at the date of publication. Neither the publisher nor the authors or the editors
give a warranty, expressed or implied, with respect to the material contained herein or for any errors or
omissions that may have been made. The publisher remains neutral with regard to jurisdictional claims in
published maps and institutional affiliations.

This Springer imprint is published by the registered company Springer Nature Switzerland AG
The registered company address is: Gewerbestrasse 11, 6330 Cham, Switzerland
 Introduction

It is our responsibility, as general and program chairs, to welcome the participants to

the 9th International Symposium on Leveraging Applications of Formal Methods,
Verification and Validation (ISoLA), planned to take place in Rhodes, Greece, during
October 20–30, 2020, endorsed by the European Association of Software Science and
Technology (EASST).
This year’s event follows the tradition of its symposia forerunners held in Paphos,
Cyprus (2004 and 2006), Chalkidiki, Greece (2008), Crete, Greece (2010 and 2012),
Corfu, Greece (2014 and 2016), and most recently in Limassol, Cyprus (2018), and the
series of ISoLA workshops in Greenbelt, USA (2005), Poitiers, France (2007),
Potsdam, Germany (2009), Vienna, Austria (2011), and Palo Alto, USA (2013).
Considering that this year’s situation is unique and unlike any previous one due to
the ongoing COVID-19 pandemic, and that ISoLA’s symposium touch and feel is much
unlike most conventional, paper-based conferences, after much soul searching we are
faced with a true dilemma. “Virtualizing” the event, as many conferences have done,
violates the true spirit of the symposium, which is rooted in the gathering of com-
munities and the discussions within and across the various communities materialized in
the special tracks and satellite events. Keeping with the physical meeting and holding it
in a reduced form (as many may not be able to or feel comfortable with travel) under
strict social distancing rules may also end up not being feasible. At the time of writing
there is a resurgence of cases in several countries, many nations are compiling “green
lists” of countries with which they entertain free travel relations, and these lists are
updated – most frequently shortened – at short notice, with severe consequence for the
travelers. Many governments and universities are again strengthening the travel
restrictions for their employees, and many of us would anyway apply caution due to
our own specific individual situation.
To be able to react as flexibly as possible to this situation, we decided to split ISoLA
2020 into two parts, one this year and one in October 2021, with the track organizers
deciding when their track will take place. So far both dates have promoters, but it may
still happen that, in the end, the entire event needs to move. All accepted papers are
published in time, but some tracks will present their papers at the 2021 event.
As in the previous editions, ISoLA 2020 provides a forum for developers, users, and
researchers to discuss issues related to the adoption and use of rigorous tools and
methods for the specification, analysis, verification, certification, construction, test, and
maintenance of systems from the point of view of their different application domains.
Thus, since 2004, the ISoLA series of events serves the purpose of bridging the gap
between designers and developers of rigorous tools on one side, and users in engi-
neering and in other disciplines on the other side. It fosters and exploits synergetic
relationships among scientists, engineers, software developers, decision makers, and
other critical thinkers in companies and organizations. By providing a specific,
dialogue-oriented venue for the discussion of common problems, requirements,
vi Introduction

algorithms, methodologies, and practices, ISoLA aims in particular at supporting

researchers in their quest to improve the usefulness, reliability, flexibility, and effi-
ciency of tools for building systems, and users in their search for adequate solutions to
their problems.
The program of the symposium consists of a collection of special tracks devoted to
the following hot and emerging topics:
• Reliable Smart Contracts: State-of-the-art, Applications, Challenges and Future
Directions
(Organizers: Gordon Pace, César Sànchez, Gerardo Schneider)
• Engineering of Digital Twins for Cyber-Physical Systems
(Organizers: John Fitzgerald, Pieter Gorm Larsen, Tiziana Margaria, Jim
Woodcock)
• Verification and Validation of Concurrent and Distributed Systems
(Organizers: Cristina Seceleanu, Marieke Huisman)
• Modularity and (De-)composition in Verification
(Organizers: Reiner Hähnle, Eduard Kamburjan, Dilian Gurov)
• Software Verification Tools
(Organizers: Markus Schordan, Dirk Beyer, Irena Boyanova)
• X-by-Construction: Correctness meets Probability
(Organizers: Maurice H. ter Beek, Loek Cleophas, Axel Legay, Ina Schaefer,
Bruce W. Watson)
• Rigorous Engineering of Collective Adaptive Systems
(Organizers: Rocco De Nicola, Stefan Jähnichen, Martin Wirsing)
• Automated Verification of Embedded Control Software
(Organizers: Dilian Gurov, Paula Herber, Ina Schaefer)
• Automating Software Re-Engineering
(Organizers: Serge Demeyer, Reiner Hähnle, Heiko Mantel)
• 30 years of Statistical Model Checking!
(Organizers: Kim G. Larsen, Axel Legay)
• From Verification to Explanation
(Organizers: Holger Herrmanns, Christel Baier)
• Formal methods for DIStributed COmputing in future RAILway systems (DisCo-
Rail 2020)
(Organizers: Alessandro Fantechi, Stefania Gnesi, Anne Haxthausen)
• Programming: What is Next?
(Organizers: Klaus Havelund, Bernhard Steffen)
With the embedded events:
• RERS: Challenge on Rigorous Examination of Reactive Systems (Falk Howar,
Markus Schordan, Bernhard Steffen)
• Doctoral Symposium and Poster Session (A. L. Lamprecht)
• Industrial Day (Falk Howar, Johannes Neubauer, Andreas Rausch)
 Introduction vii

Colocated with the ISoLA symposium is:

• STRESS 2020 – 5th International School on Tool-based Rigorous Engineering of
Software Systems (J. Hatcliff, T. Margaria, Robby, B. Steffen)
Altogether the ISoLA 2020 proceedings comprises four volumes, Part 1: Verifica-
tion Principles, Part 2: Engineering Principles, Part 3: Applications, and Part 4: Tools,
Trends, and Tutorials, which also covers the associated events.
We thank the track organizers, the members of the Program Committee and their
referees for their effort in selecting the papers to be presented, the local organization
chair, Petros Stratis, and the EasyConferences team for their continuous and precious
support during the entire two-year period preceding the events, and Springer for being,
as usual, a very reliable partner for the proceedings production. Finally, we are grateful
to Kyriakos Georgiades for his continuous support for the website and the program,
and to Markus Frohme and Julia Rehder for their help with the editorial system
Equinocs.
Special thanks are due to the following organization for their endorsement: EASST
(European Association of Software Science and Technology) and Lero – The Irish
Software Research Centre, and our own institutions – TU Dortmund University and the
University of Limerick.
We wish you, as an ISoLA participant, a wonderful experience at this edition, and
for you, reading the proceedings at a later occasion, valuable new insights that hope-
fully contribute to your research and its uptake.

August 2020 Tiziana Margaria

Bernhard Steffen
 Organization

Symposium Chair
Tiziana Margaria University of Limerick and Lero, Ireland

PC Chair
Bernhard Steffen TU Dortmund University, Germany

PC Members
Christel Baier Technische Universität Dresden, Germany
Maurice ter Beek ISTI-CNR, Italy
Dirk Beyer LMU Munich, Germany
Irena Bojanova NIST, USA
Loek Cleophas Eindhoven University of Technology, The Netherlands
Rocco De Nicola IMT Lucca, Italy
Serge Demeyer Universiteit Antwerpen, Belgium
Alessandro Fantechi University of Florence, Italy
John Fitzgerald Newcastle University, UK
Stefania Gnesi CNR, Italy
Kim Guldstrand Larsen Aalborg University, Denmark
Dilian Gurov KTH Royal Institute of Technology, Sweden
John Hatcliff Kansas State University, USA
Klaus Havelund Jet Propulsion Laboratory, USA
Anne E. Haxthausen Technical University of Denmark, Denmark
Paula Herber University of Münster, Germany
Holger Hermanns Saarland University, Germany
Falk Howar Dortmund University of Technology and
Fraunhofer ISST, Germany
Marieke Huisman University of Twente, The Netherlands
Reiner Hähnle Technische Universität Darmstadt, Germany
Stefan Jähnichen TU Berlin, Germany
Eduard Kamburjan Technische Universität Darmstadt, Germany
Anna-Lena Lamprecht Utrecht University, The Netherlands
Peter Gorm Larsen Aarhus University, Denmark
Axel Legay Université Catholique de Louvain, Belgium
Heiko Mantel Technische Universität Darmstadt, Germany
Tiziana Margaria University of Limerick and Lero, Ireland
Johannes Neubauer Materna, Germany
Gordon Pace University of Malta, Malta
Cesar Sanchez IMDEA Software Institute, Madrid, Spain
x Organization

Ina Schaefer TU Braunschweig, Germany

Gerardo Schneider University of Gothenburg, Sweden
Markus Schordan Lawrence Livermore National Laboratory, USA
Cristina Seceleanu Mälardalen University, Sweden
Bernhard Steffen TU Dortmund University, Germany
Bruce Watson Stellenbosch University, South Africa
Martin Wirsing Ludwig-Maximilians-Universität München, Germany
James Woodcock University of York, UK

Reviewers

Aho, Pekka Hungar, Hardi

Aichernig, Bernhard Inverso, Omar
Backeman, Peter Iosti, Simon
Baranov, Eduard Jacobs, Bart
Basile, Davide Jaeger, Manfred
Beckert, Bernhard Jensen, Peter
Bensalem, Saddek Johnsen, Einar Broch
Bettini, Lorenzo Jongmans, Sung-Shik
Beyer, Dirk Jähnichen, Stefan
Bourr, Khalid Kanav, Sudeep
Bubel, Richard Konnov, Igor
Bures, Tomas Kosak, Oliver
Casadei, Roberto Kosmatov, Nikolai
Castiglioni, Valentina Kretinsky, Jan
Ciatto, Giovanni Könighofer, Bettina
Cimatti, Alessandro Lanese, Ivan
Damiani, Ferruccio Lecomte, Thierry
Di Marzo Serugendo, Giovanna Lluch Lafuente, Alberto
Duong, Tan Loreti, Michele
Filliâtre, Jean-Christophe Maggi, Alessandro
Fränzle, Martin Mariani, Stefano
Gabor, Thomas Mazzanti, Franco
Gadducci, Fabio Morichetta, Andrea
Galletta, Letterio Nyberg, Mattias
Geisler, Signe Omicini, Andrea
Gerostathopoulos, Ilias Orlov, Dmitry
Guanciale, Roberto Pacovsky, Jan
Heinrich, Robert Parsai, Ali
Hillston, Jane Peled, Doron
Hnetynka, Petr Piho, Paul
Hoffmann, Alwin Pugliese, Rosario
 Organization xi

Pun, Violet Ka I Trubiani, Catia

Reisig, Wolfgang Tuosto, Emilio
Schlingloff, Holger Ulbrich, Mattias
Seifermann, Stephan Vandin, Andrea
Soulat, Romain Vercammen, Sten
Steinhöfel, Dominic Viroli, Mirko
Stolz, Volker Wadler, Philip
Sürmeli, Jan Wanninger, Constantin
Tiezzi, Francesco Weidenbach, Christoph
Tini, Simone Wirsing, Martin
Tognazzi, Stefano Zambonelli, Franco
Tribastone, Mirco
 Contents – Part II

Automating Software Re-Engineering

Automating Software Re-engineering: Introduction to the ISoLA

2020 Track. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Serge Demeyer, Reiner Hähnle, and Heiko Mantel

Formal Verification of Developer Tests: A Research Agenda Inspired

by Mutation Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Serge Demeyer, Ali Parsai, Sten Vercammen, Brent van Bladel,
and Mehrdad Abdi

Modular Regression Verification for Reactive Systems . . . . . . . . . . . . . . . . 25

Alexander Weigl, Mattias Ulbrich, and Daniel Lentzsch

Finding Idioms in Source Code Using Subtree Counting Techniques . . . . . . . 44

Dmitry Orlov

Parametric Timed Bisimulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

Malte Lochau, Lars Luthmann, Hendrik Göttmann, and Isabelle Bacher

A Unifying Framework for Dynamic Monitoring and a Taxonomy

of Optimizations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Marie-Christine Jakobs and Heiko Mantel

Thirty-Seven Years of Relational Hoare Logic: Remarks on Its Principles

and History . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
David A. Naumann

Safer Parallelization. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

Reiner Hähnle, Asmae Heydari Tabar, Arya Mazaheri,
Mohammad Norouzi, Dominic Steinhöfel, and Felix Wolf

Refactoring and Active Object Languages . . . . . . . . . . . . . . . . . . . . . . . . . 138

Volker Stolz, Violet Ka I Pun, and Rohit Gheyi

Rigorous Engineering of Collective Adaptive Systems

Rigorous Engineering of Collective Adaptive Systems Introduction

to the 3rd Track Edition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Martin Wirsing, Rocco De Nicola, and Stefan Jähnichen

Composition of Component Models - A Key to Construct Big Systems . . . . . 171

Wolfgang Reisig
xiv Contents – Part II

Degrees of Autonomy in Coordinating Collectives

of Self-Driving Vehicles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Stefano Mariani and Franco Zambonelli

Engineering Semantic Self-composition of Services Through Tuple-Based

Coordination. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
Ashley Caselli, Giovanni Ciatto, Giovanna Di Marzo Serugendo,
and Andrea Omicini

A Dynamic Logic for Systems with Predicate-Based Communication . . . . . . 224

Rolf Hennicker and Martin Wirsing

Abstractions for Collective Adaptive Systems . . . . . . . . . . . . . . . . . . . . . . . 243

Omar Inverso, Catia Trubiani, and Emilio Tuosto

Verifying AbC Specifications via Emulation. . . . . . . . . . . . . . . . . . . . . . . . 261

Rocco De Nicola, Tan Duong, and Omar Inverso

Adaptive Security Policies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

Flemming Nielson, René Rydhof Hansen, and Hanne Riis Nielson

Capturing Dynamicity and Uncertainty in Security and Trust

via Situational Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Tomas Bures, Petr Hnetynka, Robert Heinrich, Stephan Seifermann,
and Maximilian Walter

Guaranteeing Type Consistency in Collective Adaptive Systems . . . . . . . . . . 311

Jonas Schürmann, Tim Tegeler, and Bernhard Steffen

Epistemic Logic in Ensemble Specification. . . . . . . . . . . . . . . . . . . . . . . . . 329

Jan Sürmeli

FSCAFI : A Core Calculus for Collective Adaptive Systems Programming . . . 344

Roberto Casadei, Mirko Viroli, Giorgio Audrito, and Ferruccio Damiani

Writing Robotics Applications with X-KLAIM . . . . . . . . . . . . . . . . . . . . . . . 361

Lorenzo Bettini, Khalid Bourr, Rosario Pugliese, and Francesco Tiezzi

Measuring Adaptability and Reliability of Large Scale Systems . . . . . . . . . . 380

Valentina Castiglioni, Michele Loreti, and Simone Tini

Centrality-Preserving Exact Reductions of Multi-Layer Networks . . . . . . . . . 397

Tatjana Petrov and Stefano Tognazzi

Towards Dynamic Dependable Systems Through Evidence-Based

Continuous Certification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
Rasha Faqeh, Christof Fetzer, Holger Hermanns, Jörg Hoffmann,
Michaela Klauck, Maximilian A. Köhl, Marcel Steinmetz,
and Christoph Weidenbach
 Contents – Part II xv

Forming Ensembles at Runtime: A Machine Learning Approach . . . . . . . . . . 440

Tomáš Bureš, Ilias Gerostathopoulos, Petr Hnětynka, and Jan Pacovský

Synthesizing Control for a System with Black Box Environment, Based

on Deep Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
Simon Iosti, Doron Peled, Khen Aharon, Saddek Bensalem,
and Yoav Goldberg

A Formal Model for Reasoning About the Ideal Fitness in Evolutionary

Processes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
Thomas Gabor and Claudia Linnhoff-Popien

A Case Study of Policy Synthesis for Swarm Robotics . . . . . . . . . . . . . . . . 491

Paul Piho and Jane Hillston

Maple-Swarm: Programming Collective Behavior for Ensembles

by Extending HTN-Planning. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
Oliver Kosak, Lukas Huhn, Felix Bohn, Constantin Wanninger,
Alwin Hoffmann, and Wolfgang Reif

Swarm and Collective Capabilities for Multipotent Robot Ensembles. . . . . . . 525

Oliver Kosak, Felix Bohn, Lennart Eing, Dennis Rall,
Constantin Wanninger, Alwin Hoffmann, and Wolfgang Reif

Author Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541

Automating Software Re-Engineering
 Automating Software Re-engineering
Introduction to the ISoLA 2020 Track

Serge Demeyer1(B) , Reiner Hähnle2(B) , and Heiko Mantel2(B)

1
University of Antwerp, Antwerp, Belgium
[email protected]
2
Technical University Darmstadt, Darmstadt, Germany
{reiner.haehnle,eduard.kamburjan}@tu-darmstadt.de

Abstract. Software Engineering as a discipline and, in particular, as a

research field within Computer Science, is still mainly focused on meth-
ods, techniques, processes, and tools to develop software from scratch. In
reality, however, greenfield scenarios are not the most common ones. It is
important to realize that dynamic evolution of software became a much
more common and relevant issue in recent times, and its importance
keeps growing. Software refactoring, parallelization, adaptation, there-
fore, become central activities in the value chain: automating them can
realize huge gains. Formal approaches to software modeling and analysis
are poised to make a substantial contribution to software re-engineering,
because they are fundamentally concerned with automation and correct-
ness. This potential, however, is far from being realized. Formal methods
tend to aim at software development ab ovo or look at some piece of
given software as a static object. This state of affairs motivated a track
on Automating Software Re-Engineering, where we invited a group of
leading researchers with an active interest in the automation of software
re-engineering to discuss the state of the art.

1 Introduction
Software Engineering as a discipline and, in particular, as a research field within
Computer Science, is still mainly focused on methods, techniques, processes, and
tools to develop software from scratch. In reality, however, greenfield scenarios
are not the most common ones [7]. This has not only to do with the usual
reasons: protection of possibly huge investments made, as well as preservation
of the knowledge embodied in existing software. It is important to realize that
dynamic evolution of software became a much more common and relevant issue
in recent times, and its importance keeps growing, because of these technological
key drivers:

– the advent of massively parallel hardware and the desire to optimally exploit
it by software,
– the need to diversify and customize, particularly, in Internet-of-Things and
Industry 4.0, and
c Springer Nature Switzerland AG 2020
T. Margaria and B. Steffen (Eds.): ISoLA 2020, LNCS 12477, pp. 3–8, 2020.
https://doi.org/10.1007/978-3-030-61470-6_1
4 S. Demeyer et al.

– novel application scenarios for existing software, fueled by digitalization of

everything.

Software refactoring [4], parallelization [1], adaptation [2], therefore, become

central activities in the value chain: automating them can realize huge gains.
Formal approaches to software modeling and analysis are poised to make a
substantial contribution to software re-engineering, because they are fundamen-
tally concerned with automation and correctness. This potential, however, is far
from being realized. The reason is that there is something inherently wrong with
the current focus of formal approaches to software analysis and development.
They tend to aim at software development ab ovo or look at some piece of given
software as a static object [6]. In other words, automated software re-engineering
is usually not on the radar.

2 Track Organization
The situation sketched above was the motivation to submit a track on Automat-
ing Software Re-Engineering to the 9th edition of the International Symposium
On Leveraging Applications of Formal Methods, Verification and Validation
(ISoLA 2020). We invited a group of leading researchers with an active interest
in the automation of software re-engineering. People working on formal founda-
tions, on tools, as well as practitioners of re-engineering, for example, from the
High-Performance Computing or the Industry 4.0 domains. We also broadcasted
an open invitation on several channels with the intent of reaching out to a wider
audience of interested researchers.
In our call for papers, we solicited either research, survey, experience or tool
papers. We did not necessarily seek for new contributions, but also allowed indi-
viduals to shed new insights on results that have been published earlier. The
corona pandemic caused a few organisational issues. But in the end we decided
to proceed with the submission and review process, hoping that we will be able
to have an actual physical meeting.
We received eight submissions. Each paper was reviewed by at least two
experts in the field. We encouraged the reviewers to be inclusive and write con-
structive reviews and we explicitly aimed for non-competitive reviewing. In the
end, we accepted eight submissions that can be classified into research, system-
atization, and tool paper as follows (where some papers fall into more than one
category), see Table 1.

3 Track Contributions
We classified the eight accepted papers into three thematic sessions: the first
group, Verification for Program Analysis encompasses contributions suggesting
verification approaches that, ultimately, will be used to analyse different versions
of a program. The second group is about formal foundations with the eponymous
label. The third group focuses on correct refactoring of concurrent programs.
 Automating Software Re-engineering 5

Table 1. Overview and classification of the papers in the ISoLA ASRE track

Authors Title Classification

Serge Demeyer, Ali Parsai, Formal Verification of Developer Systematization
Sten Vercammen, Tests: A Research Agenda
Brent van Bladel, Inspired by Mutation Testing
Merdhad Abdi
Malte Lochau, Lars Luthmann, Parametric Timed Bisimulation Research
Hendrik Göttmann,
Isabelle Bacher
Dmitry Orlov Finding Idioms in Source Code Research + Tool
using Subtree Counting
Techniques
Reiner Hähnle, Safer Parallelization Research + Tool
Asmae Heydari Tabar,
Arya Mazaheri,
Mohammad Norouzi,
Dominic Steinhöfel, Felix Wolf
Alexander Weigl, Modular Regression Verification Research + Tool
Mattias Ulbrich, for Reactive Systems
Daniel Lentzsch
Marie-Christine Jacobs, A Unifying Framework for Systematization
Heiko Mantel Dynamic Monitoring and a + Research
Taxonomy of Optimizations
David Naumann 37 years of Relational Hoare Systematization
Logic: Remarks on its + Research
Principles and History
Violet Ka I Pun, Volker Stolz, ReAct: Refactoring and Active Research
Rohit Gheyi Object Languages

It is worth observing that many of the papers indeed are motivated by the “key
drivers” of software re-engineering identified in Sect. 1, for example, [5,9] are
concerned with parallel programs, [10,12] have an Industrie 4.0 context, etc.
Below we provide a short summary of each paper. We refer interested readers
to the actual paper later in this volume for more information.

3.1 Verification for Program Analysis

In the paper Formal Verification of Developer Tests: a Research Agenda Inspired

by Mutation Testing [3], five authors from the University of Antwerp present
a research agenda on how formal verification may contribute to verifying test
code. The paper briefly describes five problems from the perspective of mutation
testing, which is a technique to evaluate the fault detection capability of a test
suite, and discusses, for each of these five problems, how formal verification can
be helpful to alleviate the issue.
6 S. Demeyer et al.

In the paper Modular Regression Verification for Reactive Systems [12], three
authors from the Karlsruhe Institute of Technology present an extension on
regression verification proofs specifically geared towards Programmable Logic
Controllers. The approach is incorporated into a tool which chains a series of
conformance checkers (from lightweight to heavyweight) to model check the sub-
goals.
In the paper Finding Idioms in Source Code using Subtree Counting Tech-
niques [11], a single author from National Research University in Moscow pro-
poses an algorithm to find idioms in source code. The algorithm first builds an
abstract syntax tree and then enumerates all subtrees above a certain size. If
the same subtree is found, it is replaced so after the algorithm processed the
whole abstract syntax tree, it results in a large trie structure where common
subtrees are all on the same nodes. The algorithm is implemented in Python 3
and validated on three small open source systems also written in Python.

3.2 Formal Foundations

The paper Parametric Timed Bisimulation [10] by one author from the Uni-
versity of Siegen and three from Technical University of Darmstadt consider
parametric timed automata: a variant of timed automata supporting paramet-
ric time constraints. They lift the definition of timed bisimulation from timed
automata to parametric timed automata. The authors propose an approximation
of this bisimulation that treats parameters as symbols, and they show that this
is a sufficient approximation of the parametric bisimulation. They also propose
a necessary condition that substitutes parameters by values at the end of the
time spectrum.
The paper A Unifying Framework for Dynamic Monitoring and a Taxonomy
of Optimizations [8] by two researchers from Technical University of Darmstadt
provides a framework for runtime monitoring that makes it possible to give
fully formal definitions of soundness for optimizations. In particular, the authors
identify various preconditions to preservation theorems that can be used as suf-
ficient conditions on soundness. The paper closes with a suggested taxonomy
of run time monitoring optimizations that partly is derived from the formal
framework. Several representative optimization approaches from the literature
are classified with respect to the taxonomy.
In the paper Thirty-seven years of relational Hoare logic: remarks on its
principles and history one author from Stevens Institute of Technology revisits
several decades of Relational Hoare Logic, and reminds the community about
highly relevant work that has not received due attention so far. The author revis-
its product constructions for programs that enable one to use traditional Hoare
Logic for relational reasoning, and he points out differences between variants of
such product constructions. The author systematizes proof rules for Relational
Hoare Logic and augments them by a novel rule. Finally, the paper clarifies bet-
ter on how Relational Hoare Logic relates to the use of product programs in
combination with traditional Hoare Logic.
 Automating Software Re-engineering 7

3.3 Formal Verification for Concurrency

In the paper Safer Parallelization [5], six authors from Technical University of
Darmstadt describe a semi-automatic approach to formally prove a suite of pro-
gram transformations that prepare a sequential program for subsequent paral-
lelisation. The approach is supported by a tool (REFINITY) which supports the
Java programming language and is implemented as a front-end to the program
prover KeY.
In the paper ReAct: Refactoring and Active Object Languages [9], two authors
from the Western Norway University of Applied Sciences and one from the
Federal University of Campina Grande, Brazil investigate the impact of well-
known refactorings for sequential OO languages in the context of concurrency.
It focuses on the cooperative scheduling paradigm, because of its formal and
well-understood semantics. This allows to give a formal definition of equivalence
and to argue about correctness of refactorings at least semi-formally. The paper
contains valuable insights about what can (and what can’t) happen when refac-
toring Active Object programs. It is an important step towards providing better
assistance to developers for refactoring concurrent programs. The authors also
argue convincingly that such assistance is necessary.

4 Conclusion

While we were highly satisfied with the breadth, depth, and quality of the con-
tributions, we do realize that this track can only be a (first) snapshot of what
promises to be an exciting, dynamic, and, most of all, practically relevant, new
direction of research: Automating Software Re-Engineering will certainly shape
our research agenda for years to come. We express the hope that it gets due
attention also in the Software Engineering research community at large.

References
1. Atre, R., Jannesari, A., Wolf, F.: Brief announcement: meeting the challenges of
parallelizing sequential programs. In: Scheideler, C., Hajiaghayi, M.T. (eds.) Pro-
ceedings of the 29th ACM Symposium on Parallelism in Algorithms and Architec-
tures, SPAA, Washington DC, USA, pp. 363–365. ACM (2017)
2. Barbier, F., Cariou, E., Goaer, O.L., Pierre, S.: Software adaptation: classification
and a case study with state chart XML. IEEE Softw. 32(5), 68–76 (2015)
3. Demeyer, S., Parsai, A., Vercammen, S., van Bladel, B., Abdi, M.: Formal ver-
ification of developer tests: a research agenda inspired by mutation testing. In:
Margaria, T., Steffen, B. (eds.) ISoLA 2020. LNCS, vol. 12477, pp. 9–24. Springer,
Cham (2020)
4. Fowler, M.: Refactoring: Improving the Design of Existing Code. Object Technol-
ogy Series. Addison-Wesley, Boston (1999)
5. Hähnle, R., Heydari Tabar, A., Mazaheri, A., Norouzi, M., Steinhöfel, D., Wolf,
F.: Safer parallelization. In: Margaria, T., Steffen, B. (eds.) ISoLA 2020. LNCS,
vol. 12477, pp. 117–137. Springer, Cham (2020)
8 S. Demeyer et al.

6. Hähnle, R., Huisman, M.: Deductive software verification: from pen-and-paper

proofs to industrial tools. In: Steffen, B., Woeginger, G. (eds.) Computing and
Software Science. LNCS, vol. 10000, pp. 345–373. Springer, Cham (2019). https://
doi.org/10.1007/978-3-319-91908-9 18
7. Hopkins, R., Jenkins, K.: Eating the IT Elephant: Moving from Greenfield Devel-
opment to Brownfield. IBM Press, Upper Saddle River (2011)
8. Jacobs, M.-C., Mantel, H.: A unifying framework for dynamic monitoring and a
taxonomy of optimizations. In: Margaria, T., Steffen, B. (eds.) ISoLA 2020. LNCS,
vol. 12477, pp. 72–92. Springer, Cham (2020)
9. Ka I Pun, V., Stolz, V., Gheyi R.: ReAct: refactoring and active object languages.
In: Margaria, T., Steffen, B. (eds.) ISoLA 2020. LNCS, vol. 12477, pp. 138–158.
Springer, Cham (2020)
10. Lochau, M., Luthmann, L., Göttmann, H., Bacher, I.: Parametric timed bisimula-
tion. In: Margaria, T., Steffen, B. (eds.) ISoLA 2020. LNCS, vol. 12477, pp. 55–71.
Springer, Cham (2020)
11. Orlov, D.: Finding idioms in source code using subtree counting techniques. In:
Margaria, T., Steffen, B. (eds.) ISoLA 2020. LNCS, vol. 12477, pp. 44–54. Springer,
Cham (2020)
12. Weigl, A., Ulbrich, M., Lentzsch, D.: Modular regression verification for reactive
systems. In: Margaria, T., Steffen, B. (eds.) ISoLA 2020. LNCS, vol. 12477, pp.
25–43. Springer, Cham (2020)
 Formal Verification of Developer Tests:
A Research Agenda Inspired by Mutation
Testing

Serge Demeyer1,2(B) , Ali Parsai1(B) , Sten Vercammen1(B) ,

Brent van Bladel1 , and Mehrdad Abdi1
1
Universiteit Antwerpen, Antwerp, Belgium
{serge.demeyer,ali.parsai,sten.vercammen}@uantwerpen.be
2
Flanders Make vzw, Kortrijk, Belgium

Abstract. With the current emphasis on DevOps, automated software

tests become a necessary ingredient for continuously evolving, high-
quality software systems. This implies that the test code takes a sig-
nificant portion of the complete code base—test to code ratios ranging
from 3:1 to 2:1 are quite common.
We argue that “testware” provides interesting opportunities for for-
mal verification, especially because the system under test may serve as
an oracle to focus the analysis. As an example we describe five com-
mon problems (mainly from the subfield of mutation testing) and how
formal verification may contribute. We deduce a research agenda as an
open invitation for fellow researchers to investigate the peculiarities of
formally verifying testware.

Keywords: Testware · Formal verification · Mutation testing

1 Introduction
DevOps is defined by Bass et al. as “a set of practices intended to reduce the
time between committing a change to a system and the change being placed into
normal production, while ensuring high quality” [6]. The combination of these
practices enables a continuous flow, where the development and operations of
software systems are combined in one seamless (automated) process. This allows
for frequent releases to rapidly respond to customer needs. Tesla, for example,
uploads new software in its cars once every month [30]. Amazon pushes new
updates to production on average every 11.6 s [22].
The key to the DevOps approach is a series of increasingly powerful auto-
mated tests that scrutinise the commits. As a consequence, test code takes a
significant portion of the complete codebase. Several researchers reported that
test code is sometimes larger than the production code under test [13,43,48].
More recently, during a large scale attempt to assess the quality of test code,
Athanasiou et al. reported six systems where test code takes more than 50% of
the complete codebase [5]. Moreover, Stackoverflow posts mention that test to
code ratios between 3:1 and 2:1 are quite common [3].
c Springer Nature Switzerland AG 2020
T. Margaria and B. Steffen (Eds.): ISoLA 2020, LNCS 12477, pp. 9–24, 2020.
https://doi.org/10.1007/978-3-030-61470-6_2
10 S. Demeyer et al.

Knowing about the popularity of automated tests and the sheer size of result-
ing test suites, software engineers need tools and techniques to identify lurking
faults in the test code. The “testware”, as it is called, should be treated as a
regular software system involving requirements, architecture, design, implemen-
tation, quality assurance, and—last but not least—maintenance [15]. Indeed,
we have witnessed first-hand that not all software projects uphold graceful co-
evolution between production code and test code [48]. This effectively means that
the software is vulnerable for extended periods of time whenever the production
code evolves but the test code does not follow (immediately).

Test code (unit-test code in particular) is written in standard programming

languages, thus amenable to formal verification. It is therefore possible to aug-
ment test code with annotations (invariants, pre-conditions) and verify that cer-
tain properties hold: loop termination, post-conditions, . . . [17,21]. Moreover,
most test code follows a quite consistent structure: the setup-stimulate-verify-
teardown (S-S-V-T) cycle [45]. The purpose of statements within the test code
is therefore rather easy to deduce, making it possible to focus the verification
process on the relevant test slices.

The Reach–Infect–Propagate–Reveal criterion (a.k.a. the RIPR model) pro-

vides a fine-grained framework to assess effective tests, or, conversely, weaknesses
in a test suite [27]. It states that an effective test should first of all Reach the fault,
then Infect the program state, after which it should Propagate as an observable
difference, and eventually Reveal the presence of a fault (probably via an assert
statement).

In this position paper we argue that “testware” provides interesting opportu-

nities for formal verification, especially because the system under test may serve
as an oracle to focus the analysis. As an example we describe five common prob-
lems (mainly from the subfield of mutation testing) and how formal verification
may contribute. We deduce a research agenda as an open invitation for fellow
researchers to investigate the peculiarities of formally verifying testware.
The remainder of this paper is organised as follows. Section 2, provides the
necessary background information on formal verification and mutation testing.
Section 3 goes over the five items in the research agenda explaining the prob-
lem and how formal verification of the test code could alleviate the problem.
Section 4 list a few papers which investigated how formal verification could help
in analysing test programs. We conclude with an open invitation to the commu-
nity in Sect. 5.
 Formal Verification of Developer Tests: A Research Agenda 11

2 Background
2.1 Formal Specification and Verification
Formal verification and formal specification are two complementary steps, used
when adopting formal methods in software engineering [18]. During formal spec-
ification one rigorously specifies what a software system ought to do, and after-
wards, during formal verification, one uses mathematical proofs to show that the
system indeed does so. It should come as no surprise that the two steps go hand
in hand, as illustrated by the discovery of a bug in the JDK linked list [20]. In
this paper we restrict ourselves to a particular kind of formal verification—the
ones based on a tool tightly integrated with a normal programming language—
exemplified by KeY [17] and VeriFast [21]. These tools insert special program
statements (pragmas, annotations) into the code to express properties by means
of invariants, pre-conditions, and post-conditions. A series of mathematical the-
orem provers are then used to show that these properties indeed hold.

2.2 Mutation Testing

Mutation testing (also called mutation analysis—within this text the terms are
used interchangeably) is the state-of-the-art technique for evaluating the fault-
detection capability of a test suite [23]. The technique deliberately injects faults
into the code and counts how many of them are caught by the test suite. Within
academic circles, mutation testing is acknowledged as the most effective tech-
nique for a fully automated assessment of the strength of a test suite. The most
recent systematic literature survey by Papadakis et al. revealed more than 400
scientific articles between 2007 and 2016 investigating mutation testing from var-
ious angles [35]. Despite this impressive body of academic work, the technique
is seldom adopted in an industrial setting because it comes with a tremendous
performance overhead: each mutant must be compiled and tested separately [37].
During one of our experiments with an industrial codebase, we witnessed 48 h of
mutation testing time on a test suite comprising 272 unit tests and 5,258 lines of
test code for a system under test comprising 48,873 lines of production code [46].

Example. Throughout this paper, we will use the C++ code in Fig. 1 as a
running example. It scans a vector from back to front, looking for an element.
Upon finding the element, it returns its index (base zero) and −1 if the element
is not found.
Now consider the test suite in Fig. 2. The first test (emptyVector, lines
1–3) checks for the exceptional case of an empty vector. The second test
(doubleOccurrence, lines 5–7), verifies the happy-day scenario: we look for an
element in the vector and it should be found on position 3. This is a very rel-
evant test because it actually looks for an element which appears two times in
the vector and it correctly asserts that it should return the position of the last
occurrence. The third test (noOccurrence, lines 9–11), checks what happens
when we look for an element that is not in the vector, in which case it should
12 S. Demeyer et al.

Fig. 1. C++ code searching for an element in a vector starting at the end
return −1. Executing the test suite shows that all 3 tests pass. When calculating
the code coverage, we even obtain a 100% statement, line and branch coverage.

Fig. 2. Test suite for the findLast in Fig. 1

Terminology. As with every field of active research, the terminology is exten-

sive. Below we list the most important terms readers should be familiar with.

Mutation Operators. Mutation testing mutates the program under test by arti-
ficially injecting a fault based on one of the known mutation operators. A muta-
tion operator is a source code transformation which introduces a change into
the program under test. Typical examples are replacing a conditional opera-
tor (>= into <) or an arithmetic operator (+ into −). The first set of mutation
operators were reported in King et al. [24]. Afterwards, special purpose mutation
operators have been proposed to exercise novel language constructs, such as Java
null-type errors [36] or C++11/14 lambda expressions and move semantics [38].

Killed and Survived (Live) Mutants. After generating the defective version of
the software, the mutant is passed onto the test suite. If a test fails, the mutant
is marked as killed (Killed Mutant). If all tests pass, the mutant is marked as
survived or live (Survived Mutant).
 Formal Verification of Developer Tests: A Research Agenda 13

Consider the mutated example in Fig. 3, where we apply a mutation operator

named “Relational Operator Replacement” (ROR). On line 3, >= is replaced by <
and the complete test suite is executed. One test fails so the mutant is considered
killed; the test suite was strong enough to detect this mutant.

Fig. 3. Killed mutant in findLast from Fig. 1

We again apply a “Relational Operator Replacement” (ROR), this time

replacing >= by > and arriving at the situation in Fig. 4. If we execute the com-
plete test suite, all tests pass so the test suite needs to be strengthened to detect
this mutant.
Examining, why this mutant is not detected shows that the test suite fails
to check for an important boundary condition: looking for an element which
appears on the first position in the vector. If we add an extra test (see Fig. 5)
the test suite now detects the mutant (1 test fails, occurrenceOnBoundary).
Now it is now capable of killing the mutant.

Mutation Coverage. The whole mutation analysis ultimately results in a score

known as the mutation coverage: the number of mutants killed divided by the
total number of non-equivalent mutants injected. A test suite is said to achieve
full mutation test adequacy whenever it can kill all mutants, thus reaching a
mutation coverage of 100%. Such test suite is called a mutation-adequate test
suite.

Reach–Infect–Propagate–Reveal (RIPR). The Reach–Infect–Propagate–Reveal

criterion (a.k.a. the RIPR model) provides a fine-grained framework to assess
weaknesses in a test suite which are conveniently revealed by mutation test-
ing [27]. It states that an effective test should first of all Reach the fault, then
Infect the program state, after which it should Propagate as an observable dif-
ference, and eventually Reveal the presence of a fault (probably via an assert
statement but this depends on the test infrastructure).
14 S. Demeyer et al.

Fig. 4. Survived mutant in findLast in Fig. 1

Fig. 5. Strengtened test suite for findLast

Consider the test suite in Fig. 2 and Fig. 5 together with the mutant that
exposed the weakness in the test suite in Fig. 4. The first test (emptyVector,
lines 1–3) does not even reach the fault injected on line 2. The second test
(doubleOccurrence, lines 5–7), reaches the fault because it executes the faulty
i > 0 condition, but does not infect the program state; so it cannot propagate
nor reveal. The third test (noOccurrence, lines 9–11), infects the program state
because it actually creates a state where the loop counter should have become
0, yet this is never propagated hence not revealed. It is only the fourth test
(occurrenceOnBoundary, lines 13–15) which effectively infects the program state
(i does not become 0), propagates to the output (returns −1) where it is revealed
by the assert statement (expected 0).

Invalid Mutants. Mutation operators introduce syntactic changes, hence may

cause compilation errors in the process. A typical example is the arithmetic
mutation operator which changes a ‘+’ into a ‘−’. This works for numbers but
does not make sense when applied to the C++ string concatenation operator.
If the compiler cannot compile the mutant for any reason, the mutant is consid-
ered invalid and is not incorporated into the mutation coverage.
 Formal Verification of Developer Tests: A Research Agenda 15

Redundant (“Subsumed”) Mutants. Sometimes there is an overlap in which tests

kill which mutants, hence some mutants may be considered redundant. Redun-
dant mutants are undesirable, since they waste resources and add no value to
the process. In addition, they inflate the mutation score because often it is easy
to kill many redundant mutants just by adding a single test case. To express this
redundancy more precisely, the mutation testing community defined the concept
of subsuming mutants.
Take for instance the mutant in Fig. 6, which replaces x[i] == y with x[i]
!= y on line 4. It is an easy to kill mutant as it is killed by three tests (doubleOc-
currence, noOccurrence and occurrenceOnBoundary). The mutant in Fig. 6 is
therefore said to be subsumed by the mutant in Fig. 3. Any test in our test suite
which kills the latter mutant (difficult) one will also kill the former (easy) one.

Fig. 6. Redundant mutant for findLast

Equivalent Mutants. Some mutants do not change the semantics of the program,
i.e. the output of the mutant is the same as the original program for any possible
input. Therefore, no test case can differentiate between a so-called “equivalent
mutant” and the original program. Equivalent mutants are not incorporated
into the mutation coverage. Unfortunately, the detection of equivalent mutants
is undecidable due to the halting problem. Therefore, it is left to the software
engineer to manually weed out equivalent mutants.
Consider again the running example, now in Fig. 7. This time we apply
the Relational Operator Replacement (ROR) on line 2, replacing the == 0 with
<= 0. Executing the test suite shows that all test pass so at first glance we have
a live mutant. However, a deeper analysis shows that since the size of a vector
is always positive, the value of == 0 will always be the same as <= 0. So there
16 S. Demeyer et al.

is no input we can provide to the program under test to kill this mutant. Thus,
this is an equivalent mutant.

Fig. 7. Equivalent mutant of findLast from Fig. 1

3 Research Agenda
3.1 Equivalent Mutants

Equivalent mutants have been heavily studied in the literature as they may
induce heavy overhead on test engineers aiming for 100% mutation coverage [31].
The most pragmatic approach so far has been to compare the generated (byte)
code of the mutated program against the original [34]. Due to compiler opti-
mizations the syntactic differences between the original and mutated program
may disappear and then they are considered trivially equivalent. This allows to
identify the easy cases, however, for the difficult ones, further analysis is required.
A paper by Offutt et al. illustrates how program analysis can help to identify
equivalent mutants by demonstrating that they belong to an infeasible path [33].
The authors argue that a mutant is equivalent if the injected mutant lies on
an infeasible path, thus (according to the RIPR model) the injected mutant can
never propagate to the assert statements that reveals it.

Research Agenda. We would even go one step further and use program verifica-
tion to prove that a mutant is equivalent to the original. And if not, the counter
example should provide us with an extra test that illustrate where they may
differ, hence would strengthen the test suite even further.
 Another Random Document on
Scribd Without Any Related Topics
The Project Gutenberg eBook of La vida en los
campos: novelas cortas
This ebook is for the use of anyone anywhere in the United States
and most other parts of the world at no cost and with almost no
restrictions whatsoever. You may copy it, give it away or re-use it
under the terms of the Project Gutenberg License included with this
ebook or online at www.gutenberg.org. If you are not located in the
United States, you will have to check the laws of the country where
you are located before using this eBook.

Title: La vida en los campos: novelas cortas

Author: Giovanni Verga

Translator: C. Rivas Cherif

Release date: October 24, 2012 [eBook #41161]

Most recently updated: October 23, 2024

Language: Spanish

Credits: Produced by William G. Spahr

*** START OF THE PROJECT GUTENBERG EBOOK LA VIDA EN LOS

CAMPOS: NOVELAS CORTAS ***
(This file was transcribed from Google-digitized images generously
made available by the HathiTrust Digital Library at
www.hathitrust.org)

COLECCIÓN UNIVERSAL

GIOVANNI VERGA

La vida en los campos

NOVELAS CORTAS

La traducción del italiano

ha sido hecha por C. Rivas Cherif.

CALPE
 MADRID, 1920

"Tipográfica Renovación" (C.A.), Larra, 6 y 8 — MADRID.

Nacido en Catania en 1840, Giovanni Verga es en la literatura de la

Nueva Italia genuino representante de la bravía Sicilia en que vió la
luz. Sus primeras obras, influídas del sentimentalismo francés, en
que moría el género romántico, muestran ya, sin embargo, uno de
los caracteres netos de la personalidad de su autor: la lucha contra
el medio ambiente en que viven sus criaturas de ficción. Pero sólo
cuando, apartándose decidido de toda transfusión autobiográfica,
acepta con entusiasmo la fórmula verista del realismo triunfante en
Francia, y con sujeción a ella presenta, en cuadros de un vigor y una
pincelada inusitadas a la sazón, el alma de su pueblo, adquiere
relieve y prestigio singulares el nombre de Giovanni Verga. Data su
primer cuento "siciliano" Nedda, incluído luego en la colección que
hoy traducimos, de 1874. De diez años después es su célebre
Cavalleria rusticana, popularizada en Italia en su forma escénica,
muy posterior, y que ha corrido el mundo entero en la adaptación
musical del compositor Mascagni.
Tienen estas narraciones breves, de concepción casi dramática,
todos los precios y deméritos propios de la escuela realista en que
Verga profesa, con entusiasmos de neófito a veces, según puede
verse en la curiosísima dedicatoria a su contemporáneo el novelista
Salvador Farina, con que comienza L'amante di Gramigna, aquí
incluído.
Figura asimismo en esta serie de LA VIDA EN LOS CAMPOS un
boceto, Fantasticheria, en que el autor esboza en cuatro pinceladas
el paisaje y las figuras que un año más tarde, en 1881, se
convirtieron en la novela I Malavoglia, traducida por nosotros para
este colección con el título de Los Malasangre[1]. La lupa, segundo
cuento de los que hoy ofrecemos, fué asimismo convertido en drama
más tarde.
[1] Colección Universal, números 134, 135, 136 y 137.

LA VIDA EN LOS CAMPOS

INDICE

Los rústicos caballeros ("Cavalleria rusticana")

"La loba"

Nedda

Capricho (Fantastichería)
 Jeli el pastor

"Malpelo" (Rosso Malpelo)

La querida del "Abrojo" (L' amante di

Gramigna)

Guerra de Santos

"Pucherete" (Pentolaccia)

LOS RÚSTICOS CABALLEROS

(Cavalleria rusticana.)
Turiddu Macca, el hijo de la "señá" Anuncia, al volver de servir al rey,
pavoneábase todos los domingos en la plaza, con su uniforme de
tirador y su gorro rojo, que parecía "talmente" el hombre de la
buenaventura cuando saca la jaula de los canarios. A las mozas
íbanseles tras él los ojos, según entraban en misa, recatadas bajo la
mantilla, y los chiquillos revoloteaban como moscas a su alrededor.
Había traído hasta una pipa con el rey a caballo, que parecía de
verdad, y encendía los fósforos en la trasera de los pantalones,
levantando la pierna como si diese un puntapié. Mas, con todo, Lola
la del señor Angel no se dejaba ver ni en misa ni en el balcón: que
se había tomado los dichos con uno de Licodia que era carretero, y
tenía en la cuadra cuatro machos del Sortino. Cuando Turiddu lo
supo, en el primer pronto, ¡santo diablo!, quería sacarle las tripas al
de Licodia; pero no lo hizo, y se desahogó yendo a cantar bajo la
ventana de la bella cuantas canciones de desdenes sabía.
— ¿Es que no tiene nada que hacer Turiddu, el de la "seña" Anuncia
— decían los vecinos —, que se pasa las noches cantando como un
gorrión solitario?
Al cabo, topó con Lola, que volvía del viaje a la Virgen de los
Peligros, y que al verle ni palideció ni se puso colorada, cual si nada
hubiera pasado.
— ¡Ojos que te ven!— le dijo.
— Hola, compadre Turiddu; ya me habían dicho que habías vuelto a
primeros de mes.
— ¡A mí me han dicho otras cosas! — respondió —. ¿Es verdad que
te casas con el compadre Alfio el carretero?
— ¡Si es la voluntad de Dios...! — contestó Lola, juntando sobre la
barbilla las dos puntas del pañuelo.
— ¡La voluntad de Dios la haces con el tira y afloja que te conviene!
¡Y la voluntad de Dios ha sido que yo tenía que venir de tan lejos
para encontrarme con tan buenas noticias, Lola!
El pobrecillo intentaba aún dárselas de valiente; pero la voz casi le
faltaba e iba tras de la moza contoneándose, bailándole de hombro
a hombro la borla del gorro. A ella, en conciencia, le dolía verle con
una cara tan larga; pero no tenía ánimos para lisonjearle con buenas
palabras.
— Oye, compadre Turiddu — le dijo, al fin —, déjame alcanzar a mis
compañeras. ¡Qué dirían en el pueblo si me vieran contigo!...
— Es verdad — respondió Turiddu —. Ahora que te casas con el
compadre Alfio, que tiene cuatro machos en la cuadra, no hay que
dar que hablar a la gente. Mi madre, la pobre, ha tenido que vender
nuestra mula baya y el majuelillo de la carretera mientras yo era
soldado. Pasó el tiempo en que Berta hilaba, y tú ya no te acuerdas
de cuando hablábamos por la ventana del corral ni de cuando me
regalaste el pañuelo aquél, antes de marcharme, que Dios sabe las
lágrimas que lloré en él, al irme tan lejos, tan lejos, que se perdía
hasta el nombre de nuestro pueblo. Ahora, adiós, Lola; hagamos
cuenta que no hay más que decir, y que si te he visto, no me
acuerdo.
La Lola se casó con el carretero, y los domingos se ponía en el
corredor, con las manos en el vientre, para enseñar todos los anillos
de oro que le había regalado su marido. Turiddu seguía paseando
una y otra vez por la calleja, con su pipa en la boca y las manos en
los bolsillos, con aire indiferente y guiñándole a las mozas; pero
roíale por dentro el que el marido de Lola tuviese todo aquel oro y el
que ella fingiese no verle cuando pasaba.
— ¡Se la voy a hacer en sus mismos ojos a esa perra! —
murmuraba.
Frente por frente al compadre Alfio vivía el señor Colás, el viñador,
rico como un cerdo según decían, el cual tenía una hija. Turiddu
tanto dijo y tanto hizo, que intimó con el señor Colás, y comenzó a
andar por la casa y a decirle palabritas dulces a la muchacha.
— ¿Por qué no le dices todas esas cosas tan bonitas a la Lola? —
contestaba Santa.
— ¡La Lola es una señorona! ¡La Lola se ha casado con un rey!
— Yo no merezco reyes...
— Tú vales por cien Lolas, y conozco yo a uno que no miraría a la
Lola ni al santo de su nombre cuando estás tú, porque la Lola no
sirve ni para descalzarte. ¡Qué va a servir!
— La zorra que no podía alcanzar las uvas...
— Dijo: ¡qué guapa estás, rica mía!
— ¡Quietas las manos, compadre Turiddu!
— ¿Tienes miedo de que te coma?
— Ni a ti ni a tu Dios tengo miedo!
— ¡Ya sabemos que tu madre era de Licodia! ¡Tienes sangre de
pelea! ¡Uy, te comería con los ojos!
— Cómeme con los ojos, si quieres, que no me harás migas; pero
mientras, carga con este haz.
— ¡Por ti cargaría yo con la casa entera!
Ella, por no ponerse colorada, le tiró un leño que tenía a mano, y no
le dió por milagro.
— Vamos, despacha, que la charla no gavilla sarmientos.
— Si fuera rico, Santa, buscaría una mujer como tú.
— Yo no me casaré con un rey, como la Lola; pero tengo mi dote
para cuando el Señor me mande novio.
— ¡Ya sabemos que eres rica, ya lo sabemos!
— Pues si lo sabes, despacha, que está para llegar mi padre y no
quiero yo que me encuentre en el corral.
El padre empezaba a torcer el gesto; pero la muchacha no se daba
por enterada, porque la borla del gorro del tirador le había hecho
cosquillas en el corazón y le bailaba continuamente ante los ojos.
Como el padre puso a Turiddu en la puerta, la hija le abrió la
ventana, y todas las noches estaba de charla con él, que no se
hablaba de otra cosa en la vecindad.
— Estoy loco por ti, y hasta el sueño pierdo y el apetito.
— Cháchara.
— ¡Quisiera ser el hijo de Victor Manuel para casarme contigo!
— Cháchara.
— Por la Virgen, que como pan te comería!
— Cháchara.
— ¡Por mi honra te lo juro!
— ¡Ay madre mía!
Lola, que lo oía todo, palideciendo y ruborizándose, escondida tras el
tiesto de albahaca, un día llamó a Turiddu.
— ¡Vaya, compadre Turiddu! ¿Es que ya no se saluda a los amigos?
— ¡Ay! — suspiró el mozo —. ¡Dichoso el que puede saludarte!
— ¡Pues si tal intención tienes, ya sabes donde vivo!... — respondió
Lola.
Turiddu volvió a verla con tanta frecuencia, que Santa se enteró y le
dió con la ventana en los hocicos. Los vecinos le señalaban con una
sonrisa o con un movimiento de cabeza cuando pasaba el tirador. El
marido de Lola andaba por las feries con sus mulas.
— ¡El domingo quiero ir a confesarme, que esta noche he soñado
con uvas negras! — dijo Lola.
— ¡Déjalo, déjalo! — suplicaba Turiddu.
— No, que como se acerca la Pascua, mi marido querría saber por
qué no me confieso.
— ¡Ay! — murmuraba Santa, la del señor Colás, esperando turno de
rodillas ante el confesonario, donde Lola estaba haciendo la colada
de sus pecados—. ¡Por mi alma, que no quiero mandarte a Roma en
penitencia!
El compadre Alfio volvió con sus mulas, cargado de dineros, y trajo a
su mujer un vestido nuevo, muy majo, para las fiestas.
— Haces bien en traerle regalos — le dijo su vecina Santa —,
¡porque mientras estás fuera, tu mujer te adorna la casa!
El compadre Alfio era uno de esos carreteros que llevan la montera a
la oreja, y al oír hablar de su mujer de aquel modo mudó de color,
como si le hubiesen dado una puñalada.
— ¡Santo diablo! — exclamó —. ¡Como no hayas visto bien, no os
dejo ni ojos para llorar a ti y a toda tu parentela!
— ¡No acostumbro llorar yo! — respondió Santa —; ni siquiera he
llorado al ver con estos ojos entrar a Turiddu, el de la "seña"
Anuncia, en casa de tu mujer...
— Está bien — respondió el compadre Alfio —; muchas gracias.
Turiddu, ahora que había vuelto ya el marido, no rondaba de día por
la calleja, y distraía el tedio en la taberna con los amigos. La víspera
de Pascua tenían sobre la mesa un plato de salchicha, cuando
entrando en esto el compadre Alfio, con sólo ver el modo que tuvo
de mirarle, comprendió Turiddu que había ido a arreglar cuentas, y
dejó el tenador en el plato.
— ¿Tienes algo que mandar, compadre Alfio? — le dijo.
— Nada, compadre Turiddu, sino que hace ya tiempo que no te veo
y quería hablarte de lo que sabes.
Turiddu, al pronto, le había ofrecido una copa; pero el compadre
Alfio la rehusó con la mano. Entonces Turiddu se levantó y le dijo:
— Pues aquí me tienes, compadre Alfio.
El carretero le echó los brazos al cuello.
— Si quieres ir mañana a las chumberas de la Canziria, podremos
hablar de nuestro asunto compadre.
— Espérame en la carretera, al salir el sol, e iremos juntos.
Con estas palabras se dieron el beso de desafío, y Turiddu le mordió
la oreja al carretero, haciéndole así promesa solemne de no faltar.
Los amigos, abandonando la salchicha, acompañaron silenciosos a
Turiddu hasta su casa. La "señá" Anuncia, la pobrecilla, esperábale
hasta tarde todas las noches.
— Madre — le dijo Turiddu —, ¿se acuerda cuando me fuí al servicio,
que creía usted que ya no iba a volver? Deme un beso muy fuerte
como entonces, porque mañana temprano tengo que irme muy
lejos.
Antes de ser de día cogió la faca, que había escondido en el heno
cuando se marchó soldado, y se puso en camino hacia las
chumberas de la Canziria.
— ¡Jesús María! ¿Adónde vas tan furioso? — lloriqueaba la Lola a
punto de salir su marido.
— Voy ahí cerca— respondió el compadre Alfio —; pero mejor te
sería que no volviese nunca.
Lola, en camisa, rezaba a los pies de la cama, llevándose a los labios
el rosario que le había traído fray Bernardino de los Santos Lugares,
cuantas avemarías podía.
— Compadre Alfio — comenzó Turiddu luego que hubieron hecho un
buen trecho del camino él y su compañero, que iba callado y con la
montera sobre los ojos —, como hay Dios que se que no tengo
corazón y que me dejaría matar. Pero antes de salir he visto a mi
vieja, que se ha levantado para verme marchar, que el pretexto de
arreglar el gallinero, como si se lo diera el corazón, y, como hay
Dios, que te mataré como perro por no hacer llorar a mi viejecica.
— Eso está muy bien — respondió el compadre Alfio quitándose el
farseto —; así pincharemos con fuerza los dos.
Ambos eran buenos esgrimidores. Turiddu tiró el primer golpe y
alcanzó al otro en un brazo; al repetir, tiró a la ingle.
— ¡Ah, compadre Turiddu! ¿Es que de veras quieres matarme?
— Si, ya te lo he dicho; acabo de ver a mi vieja en el gallinero, y me
parece tenerla continuamente delante.
— ¡Pues abre bien los ojos! — le gritó el compadre Alfio —, porque
vas a ir bien servido!
Según estaba en guardia, agachado, para contener la herida que le
dolía, y arrastrando casi el codo por el suelo, agarró un puñado de
tierra y se lo echó a los ojos al adversario.
— ¡Ah! — gritó Turiddu, cegado —, ¡soy muerto!
Intentaba salvarse dando saltos desesperados hacia atrás; pero el
compadre Alfio le alcanzó con otro golpe en el estómago y otro en el
cuello.
— ¡Y tres! ¡Este, por haberme adornado la casa! Ahora, tu madre
dejará en paz las gallinas.
Turiddu se tambaleó un poco entre las chumberas y cayó luego
como una piedra. La sangre le borbotaba espumando en la
garganta, y no pudo proferir ni un "¡Ay mi madre!".
 "LA LOBA"

Era alta, delgada; tenía, eso sí, un seno firme y vigoroso, de morena
— aunque ya no era joven —, pálida como si tuviera siempre la
malaria, y en aquella palidez, unos ojos así de grandes y unos labios
frescos y rojos que te comían.
En el pueblo la llamaban "La Loba" porque nunca ni con nada se
saciaba. Las mujeres se santiguaban al verla pasar sola como un
perro, con aquel andar errante y desconfiado de loba hambrienta;
robaba hijos y maridos en un abrir y cerrar de ojos, con sus labios
colorados y se los llevaba tras de sus faldas, con aquella mirada de
Satanás, aunque estuviesen ante el altar de Santa Agripina. Por
fortuna, "La Loba" no iba nunca a la iglesia, ni por Pascua ni por la
Navidad, ni a oír misa, ni a confesarse. El padre Angel de Santa
María de Jesús, un verdadero siervo de Dios, había perdido el alma
por ella.
La pobre Marica, muchacha buena y lista, lloraba a hurtadillas,
porque, hija de "La Loba", nadie la quería por mujer, a pesar de
tener su ropita en la cómoda y sus cuatros terrones como cualquier
otra moza del pueblo.
Un buen día, "La Loba" se enamoró de un guapo mozo que había
vuelto del servicio y que segaba el heno con ella en los prados del
notario; pero lo que se dice enamorarse, sentir que le ardían las
carnes bajo el fustán del corpiño y tener al mirárle a los ojos la sed
de las cálidas tardes de junio, en medio del llano. Pero él seguía
segando tranquilamente, atento al la gavilla, y le decía:
— ¿Qué tiene, "señá" Pina?
En los campos inmensos, donde sólo se oía el canto de los grillos,
cuando caía el sol a plomo, "La Loba" gavillaba manojo tras manojo
y haz tras haz, sin cansarse jamás, sin enderezar un momento al
cuerpo, sin acercar los labios a la botella, con tal de estar siempre
pisándole los talones a Nanni que, segaba y segaba, y preguntábale
de cuando en cuando:
— ¿Qué quiere, "señá" Pina?
Una noche se lo dijo, mientras los hombres dormitaban en la era
cansados de la larga jornada, y vagaban los perros por el campo
vasto y negro.
— ¡Te quiero... a ti, que eres guapo como un sol y dulce como la
miel! ¡Te quiero a ti!
— Y yo quiero a tu hija, que es mocita — respondió Nanni riendo.
"La Loba" llevóse las manos a la cabeza, rascóse las sienes sin decir
palabra y, marchándose luego, ya no volvió más por la era. Pero en
octubre se encontró de nuevo con Nanni, según hacían el aceite,
porque trabajaba junto a su casa, y el chirrido de la prensa no le
dejaba dormir en toda la noche.
— Coge el saco de las aceitunas — le dijo a su hija — y ven
conmigo.
Nanni empujaba con la pala las aceitunas bajo la muela, y gritábale
"¡ohí" a la mula para que no se parase.
— ¿Quieres a mi hija Marica? — le preguntó la "señá" Pina.
— ¿Qué le da usted a su hija Marica? — respondió Nanni —. Tiene lo
de su padre, y a más le doy mi casa; a mí me basta con que me des
un rincón de la cocina donde tender un jergón.
— Si es así, para Navidad hablaremos — dijo Nanni.
Nanni estaba todo untado y sucio del aceite y de las aceitunas
puestas a fermentar, y Marica no le quería en modo alguno; pero su
madre la agarró por los pelos, delante del hogar, y le dijo, apretando
los dientes:
— ¡Si no te casas con él, te mato!
"La Loba" parecía enferma, y decía la gente que el diablo cuando se
hace viejo se mete a fraile. Ya no iba de aquí para allá; ya no se
ponía a la puerta con aquellos ojos de endemoniada. Su yerno,
cuando ella se le plantaba delante con aquellos ojos, echábase a reír,
y sacaba el escapulario de la Virgen para persignarse. Marica
estábase en casa amamantando a sus hijos, y su madre andaba por
los campos trabajando con los hombres, como un hombre
enteramente, escardando, cavando, conduciendo el ganado,
podando las cepas, ya soplase el gregal, ya levante de enero o
siroco de agosto, cuando los machos agachaban la cabeza y los
hombres dormían de bruces al resguardo de la pared a tramontana.
"En esa hora entre véspero y nona, en que no anda hembra bona",
la señá Pina era la única alma viviente a quien se veía errar por el
campo, sobre los guijarros abrasados de los senderos, entre los
secos rastrojos de los campos inmensos, que se perdían en el
caliginoso ambiente, lejos, muy lejos, hacia el Etna neblinoso, donde
el cielo pesaba sobre el horizonte.
— Despierta — dijole "La Loba" a Nanni, que dormía en la cuneta,
junto al seto polvoriento, con la cabeza entre los brazos —.
Despierta, que te he traído el vino para que refresques el gañote.
Nanni abrió los ojos lacrimosos, entre dormido y despierto, y se la
encontró derecha, pálida, prepotente el pecho, los ojos negros como
el carbón, y extendió a tientas las manos.
— ¡No; "no anda hembra bona entre véspero y nona"! — sollozaba
Nanni, escondiendo la cara en la hierba seca de la cuneta y
arañándose los pelos — ¡Vete, vete; no vuelvas más a la era!
Y se marchó "La Loba", en efecto, anudándose otra vez las
hermosas trenzas, fija la mirada ante sus pasos en los cálidos
rastrojos, con los ojos negros como el carbón.
Pero volvió varias veces a la era, y Nanni no le dijo nada. Antes bien:
cuando tardaba en ir a esa hora, entre véspero y nona, íbase a
esperarla a lo alto de la senda blanca y desierta, con el sudor en la
frente, y después se llevaba las manos a la cabeza y repetíale
siempre:
— ¡Vete, vete, y no vuelvas más a la hora!
Marica lloraba día y noche, y plantábase ante su madre, ardiéndole
los ojos de lágrimas, como una lobezna a su vez, siempre que la veía
volver del campo pálida y muda.
— ¡Mala madre! — le decía —. ¡Mala madre!
— ¡Calla!
— ¡Ladrona, ladrona!
— ¡Calla!
— ¡Iré a decírselo al brigadier!
— ¡Ve!
Y fué de veras, con sus hijos en brazos, sin miedo, sin verter una
lágrima, como una loca, porque ahora también ella quería a aquel
marido que le habían dado a la fuerza, untado y sucio de las
aceitunas puestas a fermentar.
El brigadier mandó llamar a Nanni, y le amenazó incluso con el
presidio y la horca. Nanni se dió a llorar y a tirarse de los pelos. ¡No
negó nada! ¡No intentó disculparse!
— ¡Es la tentación — decía —; es la tentación del infierno!
Y se arrojó a los pies del brigadier, suplicandole que le mandase a
presidio.
— ¡Por caridad, señor brigadier, sáqueme de este infierno! ¡Que me
matan! ¡Que me maten en la cárcel; pero que no la vea nunca más!
— ¡No! — respondióle, por el contrario, "La Loba" al brigadier —. Yo
me reservé un rincón de la cocina donde dormir cuando les di mi
casa en dote. La casa es mía. ¡No quiero marcharme!
Poco después, a Nanni le atizó una coz el macho, y estuvo a la
muerte; pero el párroco se negó a darle el Señor si "La Loba" no
salía de la casa. "La Loba" se marchó, y su yerno entonces pudo
prepararse a irse también como buen cristiano, y confesó y comulgó
con tales muestras de arrepentimiento y de contrición, que todos los
vecinos y curiosos lloraban junto al lecho del moribundo. Mejor
habríale sido morirse aquel día, antes de que el diablo volviese a
tentarlo y a metérsele en alma y cuerpo cuando estuvo curado.
— ¡Déjame! — decíale a "La Loba" —. ¡Por caridad, déjame en paz!
¡He visto con estos ojos a la muerte! La pobre Marica está
desesperada. ¡Ya lo sabe todo el pueblo! Cuando no te veo es mejor
para ti y para mi...
Habría querido sacarse los ojos para no ver los de "La Loba", que
cuando se clavaban en los suyos haciénle perder el alma y el cuerpo.
No sabía qué hacer para librarse del embrujamiento. Pagó misas a
las ánimas del Purgatorio; fué a pedirles ayuda al párroco y al
brigadier. Por Pascua se confesó y se arrastró públicamente,
lamiendo los guijarros del sagrado, delante de la iglesia, en
penitencia, y luego, como "La Loba" volviese a tentarlo:
— Oye — le dijo —; no vuelvas a buscarme a la era, porque si
vuelves, como hay Dios que te mato.
— Mátame — respondió "La Loba" —, no me importa; pero sin ti no
quiero estar.
Como la divisó de lejos, en medio de los verdes sembrados, dejó de
cavar la viña y fué a arrancar el hacha del olmo. "La Loba" le vió
acercarse, pálido, con ojos extraviados, con el hacha brillando al
sólo, y no se echó atrás un solo paso; no bajó los ojos; siguió
andando a su encuentro, llenas las manos de manojos de rojas
amapolas, comiéndoselo con sus ojos negros.
— ¡Ah, maldita sea tu alma! — balbució Nanni.
 NEDDA

El hogar doméstico era siempre a mis ojos una figura retórica, buena
para encuadrar los afectos más dulces y serenos, como el rayo de
luna para besar las rubias cabelleras; pero me sonreía al oír que el
fuego de la chimenea es casi un amigo. Parecíame, en verdad, un
amigo harto necesario, a las veces fastidioso y despótico, que poco a
poco quisiera atarnos de pies y manos y arrastrarnos a su antro
humoso para besarnos a la manera de Judas. No se me alcanzaba el
pasatiempo de atizar al fuego, ni la voluptuosidad de sentirse
inundado por el resplandor de la llama; no comprendía el lenguaje
del leño crepitando desdeñoso o rezongando en llamaradas; no tenía
acostumbrados los ojos a los caprichosos dibujos de las chispas,
corriendo como luciérnagas sobre los ennegrecidos tizones a las
fantásticas formas que al carbonizarse asume la leña, a las mil
gradaciones de claroscuro de la llama azul y roja, que ora lame
tímida o acaricia graciosamente, ora se eleva con orgullosa
petulancia. Cuando me inicié en los misterios de las tenazas y el
fuelle, me enamoré con grandes transportes de la voluptuosa
ociosidad de la chimenea. Abandono pues, mi cuerpo sobre la
butaca, junto al fuego, como dejaría un traje, encomendando a la
llama el cuidado de hacer que mi sangre circule más cálida y que mi
corazón lata con más fuerza, y a las chispas fugitivas que revolotean
como mariposas enamoradas el que mantengan abiertos mis ojos, y
hagan al par errar caprichosamente mis pensamientos. El
espectáculo del propio pensamiento revoloteando vagamente en
nuestro derredor, o abandonándonos para correr lejos, e infundir, sin
que nos demos cuenta, soplos de dulzura y amargura en el corazón,
tiene indefinibles atractivos. Con el cigarro medio apagado,
entornados los ojos, las tenazas escapándose de los flojos dedos,
vemos venir de lejos una parte de nosotros mismos y recorrer
distancias vertiginosas; parécenos que pasen por nuestros nervios
corrientes de atmósferas desconocidas; probamos, sonrientes, sin
mover un dedo ni dar un paso, el efecto de mil sensaciones que nos
harían encanecer y surcarían de arrugas nuestra frente.
Y en una de esas peregrinaciones vagabundas del espíritu, la llama,
que se elevaba acaso sobrado cerca, me hizo ver de nuevo otra
llama gigantesca, que había visto arder en el hogar inmenso de la
hacienda del Pino, en las faldas del Etna. Llovía, y el viento bramaba
encolerizado; las veinte o treinta mujeres que recogían la aceituna
de la finca hacían humear sus faldas mojadas de la lluvia, ante el
fuego; las alegres, las que tenían cuartos en el bolso, o estaban
enamoradas, cantaban; las otras charlaban de la cosecha de
aceituna, que había sido mala, de las bodas de la parroquia, o de la
lluvia que les robaba el pan de la boca. La vieja mayorala hilaba,
aunque no fuese más que porque el candil colgado de la campana
del hogar no ardiese en balde; el perrazo color de lobo alargaba el
hocico sobre las patas hacia el fuego, enderezando las orejas a cada
gemido del viento. Luego, en tanto que hervía la sopa, el mayoral se
puso a tocar un aire montañés, que se iban los pies tras él, y las
mozas empezaron a saltar sobre el inseguro pavimento de la vasta
cocina humeante, en tanto el perro rezongaba con miedo de que le
pisaran el rabo. Revoloteaban las faldas alegremente, y las habas
bailaban a su vez en la olla, murmurando entre la espuma que hacía
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and

personal growth!

textbookfull.com