Schreibe dein Programm!

Schreibe Dein Programm! ist eine Einführung in die Entwicklung von Programmen und die dazugehörigen Grundlagen. Im Zentrum stehen Konstruktionsanleitungen, welche die systematische Konstruktion von Programmen fördern, sowie Techniken zur Abstraktion, welche die Umsetzung der Konstruktionsanleitungen ermöglichen. In der Betonung systematischer Konstruktion unterscheidet sich dieses Buch drastisch von den meisten anderen Einführungen in die Programmierung. Die vermittelten Grundlagen und Techniken sind unabhängig von einer bestimmten Programmiersprache. Zur Illustration und zum Training der Programmierung dienen speziell für die Anfängerausbildung entwickelte Sprachebenen. Diese erleichtern den Einstieg und erlauben, die Konzepte der Programmierung zu präsentieren, ohne Zeit mit der Konstruktvielfalt anderer Programmiersprachen zu verlieren. Entsprechend vermittelt dieses Buch fortgeschrittene Techniken. Schreibe Dein Programm! ist aus der Praxis der Informatik-Grundausbildung an den Universitäten Tübingen, Freiburg und Kiel entstanden: Über mehrere Vorlesungszyklen wurden Stoffauswahl und Präsentation stetig verbessert. Gegenüber dem Vorgängerbuch Vom Problem zum Programm wurde ein Großteil des Materials neu entwickelt. Das Buch enthält viele Beispiele und Übungsaufgaben. Alle nötigen mathematischen Grundlagen werden vermittelt

Some Elements Of A Modula-2 Development Environment

We present some language-specific tools for the development of Modula-2 program systems. Specifically, we elaborate on an extended Modula-2 syntax checker, a makefile generation utility, a Modula-2 structure analyser and a cross reference utility. INTRODUCTION Development of large program systems usually cannot be done without the aid of some tools; medium-sized projects can also take advantage of such tools. The UNIX system is famous for its rich collection of programming tools; we therefore restrict the following discussion to program development under UNIX. Some of the tools are languageindependent, such as make that takes care of the necessary actions to rebuild a target after a set of changes or rcs that helps in configuration and revision management. Other tools can be adapted to a variety of languages by some configuration files, such as emacs, a most powerful editor (?) or vgrind that helps to produce program listings. While it is clear that one should rely on language-indep..

Concepts for Overloading and Subtyping in an Algebraic Specification Language

. Following ideas of [Thi93] and [GM89], we present a type inference system of a first order polymorphic algebraic specification language with user defined overloading and subtyping. The features of overloading and subtyping of the language are similar to OBJ-3 [GWM + 93]. The extension is the type inference system which we describe in detail. Also we present a small type inference example. Introduction Wellknown functional programming languages like HOPE [BMS80], ML [MTH90] or Miranda TM [Tur86] have the restriction that data type carrier sets must be pairwise disjoint and that overloading is prohibited (i.e. it is not allowed to name more than one function with the same function symbol). These restrictions lead to awkward constructions if we want to represent sets as subsets of other sets. Essentially, we need several distinct representations for the elements of the subsets in the same program. Specifically for computer algebra where we deal with mathematical objects there is a ..

A constructive method for abstract algebraic software specification

AbstractA constructive method for abstract algebraic software specification is presented, where the operations are not implicitly specified by equations but by an explicit recursion on the generating operations of an algebra characterizing the underlying data structure. The underlying algebra itself may be equationally specified since we cannot assume that all data structures will correspond to free algebras. This implies that we distinguish between generating and defined operations and that the underlying algebra has a mechanism of well-founded decomposition w.r.t. the generating operations. We show that the explicit specification of operations using so-called structural recursive schemata offers advantages over purely equational specifications, especially concerning the safeness of enrichments, the ease of semantics description and the separation between the underlying data structure and the operations defined on it

Generation of Garbage Collector Performance Test Beds Based on Probability Distributions

We propose a profiling tool for experimental evaluation of garbage collection algorithms. Behaviour of the profiler is determined by some probability distributions on object size and life time etc. that are derived from the properties of certain languages or applications. A standard memory management interface allows precise, objective evaluation of several garbage collection algorithms under laboratory conditions using the same profiler parameters. The separation of memory management and language/application we thus achieve can be used for experimental determination of optimal garbage collection strategies for a given situation. Categories ffl Garbage collection (GC) ffl MM performance analysis and optimization tools 1 Introduction Garbage collector performance is one of the key determinants of functional and object-oriented programming systems. Numerous attempts at improvement of garbage collector performance have therefore been published; e.g. [Bak78, Bak93, NO93, ON94, Ung84, W..

Eliminating Range Checks Using Static Single Assignment Form (Extended Abstract)

John Gough, Queensland University of Technology Herbert Klaeren, University of Tubingen y November 1, 1994 Abstract We propose a new method of eliminating range checks in connection with array index expressions and assignments to variables of subrange types. Contrary to the approaches documented in the literature, we work on an extended static single assignment form (XSA) very near the target level. This gives significant advantages over previous attempts since many questions don't occur at all or else in a simpler form in the XSA. The technique has been implemented in a family of Modula-2 and Oberon-2 compilers. Introduction Implementation of safe programming languages requires range checks in connection with array index expressions and, where applicable, with assignments to variables of subrange types. Also, it calls for overflow checks in connection with arithmetic operations. Of course, these checks cause run time overhead; it is therefore a good idea to eliminate at compile t..

Subtyping and Overloading in a Functional Programming Language

We present a first order functional programming language with user defined overloading and subtyping. A regularity restriction on overloading guarantees unique term evaluation. We present an example showing that this restriction is necessary. Furthermore we define a type inference system for this language. The type inference problem is decidable and the type system has the principal type property. Introduction In the last ten years, functional programming languages have become increasingly popular. Wellknown functional programming languages like HOPE [BMS80], ML [MTH90], Miranda TM [Tur86] or Haskell [HPW + 92] usually have restrictions: data type carrier sets have to be pairwise disjoint and overloading is prohibited (i.e. it is not allowed to name more than one function with the same function symbol). These restrictions lead to awkward constructions if we want to represent sets as subsets of other sets. Essentially, we have to have in the same program two representations for th..

Wsi-95-22

. Following ideas of [Thi93] and [GM89], we present a type inference system of a first order polymorphic algebraic specification language with user defined overloading and subtyping. The features of overloading and subtyping of the language are similar to OBJ-3 [GWM + 93]. The extension is the type inference system which we describe in detail. Also we present a small type inference example. Introduction Wellknown functional programming languages like HOPE [BMS80], ML [MTH90] or Miranda TM [Tur86] have the restriction that data type carrier sets must be pairwise disjoint and that overloading is prohibited (i.e. it is not allowed to name more than one function with the same function symbol). These restrictions lead to awkward constructions if we want to represent sets as subsets of other sets. Essentially, we need several distinct representations for the elements of the subsets in the same program. Specifically for computer algebra where we deal with mathematical objects there is a ..