Search

Academic reading, a form of active reading, often involves interaction with the text. Highlighting and annotating are some of the most common strategies of interacting with academic texts, yet we have limited understanding of exactly how such interaction affects reading comprehension in digital versus analog reading environments. In this paper, we compare how university students (N=50) interact with a digital and a physical text, focusing on highlights and annotations. We compare reading speed, interaction with, and subsequent memory of the texts. We make nine observations about reading speed, highlighting frequency and memory scores between paper and laptop. We find indications that highlighting and annotating when reading a digital text has a higher impact on memory than when reading a paper text, and suggest that the main challenge for designers of digital reading support tools appears to be better designs for active annotation.

Academic reading, a form of active reading, often involves interaction with the text. Highlighting and annotating are some of the most common strategies of interacting with academic texts, yet we have limited understanding of exactly how such interactions affect reading comprehension in digital versus analog reading environments. In this paper, we present an exploratory study, comparing how university students (n = 50) interact with a digital and a physical text, focusing on highlights and annotations. We compare reading time, interaction with, and subsequent memory of the texts. We make nine observations about reading time, highlighting and annotation frequency and memory scores between paper and laptop. We find that students annotate significantly less on laptop than on paper, but that neither highlighting nor annotations influence subsequent memory of the text in either condition. Our broader contribution is to augment understanding of how different interaction features aid academic reading in a natural environment.

A software product line (SPL) encodes a potentially large variety of software products as variants of some common code base. Up until now, re-using traditional static analyses for SPLs was virtually intractable, as it required programmers to generate and analyze all products individually. In this work, however, we show how an important class of existing inter-procedural static analyses can be transparently lifted to SPLs. Without requiring programmers to change a single line of code, our approach SPLLIFT automatically converts any analysis formulated for traditional programs within the popular IFDS framework for inter-procedural, finite, distributive, subset problems to an SPL-aware analysis formulated in the IDE framework, a well-known extension to IFDS. Using a full implementation based on Heros, Soot, CIDE and JavaBDD, we show that with SPLLIFT one can reuse IFDS-based analyses without changing a single line of code. Through experiments using three static analyses applied to four Java-based product lines, we were able to show that our approach produces correct results and outperforms the traditional approach by several orders of magnitude.

Context. Variability-intensive programs (program families) appear in many application areas and for many reasons today. Different family members, called variants, are derived by switching statically configurable options (features) on and off, while reuse of the common code is maximized. Inquiry. Verification of program families is challenging since the number of variants is exponential in the number of features. Existing single-program analysis and verification tools cannot be applied directly to program families, and designing and implementing the corresponding variability-aware versions is tedious and laborious. Approach. In this work, we propose a range of variability-related transformations for translating program families into single programs by replacing compile-time variability with run-time variability (non-determinism). The obtained transformed programs can be subsequently analyzed using the conventional off- the-shelf single-program analysis tools such as type checkers, symbolic executors, model checkers, and static analyzers. Knowledge. Our variability-related transformations are outcome-preserving, which means that the relation between the outcomes in the transformed single program and the union of outcomes of all variants derived from the original program family is equality. Grounding. We show our transformation rules and their correctness with respect to a minimal core imperative language IMP. Then, we discuss our experience of implementing and using the transformations for efficient and effective analysis and verification of real-world C program families. Importance. We report some interesting variability-related bugs that we discovered using various state-of-the-art single-program C verification tools, such as Frama-C, Clang, LLBMC., Comment: The Art, Science, and Engineering of Programming, Vol. 1, Issue 1, Article 1

During 2007 all Danish university curricula were reformulated to explicitly state course objectives due to the adoption of a new Danish national grading scale which stipulated that grades were to be given based on how well students meet explicit course objectives. The Faculties of Science at University of Aarhus and University of Southern Denmark interpreted “course objectives” as “intended learning outcomes” (ILO) and systematically formulated all such as competencies using the SOLO taxonomy that operates with five numbered progressive levels of competencies. We investigate how the formulation of ILOs using the SOLO taxonomy gives information about competence progression, educational traditions, and the nature of various science subjects. We use all the course curricula (in total 632) from the two faculties to analyze and compare undergraduate and graduate courses within each department, and different departments with each other.

In this chapter we discuss several previous work on topics like interfaces for non-annotative approaches (such as aspect-oriented programming), separation of concerns and modularity, analyses on preprocessor-based systems, and dataflow analysis. Besides discussing, we compare these works to our approach, pointing out the differences between them.

In this chapter we review essential concepts we explore in this work. Firstly, we review software families and software product lines, since the problem we address here is critical in these contexts. We show the basic concepts and then move towards conditional compilation with preprocessors, a widely used mechanism to implement features in industrial practice. Despite the widespread usage, conditional compilation has several drawbacks. We then present the Virtual Separation of Concerns (VSoC) approach, which can minimize some of these drawbacks. In this work, we intend to address the lack of feature modularity. Thus, we need to catch dependencies between features and inform developers about them. To do so, we rely on dataflow analyses, the last topic we review in this chapter.

We present the metafront tool for specifying flexible, safe, and efficient syntactic transformations between languages defined by context-free grammars. The transformations are guaranteed to terminate and to map grammatically legal input to grammatically legal output. We rely on a novel parser algorithm that is designed to support gradual extensions of a grammar by allowing productions to remain in a natural style and by statically reporting ambiguities and errors in terms of individual productions as they are being added. Our tool may be used as a parser generator in which the resulting parser automatically supports a flexible, safe, and efficient macro processor, or as an extensible lightweight compiler generator for domain-specific languages. We show substantial examples of both kinds.

All uses of HTML forms may benefit from validation of the specifiedinput field values. Simple validation matches individual values against specified formats, while more advanced validation may involve interdependencies of form fields.There is currently no standard for specifying or implementing such validation. Today, CGI programmers often use Perl libraries for simple server-side validation or program customized JavaScript solutions for client-side validation.We present PowerForms, which is an add-on to HTML forms thatallows a purely declarative specification of input formats and sophisticated interdependencies of form fields. While our work may be seen as inspiration for a future extension of HTML, it is also available for CGI programmers today through a preprocessor that translates a PowerFormsdocument into a combination of standard HTML and JavaScript that works on all combinations of platforms and browsers.The definitions of PowerForms formats are syntactically disjoint from the form itself, which allows a modular development where the form is perhaps automatically generated by other tools and the formats and interdependencies are added separately.PowerForms has a clean semantics defined through a fixed-point process that resolves the interdependencies between all field values. Text fields are equipped with status icons (by default traffic lights) that continuously reflect the validity of the text that has been entered so far, thus providing immediate feed-back for the user. For other GUI components the available options are dynamically filtered to present only the allowed values. PowerForms are integrated into the system for generating interactive Web services, but is also freely available in an Open Source distribution as a stand-alone package.

We present the results of the project, which aims to design and implement a high-level domain-specific language for programming interactive Web services. A fundamental aspect of the development of the World Wide Web during the last decade is the gradual change from static to dynamic generation of Web pages. Generating Web pages dynamically in dialogue with the client has the advantage of providing up-to-date and tailor-made information. The development of systems for constructing such dynamic Web services has emerged as a whole new research area. The language is designed by analyzing its application domain and identifying fundamental aspects of Web services inspired by problems and solutions in existing Web service development languages. The core of the design consists of a session-centered service model together with a flexible template-based mechanism for dynamic Web page construction. Using specialized program analyses, certain Web specific properties are verified at compile-time, for instance that only valid HTML 4.01 is ever shown to the clients. In addition, the design provides high-level solutions to form field validation, caching of dynamic pages, and temporal-logic based concurrency control, and it proposes syntax macros for making highly domain-specific languages. The language is implemented via widely available Web technologies, such as Apache on the server-side and JavaScript and Java Applets on the client-side. We conclude with experience and evaluation of the project.

International audience