This are all the courses I followed during my Bachelor and Master degree. Description follows...

• Development of information systems
  Knowledge of elementary concepts from the area of information systems and their application. Knowledge of the function of databases and the roles involved in database design and use. Knowledge of the relational model with concepts like relation, key and integrity. Knowledge of the Entity-Relationship model with concepts like entity, attribute, relationship and constraints. Ability to construct a data model in terms of the relational model or Entity-Relationship model. Knowledge of the database language SQL and the main constructs in SQL for data manipulation and data definition. Ability to formulate queries in SQL. contents
  1. Information Systems
  2. Databases
  3. Entity-Relationship model
  4. Relational model
  5. SQL
  




• Logic and set theory
  After completing the course, the student can work with formulas from propositional logic and predicate logic, and knows their meaning and use. In particular, the student can `calculate' with logical formulas by replacing them by equivalent formulas, by strengthening formulas, or by weakening them, and the student can 'reason' with logical formulas in a system with assumptions, deductions and conclusions. The student can put his logical knowledge to work, in particular to calculate and reason with the formulas of set theory, having developed both the skills and the understanding of the fundamental mathematical abstractions in the area of sets, including relations, classes, functions, orderings and induction.
  
  Subjects:
  • Propositions, truth tables, equivalence, tautology and contradiction, standard equivalences, calculating with equivalences, strengthening and weakening propositions.
  • Predicates, quantifiers, standard equivalences with quantifiers, substitution, Leibniz's law, variable binding. Logical derivation, reasoning with propositions and predicates, conclusion, assumption, context, validity.
  • Set, subset, intersection and union, complement, difference, the empty set, powerset, cartesian product, sequence.
  • Relation, equivalence relation, class.
  • Mapping (function), image and source, injection, surjection, bijection, inverse function, composition of relations and functions.
  • Ordering, linear ordering, partial ordering, well-ordering.
  • Induction, strong induction, inductive definitions, structural induction, recursively defined functions.
  • Cardinality, (non)denumerability, Cantor's diagonal argument.
  




• Organisation and management
  This course explores how good management requires strategic thinking, a flexible organizational structure, strong management processes and leadership. Today’s managers have to think strategically about their company’s position and about the impact of changing conditions. They have to monitor the company’s external environment and internal capabilities closely enough to know when to institute strategy changes. They have to know the business well enough to determine what kinds of strategic changes to initiate. New technologies are opening up new opportunities but might also be a threat for the current position of companies. Companies can also innovate strategically by introducing new business models. Firms have to be reorganized accordingly and strategic target can only be reached when appropriate management processes and incentives are in place.
  This course highlights the following topics:
  • The external and internal environment of management
  • Managerial Planning
  • Strategy formulation and implementation
  • Managerial decision making
  • Changing organizational structure and culture
  • (Corporate) entrepreneurship
  • Leadership
  • Control
  • Teamwork
  




• Design-based learning 1.1
  Technical goals are introduction to formal needs in specification of systems and deal with suitable mathematical means of specification. The professional skills to be trained are cooperation, reviewing of eachothers work and performance and documenting specifications. Groups of about six students tackle some specification problems with emphasis on peer review and documantation. The formalism to be used is some practical predicate logic and set theory, it is willfully running ahead of the contents of the course 2IT10.
  




• Program realization 1
  The student is able to code programs in an organized way, paying attention to the choice of identifiers, layout, comments, and structure in terms of routines with suitable parameters and no coupling via global variables.
  The student is aware that code needs to be verified, e.g. by inspection, built-in test code, and systematic testing.
  The student knows about such program qualities as functional correctness, performance, readability, verifiability, and adaptability. The student is able to view a program in an abstract way as an automaton.
  Given an outline of a program design, the student knows which tools to use and how to use them for writing, adapting, compiling, debugging,
  and analyzing programs.
  The student has a good command of the general constructions of the imperative programming language Pascal, knows various elementary
  algorithms, and can apply these in larger programs.
  Coding standards, user-interface styles (console application, text filter, simple GUI). Tools (editor, compiler/linker, debugger, profiler, static analyzer). Automaton, state, state change, input, ouput.
  Computer as programmable (universal) automaton. Program as description of automaton. Imperative programming language (state space spanned by typed program variables, write statements, expressions, catenation of statements, read statements, assignment statement, conditions, conditional statement, repetitive statements, abbreviations (procedure, function), generalization, abstraction, parameters, file variables, composite types (array, record, set), coding idioms.
  Elementary algorithms (sum of a sequence, maximum of a sequence, linear search, bounded linear search, binary search, count number of occurrences, frequency table, evaluate a polynomial, matrix multiplication, factorize a number in prime factors, simple pattern recognition, various efficient coding patterns and idioms).
  




• Design-based learning 1.2
  General goals:
  • Develop a concrete product following a predefined development process and working in teams.
  • Become acquainted and practice professional the following professional qualities:
  • work on a project.
  • work in a team.
  • organise and hold meetings.
  • distribute work and organise time management.
  • reporting in Dutch.
  Goals wrt. the project:
  • develop a product methodically.
  • analyse the information needs of an organisation.
  • draw up and document data models.
  • translate data models into an application program.
  • document design decisions.
  In this project we get acquainted with a number of activities that take place during the development of an information system. We carry out these activities step by step and finally obtain the end product: an information system for a hospital. We start with formulating a set of requirements that reflect the information needs of an organisation. Based on these requirements, we construct data models for the information system. Then we develop a database according to the data models and build an information system that can collect and present the information necessary to support the work of the hospital personnel.
  




• Automata theory and formal languages
  The student has an idea of the notion of computability. He/she has some idea of what a computer can and cannot do.
  He/she can handle basic notions concerning automata and formal languages, in particular:
  • For a language given in natural language of in set notation, determine an automaton, a grammar or a regular expression that generates this language, and vice versa.
  • Transform a non-deterministic finite automaton into an equivalent deterministic automaton; transform such automata, regular expressions and regular grammars into the other representations.
  • Transform context-free grammars into pushdown automata, and vice versa.
  • Determine whether a particular language is in a particular class, using pumping lemmas and closure properties.
  • Give a rigorous formal presentation of a proof.
  • Grammars: regular, context-free, ambiguous
  • Finite automata: deterministic and non-deterministic
  • Regular expressions
  • Transformations of different representations for regular languages
  • Pushdown automata
  • Pumping lemmas for regular and context-free languages
  • Turing machines
  




• Computer architecture
  The 'Computer Systems' course is intended to teach first-year students in Computer Science the basics of computer architectures.
  In this course, we will focus on the point where 'hardware' and 'software' interact:
  hardware
  is the actual computer, a (fixed) electronic circuit built out of logic gates. The hardware includes a 'processor' which is capable of performing relatively simple operations under control of patterns of 'true' and 'false' logic values.
  software
  is a kind of 'recipe' for the functionality of a computer system, defined by a (changeable) sequence of patterns of 'true' and 'false' logic values. It is this sequence which controls the actual execution of simple operations by the processor.
  
  The following main items will be discussed:
  The processor as seen from the software viewpoint.
  We will discuss the ways in which a processor stores information, including the software 'program' which tells the processor what to do with this information. We will show the basic operations (or 'instructions') available within the processor. You will learn how to use these basic operations to write complete (working) programs in 'assembly language' (where you can use a readable textual format to define the instructions to execute, instead of unreadable logic value patterns).
  The processor as seen from the hardware viewpoint.
  We will show the basic hardware 'architecture' of a computer system, including the actual processor with its connections to the 'memories' in which information and data are stored. We will discuss the basic connections from a computer to the 'outside world', which are needed to get information into- or out of the computer. This part will provide the basis for tasks like 'build your own computer' or even 'build your own processor'. You will learn how to control this 'outside world' with programs written in assembly language.
  One level up: support for 'real' programming languages and 'operating systems'.
  Here, we will show techniques which are used to run 'real' programming languages like C or JAVA on a basic processor. Also, we will discuss the basic operation of operating systems like UNIX or Windows. These allow a running program to be interrupted automatically when something important happens in the 'outside world' connected to the computer. Operating systems also offer the capability to run several programs (virtually) 'at the same time'. We will show how these capabilities are supported with hardware inside the processor and how you can use this hardware to write your own (mini) operating system.
  




• Program realization 2
  The student is able to code and document programs in an organized way, using the tools and methods of modern object-oriented programming languages, assuming that the problem domain is sufficiently familiar.
  The student knows and has a command of concepts such as object, class, method, conctract, pointer structure, inheritance, assertion checking, exception handling, threads, and design patterns, especially in the realm of graphical user interfaces.
  The student is aware of the separation between problem specification, algorithm and data structure selection, and implementation in code.
  The student is aware of the evolving role of software in organizations and of the importance to develop high-quality software.
  contents Abstract data types, design by contract, recursion and its application in data structures and backtracking, branch and bound, object-oriented programming, modularization (unit, class), unit testing (automated, regression testing), integration, hashing, string manipulation, memory management, elementary design patterns, exception handling, threads, event-driven programming
  




• Design-based learning 1.3
  The students will build up some experience in presentation and composition of software and hardware products. They will get to know about embedded systems. They will experience the interaction between mechanical constraints on one side and alternative implementations for machine control on the other side and they will learn to deal with this issue.
  




• Ethics and Law
  Is able to critically reflect on the field of study: computer science; Is able to ask adequate questions, and has a critical yet constructive attitude towards analyzing and solving moral and legal problems in computer science; Is able to analyze and to discuss the ethical and legal aspects of the consequences and assumptions of scientific thinking and acting with colleagues and non-colleagues contents On the basis of case-based exercises several basic concepts of ethics and law will be introduced, such as computer ethics, philosophical foundations of computer ethics, privacy, property rights, and different senses of responsibility.
  




• Process theory
  • The student is capable of modeling simple systems by means of transition systems, Petri nets and process expressions.
  • The student is capable of using/computing the equivalence notions that are treated.
  • The student is aware of the usefullness of abstractions and is capable of applying abstraction.
  • The student is capable of transforming a description of a system ina vertain formalism to a description in one of the other formalisms.
  • The sudent is capable of formulating simple properties of simple systems in Hennessy-Milner logic.
  • Transitionsystems as a means for describing the behaviour of systems.
  • Process equivalences: isomorphism, language equivalence, trace equivalence en bisimulation equivalence.
  • Nondeterminism.
  • Branching versus linear behaviour.
  • Hennessy-Milner logic.
  • Parallelism en interaction.
  • abstraction.
  • algebraic description and manipulation.
  • relation between automata, Petri nets, transitionsystems and process expressions.
  




• Mathematics 2
  The student is able to solve systems of linear equations, to manipulate determinants, to analyse linear mappings and to diagonalize suitable matrices.
  Vectors, vector spaces, systems of linear equations, matrix operations, determinants, linear mappings, inverses, range, null space, rank, eigenvalues and eigenvectors, diagonalisation,inner products, orthogonal mappings, symmetric mappings
  




• Switching Theory
  A student• is able to derive logic functions from some given logic circuit and to construct an (optimal) circuit for some given logic function. This includes circuits for simple arithmetic with binary numbers.• understands the workings of sequential circuits and knows how to implement these circuits for some given functionality using finite state machines. Theory en methods for the design of logic circuits:• Combinational logic: Boolean algebra, K-maps, 2-level logic, multi-level logic, number systems, arithmetic circuits.• Sequential logic: flip-flops, registers, counters, finite state machines, Moore/Mealy machines.
  




• Systems engineering 1
  Learning to apply methods and techniques for the modelling and analysing of complex (information) systems. In this course methods and techniques for the modelling and analysing of complex systems are dealt with. Such models of existing systems are made if one wants to analyse or update them. Also when a new system has to be made first a model is designed. The methods that are used are based upon the Petri net theory ( extended with values and time). For the specification of value transformations a formal language will be used. Furthermore an appeal will be made on the knowledge of data models (as treated in 2M400 Databases 1). The emphasis of course lies on the ability to make models assuming an informal description and the analysis of these models.
  




• Design-based learning 2.1
  The goal of this course is to solve a large algorithmic problem with a group of students, where the students have to find the ingredients to the solution themselves. Special attention is given to information gathering (there will be a presentation on this by a librarian), to working effectively in groups (there will be a short training on this), and to writing reports. In OGO 2.1 groups of students must independently solve an algorithmically oriented problem. In 2001/2002 the problem was to find proteins in the human gnome, in 2002/2003 the problem was to decipher a text that was encoded by the Enigma (the coding machine used by the Germans in World War II), and last year the problem was to generate a time table for the Dutch railways. This year the task is to place labels (e.g. names of cities) on a map.
  




• Parallel and distributed algorithms
  Introduction to the elementary concepts of concurrency: scenarios, interference, local and global correctness, synchronization, semaphores, synchronous and asynchronous message passing. Elementary parallel algorithms: hand-shake, mutual exclusion, buffering. Properties of communication channels. Introduction to distributed protocols: summation input scheduling, token passing.
  




• Mathematics 1
  The Student:
  • acquires computational skills in the ring of integers mod n, in the set of polynomials whose coefficients belong to a given ring, en polynomials modulo a particular polynomial.
  • is able to combine methods from the theory of integers and polynomial rings in solving a variety of problems in practical digital communication.
  • Is able to analyse problems with integers and polynomials from an algorithmic point of view.
  • Is able to use tools from computer algebra to solve computationally hard problems.
  In highschool one learns to do arithmetic with real number. Addition, subtraction, multiplication and division. Addition, subtraction and multiplication are also possible with integers, but division is a bit harder. In the course you will learn to do arithmetic in a variety of algebraic structure. The central theme is arithmetic of integers and polynomials. This involves notions as greatest common divisor and least common multiple, the Euclidean algorithm, irreducibility (primality) Eratosthenes' sieve, factorization, the chinese remainder theorem, arithmatic mod n, solving linear congruences and a practical introduction of the notions ring, zero-divisor, invertibility and field. Also some practical applications of these concepts in computer science and digital communication wil be given.
  




• Design of algorithms 1
  A. Kaldewaij, Programming: The Derivation of Algorithms. Prentice Hall International (UK), 1990. (compulsory)
  




• Philosophy and informatics
  This seminar aims at giving students a broader perspective on formal languages and at providing them with more insight into the general background of the natural and engineering sciences; moreover we want them to reflect on the relation between the information sciences and the other sciences: the problem of the unity of science contents The course has the following outline. We start with a broad introduction on formal languages where the emphasis lies on the distinction between syntax, semantics and the meta level, and the relation with the course Logica en Verzamelingen. Next, some meetings are dedicated to the background and application of first order logic. We start with paraphrasing statements or arguments from natural language into formal language and vice-versa of formal to natural language. Then, we will look at the logical validity of reasoning; and finally we will dedicate a meeting to the meta-theory of logic; subjects, which, among others, will pass in revue are: deduction, validity, correctness, completeness, definability, and decidability. After the foundation of logical knowledge, we will discuss the axiomatic method and formal theories. We will look at the way the concepts of consistency, independence and completeness find their way in sets of models and of consequences. After the axiomatic method has been introduced, we apply this method to the introduction to the standard view of the sciences, which forms the basis of many modern discussions in modern philosophy of science. We continue the course with a meeting concerning measurement theory, which is dedicated to the different levels of measurement and the way these levels restrict the set of permitted statistics. In the last three meetings, we turn to: scientific methods, the empirical cycle and its relevance to the information sciences; the double slit experiment and the debate between realists and anti-realists; and, finally, the discussion regarding the unity of the sciences, and the place of the information sciences within the natural social and engineering sciences.
  




• Computer graphics
  The aim is to obtain knowledge on base concepts of 2D and 3D computer graphics. The student has a good insight in the graphics pipeline after attending the course. He can describe the main methods and algorithms for each step, and he can make a justified choices for a given situation. He is capable to solve (simple) geometric problems.
  This enables him to design and implement an interactive 3D graphics application on top of a 3D graphics library.
  Graphics pipeline, transformations, projections, geometric modelling, graphics primitives, shading models, algorithms for hidden surface removal.
  




• Design-based learning 2.2
  Technical learning objectives are the application of specification and implementation techniques for the
  configuration of an information system by means of components.
  
  The professional skills to be learned are: working in teams, documenting the design process, presenting and demonstrating the design and peer assessment. In this assignment the team must design a software system for a (fictitious) company that can process orders fully automatically. The software system should be able to handle a generic class of products.
  
  The product consists of components which are ordered from suppliers and the only physical actions taking place within the company are configuration and assembly of these components.
  The design process follows the roadmap as taught during the course System Modelling 1 (2M310). It consists of the following phases:
  1. User requirements
  2. Business architecture
  3. Functional architecture
  4. Construction by means of standard components
  In the final presentation both the design and the working system must be demonstrated.
  




• Component-based systems 1
  Learn how to design software components, which are usable in different contexts, based on an informal or formal specification. Syntactic aspects of procedural and data abstraction (e.g. private state, protected and public interface), types, inheritance. Specification techniques for components: a.o. class invariants, pre/post condition specification, design by contract, relation among classes and their components, hierarchy, inheritance, virtual components and design patterns. Examples of components from differen problem areas, such as information systems, graphics, compilers.
  




• Design-based learning 2.3
  This Design-Oriented Education project focuses on computer graphics and distributed systems. In addition, special attention is given to presentation of the work. The subject is the development of a distributed game. Starting from a minimal problem description, a creative approach is expected towards a working implementation of an attractive game. Much attention must be given to the graphical presentation and user interaction of the game, as well as the communication between computers via a network, such that all players always have the same view on the game. The project is carried out by groups of six students.
  




• Databases 1
  Study the foundations, design and usage of databases. The Relational Database Model. Theoretical foundation, database design, constraints (mostly functional dependencies), decomposition, normal forms. Data manipulation, relational algebra, tuple calculus, SQL.
  




• Mathematics 3
  The student:
  • is able to compute with relations;
  • has a knowledge of special kinds of relations, such as graphs, partial orderrs and equivalence relations
  • can do computations in finite monoids, groups, lattices and boolean algebra's
  • is able to handle algebraic structures defined by a small set of axioms
  • is able to apply algebraic methods in solving practical problems (in the area of digital communication and computer science)
  • Is able to use tools from computeralgebra to solve algebraic problems requiering a lot of calculations.
  We study relations on a set. In particular we look at graphs, maps and partial orders. Also we will consider algebraic structures. In Mathematics one you have learned how to do arithmetic with integers and polynomials. Apart from de differences in doing computations with these objects there are a lot of similarities. In all cases we were doing computations in an algebraic structure, a set together with a number of algebraic operations. We show that we can view the computations done in Mathematics 1 in this more general context. Along the way applications in computer science and digital communication will be given.
  




• Component-based systems 2
  The aim of the course is to provide a basic level of knowledge about the design and use of components and the technical and organisatorial issues concerning component-based software engineering. contents
  The subjects covered in the course will include:
  • component models
  • component-based development processes
  • the effect of reuse on productivity and quality
  • designing components
  • principles of software composition
  • predicting properties of component-based systems
  In parallel with the lectures, the participants will also work on an assignment that guides them through the CBSE process.
  




• User interfaces
  The goal is that the student learns to develop user interfaces that are ergonomically sound, efficient and effective to use, and that satisfy the requirements as jointly agreed upon between the developers and the clients (users).
  • General principles of ergonomically sound graphical user interfaces.
  • Design methods for (prototype) user interfaces.
  • Evaluation of user interfaces (with and without users).
  • Implementation of user friendly user-interfaces.
  




• Design of algorithms 2
  The student understands the difference between an abstract data structure (ADT) and its implementation, and knows a number of important ADTs and implementations of them. Furthermore, the student can analyze the efficiency of algorithms and data structures, and is able to use this to make a choice between different implementations of some ADT and, more generally, between different algorithms solving the same problem. Divide-and-conquer, recursion. Analysis of algorithms, O-notation, recurrences. Sorting algorithms. ADT's (with implementations): priority queues (heap), dictionaries (hash tables, (balanced) search trees), union-find. Augmenting data structures.
  




• Complexity
  After the course
  • the student understands the notion of complexity of an algorithm,
  • the student is able to compute the complexity of concrete algorithms,
  • the student knows the definition of the complexity classes P, NP and NPC,
  • the student knows the definition of polynomial transformation,
  • the student can perform elementary reductions,
  • the student knows the concept of decidability and a number of decidable and undecidable problems
  • Intractability: polynomial vs. exponential, polynomial certificate, NP-completeness
  • Undecidability: examples, halting problem, finite certificates
  • Machine-models: Turing machine, counter program
  • NP-completeness: Cook's theorem, polynomial reduction, examples
  • Approximation: bin-packing, traveling salesman, Steiner tree, coloring.
  




• Aspects of Programming Languages
  
  The student is able to:
  • Judge programming languages on criteria such as orthogonality, typing machnie independence.
  • Classify programming languages in broad categories, (imperative, functional, etc.).
  • Select a programming language to a given programming project.
  • Learn a new programming language in short time, because she is confident with the notions that distinguish languages and knows the various options.
  • Formulate criteria for a new language for a certain application area.
  • Demonstrate how style of programming is influenced by properties of the programming language.
  • Read and udnerstand a scientific paper about aspects of programming languages.
  • Form an opinion about such an article.
  • Formulate this opinion in an essay or a debating session.
  • Motivation for studying aspects of programming languages.
  • Categories of programming languages.
  • Available options at designing a programming language.
  • Trade offs in design, such as flexibility vs. safety.
  • Binding time
  • Design choices in the syntax.
  • Variables, typing, scoping, lifetime.
  • Design choices in datatypes, expressions, assignments.
  • Design choices in statement leve control structures (e.g., choice, iteration).
  • Design choices in subprograms (e.g. parameter passing, genericity).
  • Design choices in concurrency and exception handling.
  Languages that appear: Ada, C++, CLU, Eiffel, Algol68, Java, Prolog, Perl, Miranda, Oberon, Pascal, Cobol.
  




• Simulation
  The student is able to develop a discrete-event simulation model, and implement the model by using a general purpose programming language (Java), simulation language (Chi) or simulation system (Arena). Further, the student is able to prepare simulation input, set simulation parameters (such as warm-up interval, run length and number of simulation runs), and perform a statistical analysis of the output generated by simulation experiments. Merits and demerits of simulation versus mathematical analysis. Modeling approaches (event scheduling, process interaction). Input and output analysis. Random number generators. Variance reduction techniques. Implementation of discrete-event models in Java, Chi and Arena.
  




• Operating systems
  Provide knowledge of and insight in the concepts, methods, and techniques in the field of operating systems. Familiarity with existing operating systems. Provide access to the literature in this field. contents Overview of the tasks performed by an operating system. The paradigm of software construction in "layers", seen as a hierarchy of abstract machines. The architecture and the Application Programmers Interface. The kernel, multiprocessing, synchronization primitives, interrupts. Virtual memory: demand paging, replacement algorithms, load control. File systems. Resource management and scheduling. Examples from Linux and Windows.
  




• Knowledge-based systems
  Kennissystemen zijn softwaresystemen, die kennis verwerven, op een expliciete manier voorstellen, over deze kennis redeneren en gebruiken om een opdracht uit te voeren. Het vak Kennissystemen bestaat uit hoorcolleges die de belangrijke onderwerpen presenteren uit het gebied van de kennissystemen. In Blok E worden de kennisvoorstelling en het redeneren besproken, in blok F - het verwerven van kennis en het gebruiken ervan.
  Leerdoelen:
  1. Kennis van elementaire concepten op het gebied van kennissystemen.
  2. Kennis en praktische vaardigheid in het voorstellen van, het redeneren over, het verwerven van en het gebruiken van kennis.
  3. Praktische vaardigheid in het implementeren van kennissystemen.
  




• Hypermedia structures and systems
  Ability to design, implement and analyse hypermedia documents and hypermedia information systems. Gaining good background knowledge level in the field of hypermedia. Basic principles and a short historic overview of the research area of hypertext and hypermedia. Hypermedia reference models, hypermedia design, hypermedia information systems, authoring aspects, multimedia aspects, conversion of text to hypertext.
  




• Software specification
  The student can describe a wide range of existing software systems or software systems to be developed formally making use of mathematical formalisms introduced in the course. Method for software specification consisting of the description of data, functionality, and behaviour. Class diagrams are used for the description of data and functionality. Formal semantics uses Abstract Data Types and Z. Interaction of the (software) system with the environment is described by means of Message Sequence Charts (MSC) and High-level MSCs for normal scenarios and by means of State Charts for a more complete description of the behaviour.
  




• Compilers
  The objective of this course is to have the student acquire knowledge on the working and structure of simple compilers. This concerns both theoretical (language related) issues and more practical aspects. On completion of the course the student has to have insight in the working and theoretical background of the various parts of a compiler and has to be able to apply the various techniques, also in a different context. contents
  During the lectures five main subjects are subsequently treated:
  - lexical analysis (scanning): notion of token, regular expressions and languages, construction of a scanner from a specification expressed by means of regular expressions.
  - context-free analysis (parsing): syntax of languages, context-free grammars and languages, LL(1)-parsing, recursive descent parsing procedures, recursive descent parser generator.
  
  - concrete versus abstract syntax (tree), construction of a abstract syntax tree by the recursive descent parser, representation of abstract syntax trees.
  
  - context dependent analysis: attribute grammars, expressing context conditions by means of attribute grammars, inherited and synthesized attributes, attributed abstract syntax tree, attribute evaluation by means of so-called visitors of the abstract syntax tree, general one- pass condition.
  
  - translation: translation functions, syntax- directed translation, translation of several programming language constructs into the assembly language of a simple and idealized stack machine, code generation as attribute evaluation.
  The subjects are illustrated by means of a simple compiler implemented in Delphi for a compact example language. During the instructions several extensions to this compiler have to be implemented. The design of the compiler is based on several object- oriented techniques.
  




• Software tools
  After completing the course students
  - have gained insight in the working and underlying theory of some typical tools for program development
  
  - are able to use such tools
  
  - are able to construct similar tools
  The topic of this course are tools for program development. Examples of such tools are program generators, compiler toolkits, and visual development environments like Delphi and JBuilder. This course not only deals with the use of such tools, but also with the underlying theory and working of the tools themselves. Many of these tools are even excellent examples of good software design on the base of a simple and effective theory. The emphasis will be on tools for compiler construction, like scanner generators, parser generators, and attribute evaluator generators.
  




• Software engineering
  Be acquainted with the field of Software Engineering, in particular its terminology, methods, and research. Know when, why, and how to apply techniques from Software Engineering. More detailed knowledge of its specializations, including requirements engineering, conceptual modelling, software architecture, verification, and various related standards. Be able to define, describe, evaluate, and compare software development processes. Be able to measure various quality aspects of software processes and products. contents General motivation and history, requirements engineering, modelling in UML, software architecture (IEEE Std. 1471), detailed design, testing (planning, specification, automation through test frameworks, reporting, root cause analysis), inspections and reviews, project management, team organization, cost estimation, planning, progress reporting, configuration management, quality management, ESA PSS-05, Unified Process, agile development.
  




• History of computer science
  Goals: Creating a historical frame of reference for the developments in computing and information processing, with attention for the following aspects:
  1. Origins of ideas, methods, and tools;
  2. Technical backround;
  3. Social and economix context;
  4. Sense for place and time.
  Subjects:Organized in a number of themes:
  1. What, why an how of History of Computing;
  2. Early beginnings: Historical roots of key notions: number systems, calculation methods,algorithms, automata, data structures;
  3. Computers: From early calculation aids to modern computers;
  4. Software: Development of programming languages and certain classes of software;
  5. Development of "Informatica" in the Netherlands;
  6. Informatica as an emerging science, with its own foundations, principles, methods, standards and agenda.
  7. From computing machine to information machine, with nearly unlimited possibilities for computing information processing, communication, and control; a.o personal computing, shift to software, Internet and WWW.
  




• Technology of Information Systems
  Students learn the principles of the design and application of modern information systems: they now frequently used implementation technologies and design methods, they know typical application areas and are able to act as an architect in the design process of modern information systems. This means that they can apply what they learnt in other courses on the basis of concrete technologies, in the context of an environment in which the information systems is used to support a business process. Keywords:
  • Architecture
  • Component-based development
  • Workflow management
  • Data management
  • Webtechnology
  




• Mathematics 4
  The student is able to analyse functions of one variable, to differentiate and integrate (one and several variables), to analyse critical points of functions of several variables and to use series and power series. contents Continuity (single variable, several variables), differentiation (single variable, several variables), gradient, Taylor polynomials, extreme values, second derivative test, method of Lagrange, integration (single variable, several variables), Riemann sums, integrals in polar coordinates. Series, power series, convergence.
  




• Semantics and computational models
  The student knows the purpose of giving a formal semantics to a programming language en appreciates the importance of it.
  
  A semantics is a mapping to a model of computation. The student knows different models of computation and the purpose of these models. The student knows the three most common styles (operational, denotational and axiomatic) for the formalisation of the semantics of programming constructions, as well as their differences, commonalities and correspondences. The student is able to formalise the informal semantics of programming constructs in each of these styles. The student can substantiate statements about small programs with a formal semantic proof. The student is able to apply a number of standard proof techniques when reasoning about the semantics of programs and programming languages. The student knows the semantics of different programming paradigms such as imperative, parallel, functional and logic programming.
  
  In the first part of the course the operational, denotational and axiomatic semantics of a simple deterministic, imperative programming language is discussed. Semantic domains as transition systems modulo an equivalence relation, domain theory are adressed. The second part of the course treats the semantics of nondeterminism and parallelism, considering the Guarded Command Language and an extension with parallelism. The third part considers the semantics of a functional and a logic programming languages, and their semantic domains Herbrand universes and lambda calculus.
  




• Computer networks
  Knowledge: Students understand the organization of computer networks, factors influencing computer network developments and the reasons for existence of variety of different types of networks. They know the Internet structure and can see how standard problems are solved in that context. Skills: Students can analyze simple protocols and can independently study literature concerning computer networks. contents The OSI model; notions: protocol, connection, carrier, binding, service; network topology, network components & physical media; overview of relevant services; the link layer and bridging; the network layer and routing; the Internet protocol; naming; addressing; the transport layer: TCP, RTP and UDP; reliability and multiplexing; security; performance characteristics and quality of service.
  




• Functional programming
  Functional programming:
  The student is proficient in pointwise and pointfree calculation with functions, derivation of polymorphic typing of (functional) expressions and (s)he can apply abstraction and parametrization to enhance generality. (S)he masters programming techniques like induction, tupling, generalisation, accumulation and divide and conquer and is able to apply those techniques in the construction of elementary programs . Moreover (s)he masters the algebraic theory of inductive data types and knows how to use it for construction, transformation and verification of functional programs.
  logic programming:
  The student is acquainted with important concepts like Horn clause, resolution and unification. (S)he can read programs and use SLD-trees for the illustration of the program execution. (S)he is able to derive logic programs with the aid of functional design, predicate calculus and data base design.
  Functional and logic programming are two branches of the declarative style in programming. In the declarative style one is to define WHAT is to be computed and not HOW such computation is performed. We therefore may think of declarative programs as specifications.
  A functional program is a set of function definitions. In the design of these definitions well-known programming techniques are used. In this course we treat functions on inductive domains like natural numbers, (cons-)lists and trees. From the algebraic properties of inductive domains several transformations of functions and specifications may be derived. Using those transformations we can easily deduct equivalence of programs and specifications.
  A logic program is a set of relation definitions. In the design of those programs we can put functional design, predicate calculus and database design to good use.
  The following subjects will be treated:
  • pointwise and pointfree function calculation
  • Typing, polymorphy, currying
  • Abstraction and parametrization
  • Program derivation using induction, tupling, generalization, accumulation and divide and conquer.
  • Program verification by way of induction, laws and extensionality
  • Syntax en semantics of (Horn)clauses, inference systems, resolution and unification.
  • Design of logic programs using predicate calculus, function design and data base design.
  




• Software engineering project
  This is the final project of the bachelor Computer Science. It demonstrates the ability to develop large non-trivial software by a group of people. The subjects of the lecture on Software Engineering (2IP25) will be applied in a practical setting.
  
  The students will practice:
  • The development of a software product of moderate size (a few man year).
  • The definition, set-up, and use of a development environment: version management, build environment, test environment.
  • Project, process, and product documentation.
  • Organizing a development team and the assignment of specific roles.
  • Developing software in a phased way.
  • Translating vague user requirements into a concrete, testable product.
  • Defining a suitable product architecture.
  • Maintaining contact with the customer (an external person with a concrete problem).
  At the same time, also the portfolio will be finished. At the end of the software engineering project, the students will look back via a number of small individual exercises (needing about 1 day of work) onto the software engineering project and the bachelor phase. This addresses academic competences like reflecting and communication with non-technical people.
  




• Mathematics 5
  The aim of this course is to make student familiar with the basic concepts of probability theory and statistics. This means in the first place that students should be familiar with `statistical thinking': they should be able to translate a realistic (possibly simplified) situation into a probabilistic model. Secondly, the students are expected to be able to perform a statistical test and (thirdly) to report on results in a concise and mathematically sound way.
  1. Basic probability theory, conditional probability, independence, random variables, expected value, limit theorems. Special attention to probabilistic sums and conditional expectation. Applications in computer science.
  2. Statistics: point estimation, interval estimation, hypothesis testing, principles of linear regression
  




• Algorithmics
  The students learn to use standard techniques for optimisation problems, and learn about computational complexity theory and some advanced approaches to algorithm design. In many applications fast software is essential. Often this means that we need not only fast computers and good compilers, but also fast algorithms---especially when we want to compute the optimal solution for a problem that has many possible (but not equally good) solutions. Examples are packing problems, scheduling problems, and shortest path computations. In this course we discuss several general techniques to solve this type of problems. We will also explore the boundaries: when are the standard techniques not satisfactory, in theory and in practice, and what alternatives do we have? Branch-and-bound, dynamic programming, greedy algorithms, approximation algorithms, randomized algorithms, I/O-efficiency and NP-completeness (P = NP ?) will be the topics of this course. The course builds heavily on the material of the data structures course.
  




• Requirement analysis, design and verification
  The purpose of this course is to learn how computer steered system can be designed by mathematically modelling the behaviour of these systems and by verifying that this behaviour meets the requirements, before commencing to implement. The purpose is also to experience that the behaviour of contemporary systems is so complex, that without a proper a priori analysis of such systems, residual errors will most likely remain in the design of such systems. The course starts off with a crash course in process algebraic system description. Keywords are: Process algebra, interactions, behaviour, axioms, derivations, hiding and internal actions, data-process interaction. Linear processes. Cones and foci. Confluence. mCRL2 toolset. Modal logic and modelchecking. The first part will be terminated by an exam. In the second half of the course the focus shifts to the design of a small embedded system. First the requirements must be written down. Second a design of the system must be made and third the requirements must be proven to hold on the system, where faulty performance of some of the components must be taken into account.
  




• Motion and manipulation
  Motion and manipulation are key issues in the field of robotics and automation, but also play a major role in virtual environments and games. We will study models and planning problems for tasks that involve motion or manipulation. The motion planning problem is concerned with finding a path for an entity between an initial and final placement during which it avoids collision with the obstacles that are present in its environment. Our study of manipulation planning will concentrate on grasping and tasks involving simple actions such as pushing. The emphasis in manipulation will be on the design of industrial systems that are based on simple hardware elements performing simple physical actions. Geometry is a major parameter in the definition, modeling, and planning of manipulation and motion tasks.
  




• Visualization
  The aim of this course is to introduce students to the theory and practice of data visualization. The course is intended at students who already have a good knowledge of computer graphics, programming and data structures, and a basic knowledge of linear algebra and analysis. At the end of the course, the students should be familiar with the aims and problematics of data visualization, and have a good knowledge of the theory, principles, and methods which are frequently used in practice in the construction and use of data visualization applications. Moreover, the students should be able to design, implement, and customize a data visualization application of average complexity in order to get insight in a real-world dataset from one of the application domains addressed during the lecture. On a practical side, the students should understand (and apply) the various design and implementation trade-offs which are often encountered in the construction of visualization applications. The course covers the theory and practice of data visualization. This addresses several technical topics, such as: data representation; different types of grids; data sampling, interpolation, and reconstruction; the concept of a dataset; the visualization pipeline. In terms of visualization application, several examples are treated, following the different types of visualization data: scalar visualization, vector visualization, tensor visualization. Besides these, several additional topics are treated, such as: volume data visualization; domain modeling techniques; and a brief introduction to information visualization. The techiques treated in the course are illustrated by means of several practical, hands-on, examples.
  




• Formal methods
  Understanding of fundamentals of program verification with emphasis on tool support.
  Preparation for courses on special tool supported verification, like reducing the state space for model checking using advanced techniques like BDD's.
  
  The basic ideas underlying model checking for modal logics and and theorem proving for, mainly, Hoare style logics are covered.
  
  The course is self-contained in the sense that no prior knowledge beyond general bachelor material is required and also that a level is reached at which model checking and theorem proving tools can be used for program verification. contents 1. Fundamentals of formal methods: Syntax and semantics of assertional formalisms (Hoare logics) and modal formalisms (LTL, CTL, CTL*).
  
  2.a. Model checking and program verification. Labelling approach for CTL, automata intersection approach for LTL, combining these for CTL*. SMV or SPIN tooling.
  
  b. Theorem proving and program verification. Automated proofs for Hoare style verification. ESC/Java2 or Spec# tooling, connection to PVS.
  
  3. Some more advanced topics to be chosen.
  




• Game design
  Computer games form a prime use of computers these days. In this course we study how to design and develop computer games. Designing computer games is a complicated process involving aspect of psychology, liberal arts, human-computer interaction, artificial intelligence, etc. The emphasis of this course does not lie on the implementation aspects but on the design aspects of games. In particular the following aspects are treated:
  • what is a game
  • how do you design games
  • challenges and rewards
  • game balance
  • storytelling and narrative
  • game worlds
  • interactivity
  • behavior
  The course expects considerable involvement of the student, in the form of discussions during the meetings and the four assignments that must be completed (see below).
  The following topics are treated:
  • What is a game: history of computer games, game play, designing process,
  • Game play: rules, game balancing, flow, challenges, rewards
  • Game setting: game worlds, time, emotion, realism
  • storytelling, narrative and character design
  • interactivity: devices, tasks, motion control
  • technique introduction: graphics, behavior
  




• Three dimensional modeling
  The course 3D Modelling focuses on aspects of graphical modelling and animation issues for use with virtual worlds and game technology. A tentative list of topics is
  • parametric curves and surfaces, implicit surfaces, Bézier curves and surfaces, sweep surfaces
  • shape acquisition techniques
  • polygonal meshes, mesh compression, fractals, subdivision surfaces, spatial subdivisions
  • constructive solid geometry, model hierarchies, level of detail
  • physically-based modelling, particle systems
  • animation: traditional animation, object models, motion models, quaternions, kinematics.
  Lectures will focus on the underlying techniques and methods, and show practical examples. Lectures will include exercises that are important for developing understanding and skills
  




• Business process management systems
  After taking this course students should be able to:
  • have detailed knowledge of the functionality and architecture of WFM and BPM systems
  • model complex workflows
  • analyze complex workflows
  • have deep knowledge of classical Petri net theory
  This course focuses on enterprise information systems that are driven by models, i.e., instead of constructing code these systems are assembled, configured or generated using a model-driven approach. Of particular interest are so-called "process-aware" information systems. Typical examples are workflow management systems and the process engines of ERP, CRM, PDM and other enterprise information systems. Starting point for the course are the process modeling techniques taught in the Bachelor phase. In particular it is assumed that the students are able to model in terms of (high-level) Petri nets and are able to make object models. Nevertheless, a short refresher is offered to learn the main concepts.
  
  The first part of the course focuses on the modeling and implementation of workflows. Different languages and systems are presented. Using the so-called workflow patterns students need to compare and evaluate languages and systems. Moreover, students need to model and implement non-trivial workflows in a specific workflow management system (e.g.,YAWL). It should be noted that although the focus is on pure workflow management systems, the knowledge and experience will also applicable to other process-aware information systems.
  The second part of the course focuses on the analysis of workflows using Petri net theory.
  One of the topics is workflow verification, i.e., How to automatically identify design errors and correct them? Here different tools are being used and, among others, the SAP reference model and its errors are used as examples. This requires an introduction to concepts such as WF-nets, various soundness notions, free-choice nets, reduction rules, etc.
  




• Virtual worlds
  Virtual worlds consists in many forms. Certainly the most interesting virtual worlds are game worlds, both online and offline. Two of the most important issues in realistic virtual worlds are the physics and networking. Physics makes the virtual worlds as realistic as possible, while networking enable multiple users to enjoy the virtual world at the same time and interact with each other. Therefore, the emphasis in this course will be on both physics and networking. The course expects considerable involvement of the student, both in the form of a virtual world design assignment in groups and in the form the practical assignments.