modulewijzer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# INFDEV02-2 (Development 2, 2017-18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "This is the course descriptor for the _Development 2_ course.\n",
    "\n",
    "Development 2 covers the concepts in and around functional abstraction. The course opens with a description of the mechanisms of abstraction and its relationship to code reuse. It then moves on to a discussion about the semantics of function call. The stack is shown as a parameter storage, which plays a particularly interesting role when functions call other functions. Recursion is then introduced as a mechanism for calling a function from within its own body. Finally, we will introduce higher order functions and anonymous (lambda) functions. We will ultimately also combine all of these concepts (recursion, higher order functions, and anonymous functions) in large architectures based on some generic code. \n",
    "Many concrete examples are shown throughout the whole course: given the abstract nature of the concepts, we will strive towards showing many instances of these topics in action. The examples are small in size, but complex and exemplary in nature.\n",
    "\n",
    "An important reminder: the course (and the whole Informatica degree of Hogeschool Rotterdam as well, for that matter) is not meant to provide students with a series of tips and tricks to be quickly successful at one's job. Rather, the course aims to build a solid foundation upon which learning of all sorts of programming languages will be based. This *will*, without a doubt, prepare students not only for their first professional tasks, but for all their evolutions. Moreover, understanding of these concepts will allow students to wield their professional tools (programming languages) with certainty instead of intuition, thereby greatly increasing the quality of what they deliver and their value on the job market."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning goals\n",
    "The course has the following learning goals:\n",
    "- (ICODE) students can _recognize and formally interpret_ components of a programming language in their formal semantics: function definition, stack, function call, anonymous function, recursion, higher order function;\n",
    "- (ECODE) students _understand code_; _understand_ here means that students can describe the effect of running the program by predicting the sequence of state transitions produced by its execution;\n",
    "- (WCODE) students can _write small snippets of code_ in order to complete an existing program, from a clearly given specification of the state transitions that the completed program is expected to perform.\n",
    "\n",
    "The course, and therefore also the learning goals, are limited to imperative programs featuring a pervasive functional core, and the following Python 3 keywords and operators: \n",
    "- `def`\n",
    "- `return`\n",
    "- `lambda`\n",
    "\n",
    "All concepts and keywords learnt during the previous development courses (_Development 1_) are assumed to be available and built upon.\n",
    "\n",
    "The corresponding competences connected to these learning goals are: \n",
    "- realisation.\n",
    "\n",
    "### Learning materials\n",
    "\n",
    "The mandatory learning materials are:\n",
    "- reader of the lectures, which will be made available one week after the lecture\n",
    "- materials on the Github repository (github.com/hogeschool), which is already online"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exam\n",
    "The exam is divided in two parts:\n",
    "#### Theory\n",
    "- (FA) a series of four (4) *forward assignments*, that is exercises where students, given full code and partial state transitions produced by the code, are requested to complete the missing state transitions the code will produce;\n",
    "- (MC) a series of eight (8) *multiple choice* questions on the formal interpretation of state transitions induced by statements, expression evaluation, and state manipulation.\n",
    "\n",
    "#### Practice\n",
    "- (BA) a series of five (5) *backward assignments*, that is exercises where students, given partial code and the desired state transitions, are requested to fill in the missing code that matches the given state transitions.\n",
    "\n",
    "#### Scoring\n",
    "The theory results in a grade which is either PASS or FAIL. Each question awards one single point, if correctly answered. Students who score at least 75% of the total points will get a passing grade (PASS). For example, if the theory exam is made up by 12 questions in total, then a student needs to answer correctly at least 9 questions (since 8/12 = 67% and 9/12 = 75%) to get a PASS.\n",
    "\n",
    "Here below you can see some example of results. In the first column you find the percentage of correct answers given by the student. In the second column there is the corresponding grade in a scale from 0 to 10 that you will find in Osiris. The final result of this part of the exam can be seen in the third column: PASS (when the points percentage is greater than or equal to 75) or FAIL (otherwise).\n",
    "\n",
    "| Points percentage | Corresponding grade (from 0 to 10) | Result of the theory exam |\n",
    "| ----------------- |:------------------:|:-------------:|\n",
    "| 0%                | 0                  | FAIL          |\n",
    "| 12.5%             | 0.9                | FAIL          |\n",
    "| 25.0%             | 1.8                | FAIL          |\n",
    "| 37.5%             | 2.8                | FAIL          |\n",
    "| 50.0%             | 3.7                | FAIL          |\n",
    "| 62.5%             | 4.6                | FAIL          |\n",
    "| 75.0%             | 5.5                | PASS          |\n",
    "| 87.5%             | 7.8                | PASS          |\n",
    "| 100.0%            | 10                 | PASS          |\n",
    "\n",
    "\n",
    "The practice results in a full grade (from 0 to 10). Each assignment awards one single point, if correctly completed. The grade is computed as the percentage of points obtained, divided by 10. Students who score at least 55% of the total points will thus get a passing grade. For example, if a student completes 3 assignments out of 5, this means obtaining 3 points out of 5, which means 60% and corresponds thus to a 6 (60/10).\n",
    "\n",
    "**You receive the credit points for this course as soon as the theory result is PASS and the practice result is greater than or equal to 5.5**.\n",
    "\n",
    "Notice that, even though there are more FA's and MC's than BA's, the BA's require actively _writing code_, which is significantly more complex than reading code and describing states and bindings, seen that it combines technical understanding and creativity.\n",
    "\n",
    "#### Retake\n",
    "If only one of the exam parts is passed (theory or practice), then only the other will need to be retaken.\n",
    "\n",
    "#### Exam matrix\n",
    "The exam covers all learning goals.\n",
    "\n",
    "| Exam part     | ICODE         | ECODE         | WCODE         |\n",
    "| ------------- |:-------------:|:-------------:|:-------------:|\n",
    "| FA            |               | V             |               |\n",
    "| MC            | V             |               |               |\n",
    "| BA            |               |               | V             |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lecture plan\n",
    "The course is made up of eight lectures and practicums, usually planned as one lecture and one practicum per lesson week (for details, see lesson schedule on HINT). \n",
    "The lectures begin with an introduction of the basic concepts, which are then elaborated during the practicums. The lectures handle the theory, plus applied examples. Some of the applied examples are then further elaborated during the practicums.\n",
    "\n",
    "The lesson units covered by the course are the following:\n",
    "- Abstract vs concrete\n",
    "- Functional abstraction\n",
    "- Function definition and call\n",
    "- The stack\n",
    "- Functions calling other functions\n",
    "- Recursion and the induction principle\n",
    "- Higher order functions\n",
    "- Anonymous functions\n",
    "- An example applied to drawing: a higher order raster drawing function and an algebra of predicates \n",
    "\n",
    "Note that each lesson unit does not necessarily correspond to one lesson week (for example, one lesson unit could span during two lesson weeks or two lesson units could be handled during one lesson week)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Study points and contact time\n",
    "The course awards students 4 ECTS, in correspondence with 112 hours of study.\n",
    "\n",
    "The course consists of eight frontal lectures for the theory, and eight assisted practicums. The rest is self study."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}