Pedro Guerreiro

Combating anonymousness in populous CS1 and CS2 courses

One of the causes for unsatisfactory results in first year programming courses, as we have observed, is anonymousness: individual students mostly follow the course without recognition from their peers and their teachers, and this often discourages them. Therefore, increasing the visibility of what happens in the classroom and in the labs, as well as helping the students to know who their colleagues are and how they are performing can be very helpful. We recommend three complementary educational strategies which include video recording the classes and making the recordings available on the Internet to help students to review the lectures, using a web-based learning management system to foster the communication between teachers and students and among students, and increasing the visibility of student work by adopting an automatic grading system for lab assignments which can in parallel be used for self-assessment purposes.

Another mediocre assertion mechanism for C

Assertions are a basic programming ingredient. If the language being used does not support them in a proper way, then you must at least use some kind of standardized comments to express things like preconditions for functions. The comments can be turned into executable functions by a preprocessor, but we could write the function calls directly, with the advantage of having the compiler check their syntax. This technique can be used with C++ to emulate the full set of assertions used in Eiffel to implement Design by Contract. The assertion functions are grouped in a class (Assertions class), which is inherited by the classes whose functions we want to assert. The assertions can be turned on and off, object by object, during the execution of the program. The system works well under inheritance, although some guidelines must be followed when writing postconditions on the base class. The simplicity of this mechanism makes it possible to comment out all or some of the assertions automatically through the programming environment.

Object oriented requirements analysis in an Ada project

Among the methodologies that have appeared related to Ada, Object Oriented Development is emerging as the one of choice for a wide range of applications. Although Object Oriented Development is understood as covering more than just the design phase of the software life cycle, most Ada projects adopt these methodologies only in the design phase, using other kinds of methodologies for the requirements analysis, like structured analysis. We believe that if a single coordinated methodology is used throughout all the phases of the software life cycle, it will increase the traceability in the system, decrease the integration problems, and improve conceptual integrity of the design, leading to a more consistent final system.Although there are already many well known Object Oriented Design methods for Ada, Object Oriented Requirements Analysis methods are not so common. Notwithstanding, having a project to be carried out in Ada, we decided to use Object Oriented methodologies from the very beginning, using the Object Oriented Requirements Analysis method proposed by the company EVB Software Engineering, Inc. That work, however, was not completely straightforward. We faced many practical difficulties, that had to be dealt with, and some problems that had to be solved. In this way, a variant of the original method emerged, which we believe is better suited to real word projects.

Another characterization of weakest preconditions

We present an approach to the study of nondeterministic programs, consisting essentially in using binary relations as semantic objects representing the input-output behaviour of programs. These relations include an explicit representation of non-terminating computations. Based on the relational model we introduce a weakest precondition total correctness predicate transformer. We then show how to build up this predicate transformer starting from others of a more elementar kind. Finally,we obtain a characterization of its healthiness properties in terms of set-theoretical properties of the relations involved.

Implementations of Nondeterministic Programs

Non-determinism is an important concept for program development. Nevertheless, at some low level of detail, the existing machines work in a deterministic manner. Therefore, it is necessary to know how to suppress the non-determinism of a given program, without disturbing its behaviour. This paper treats that problem formally, within the framework of the relational semantics of non-deterministic programs, and provides the justification of the validity of some usual techniques which are based on a intuitive understanding of the concept.