Online stores often include a customer reviews section on their product web pages. These reviews contain valuable information for product sellers, who often want to collect the reviews of their products from as many pages as possible. This work presents a novel technique to automatically extract customer reviews from online stores. Unlike traditional scraping tools, the proposed technique operates on heterogeneous web pages without requiring prior knowledge of their structure or human intervention. By analysing the web page’s DOM tree, it identifies the reviews section, enabling the extraction of text-based comments as well as associated media content such as images and videos. The technique processes individual pages in real time, making it suitable for dynamic browsing scenarios, and has been empirically evaluated on diverse real-world web pages, demonstrating its robustness and versatility. This evaluation shows that the technique achieves an average F1 score of 91.54% and reaches 100% in 82.6% of the web pages.

Data-dependence analyses (DDA) and data-flow analyses (DFA) are essential software engineering processes automatically carried out in compilers, debuggers, and, in general, in most program analyses for termination, parallelization, optimization, etc. The question "For which classes of programs DDA and DFA are decidable?" remains unanswered, even though it is of fundamental importance because it can pose limits to the algorithms that try to solve the DDA/DFA problem. It is a well-known result that DDA/DFA is undecidable for non-terminating programs. In 2000, Thomas Reps took a big step forward. He proved the undecidability of one specific DDA for programs with recursive functions and composite data structures, and he explained the important implications of that result. It was a big step in the path to prove the undecidability of other analyses. This paper uses Reps’ results to prove that DDA and DFA are also undecidable for programs without composite data structures.

The system dependence graph (SDG) is a widely used program representation for the static analysis of programs. In particular, it is the standard way to represent control and flow dependences between the statements of a program. It is at the core of program slicing, a technique that extracts the part of a program that can influence a given program point (the so-called slicing criterion). In this paper, we identify several program slicing situations (e.g., list comprehensions, try-catch and for ) where the representation provided by the SDG is imprecise, and we present an alternative program representation, which is indeed an extension of the SDG, that solves these situations. We call this extension the expression dependence graph (EDG). The EDG redefines the SDG by increasing the granularity of its nodes to abstract syntax tree (AST) nodes. The implications of this change include an improvement in precision, the appearance of new kinds of dependences (besides control and flow dependences), and the possibility of selecting any (sub)expression as the slicing criterion.

This paper presents RevEx, an online consumer reviews extraction tool. RevEx extracts the comments section for products in webshops. In contrast to other web scraping tools, it can work with heterogeneous web pages automatically, that is, it does not need any additional information apart from the web page itself. In addition, RevEx is a page-level tool since it only needs to load the web page whose comments have to be extracted. The technique includes a mechanism to group similar DOM nodes and then, once several sets of similar DOM nodes are obtained, an algorithm selects the group of DOM nodes that corresponds to the comments of the web page. The results of the empirical evaluation show an average F1 higher than 88%, and perfect results for around 75% of web pages.

Program slicing is a program analysis technique to identify the parts of a program that can influence the values computed at a given program point. Its application to concurrent programs with shared memory revealed a new program dependence between threads called interference and uncovered some problems associated with concurrent executions such as time travel. To solve these problems, a new program representation for slicing concurrent programs was proposed: the threaded System Dependence Graph (tSDG), which aimed at solving the time travel problem and to provide context-sensitive slices for concurrent programs. In this paper, we show that the problem remains unsolved because the tSDG is not context-sensitive in some situations. We give a counterexample for the tSDG and identify situations where the tSDG is imprecise, generating context-insensitive slices for concurrent programs. To solve these imprecisions, we redesign the tSDG to become context-sensitive in those situations, solving the inaccuracy problem and preserving the solution to time travel. The new program representation is always as precise as the previous tSDG, and sometimes it is more precise. That is, the slices computed with the new graph are always smaller or equal than those computed with the previous tSDG.

Program slicing is a technique to extract the part of the program that can affect the values computed at a given program point (known as the slicing criterion). To represent programs, program slicing uses the System Dependence Graph (SDG), for which several extensions like the Java System Dependence Graph (JSysDG) or the Sub-Statement Linear Dependence Graph (SSLDG) exist to deal with Java object-oriented programs. In this paper, we present an incompleteness result proving that these graphs do not produce complete slices in all cases, and specifically when some object variables are selected as the slicing criterion. We first identify the source of the problem: the representation of dependences between partial definitions of objects is ill-defined in these approaches, leading to a loss of completeness in many cases. To solve this limitation, we extend these representations with the addition of a specific flow dependence for object type variables called object-flow dependence. This extension provides a more accurate flow representation between object variables and its data members and it allows us to obtain complete slices when an object variable is selected as the slicing criterion.

Program slicing is a technique for program analysis and transformation with many different applications such as program debugging, program specialisation, and parallelisation. The system dependence graph (SDG), the most commonly used data structure for program slicing, has been extended in several ways to manage exception handling constructs. In this paper, however, we show that the presence of exception-handling constructs can make even the extended SDG produce incorrect and incomplete slices. To solve this situation, we survey the current state of the art and merge and extend different approaches (that treat throws, try-catch, etc.) to produce a version of the SDG that is able to manage all of them, that always produces complete slices, and that increases its precision keeping the same time complexity. An interesting side result is the discovering of a new kind of control dependence: conditional control dependence, which is needed to properly represent catch statements.

Reversibility enables a program to be executed both forwards and backwards. This ability allows programmers to backtrack the execution to a previous state. This is essential if the computation is not deterministic because re-running the program forwards may not lead to that state of interest. Reversibility of sequential programs has been well studied and a strong theoretical basis exists. Contrarily, reversibility of concurrent programs is still very young, especially in the practical side. For instance, in the particular case of the Communicating Sequential Processes (CSP) language, reversibility is practically missing. In this article, we present a new technique, including its formal definition and its implementation, to reverse CSP computations. Most of the ideas presented can be directly applied to other concurrent specification languages such as Promela or CCS, but we center the discussion and the implementation on CSP. The technique proposes different forms of reversibility, including strict reversibility and causal-consistent reversibility. On the practical side, we provide an implementation of a system to reverse CSP computations that is able to highlight the source code that is being executed in each forwards/backwards computation step, and that has been optimized to be scalable to real systems.