After successful completion of the course, students are able to

• translate program descriptions given in natural language (i.e., programming tasks) into executable Java programs,
• describe systematic approaches to programming (for creating and using abstract data types including abstaction hierarchies as well as traversing and modifying recursive data structures),
• describe selected algorithms (like insertion, deletion, searching, comparing, sorting, iterating), data structures (variants of lists, trees and hash tables) and abstract data types (like data sets, queues, stacks, collections, lists, maps as well as hierarchies of them),
• implement and use specified data abstractions, algorithms and data structures,
• apply language concepts and techniques for data abstraction, traversal and modification of recursive data structures, input and output through files as well as quality assurance,
• describe important sources of errors as well as quality assurance techniques (verifying input data, exception handling, testing, documentation, code-review),
• act autonomously and as team players (teams of 2 persons) when solving programming tasks and thereby communicate properties of programs.

• concept of data abstraction and language features for data abstraction
• implementation and essential properties of recursive data structures (as lists and trees)
• implementation and essential properties of algorithms (for insertion, deletion, search, sorting, comparison, conversion, iterating) on several data structures
• abstraction over data structures with comparable access functions
• exception handling
• input and output over files, validation of input
• simple testing methods and code review
• approaches to program optimization and corresponding sources of errors
• programming styles and program documentation

• Lectures (talks) each Monday and Tuesday (10 a.m. c.t. in the Audi.Max., in German) give an overview of all topics in the course and provide examples. It is recommended to participate in all lectures. The first lecture (March 2) gives information on the organisation of this course.
• A script (in German) is available for download - see the "Documents" section. The script serves as an accompanying textbook and gives some information students shall know before taking this course. Hence, ideal students familiarize with the script before the course starts.
• Programming tasks on 7 exercise sheets have to be solved within about 1 week each. Solutions in the form of IntelliJ IDEA projects have to be uploaded before the deadlines.
• The team task is a slightly larger programming task to be solved by a team of two students within about two months. The solution has to be uploaded in the same way as for exercise sheets. Feedback to a preliminary solution has to be requested from a tutor in good time before the deadline, and given suggestions shall be considered in the final solution.
• Guided exercises take place in groups of approximately 25 students who meet 8 times for 45 minutes, one meeting for discussing each exercise sheet and the team task. In the meetings, students have to present their solutions of programming tasks when requested to do so by the exercise instructor. Furthermore, small programming tasks (exercise tests) have to be solved during the meetings either allone or in teams of two students (as requested by the exercise instructor) under pressure of time. Some exercise tasks may depend on solutions of exercise sheets; if the exercise sheet has not been solved, such exercise tests will be almost insolvable.
• The programming cafe is a weekly informal meeting in the InfLab where students can discuss their experiences and solve programming tasks together. At least one instructor or tutor will attend the meeting to provide assistance.
• There are two regular tests on computer terminals in the labs, 60 minutes each, where you have to answer multiple-choice questions and solve programming tasks. The first test will happen in the middle of the semester, the second at the end of the semester.
• For each regular test there will be a corresponding supplementary test. Results of these tests replace results of corresponding regular tests. Participation in a supplementary test is only possible if at least 50% of the accomplishable achievements in the guided exercises were accomplished and the corresponding regular test was missed or yielded a negative result. The supplementary test substituting the 1st regular test will happen shortly before the begin of the summer break, that substituting the 2nd regular test shortly after the end of the summer break.

Preliminary Talk

The preliminary talk (March 2, 2019, 10-11 a.m., Audi.Max.) gives much information on the organisation of this course. Please participate.

Who shall participate in the course

• Shortly after successfully completing "Einführung in die Programmierung 1" students shall participate in "Einführung in die Programmierung 2".
• Students, who got a negative mark in "Einführung in die Programmierung 1" shall not participate in "Einführung in die Programmierung 2". The only exception are students, who almost completed successfully, know the reasons for their failure and meanwhile eliminated these reasons.
• Students in the first semester shall participate only if they already have much programming experience in Java.

Registration

To participate, students have to register for a guided exercise group within the short registation period using TISS in order to determine room and dates.

Mail

For questions concerning this course please use the following mail address: ep2@complang.tuwien.ac.at

Please use your TU mail address for sending mails.

ECTS-Breakdown

(4 ECTS correspond to 100 hours of work)

• 21 h for participation in lectures
• 06 h for participation in 8 guided exercise meetings, 45 minutes each
• 03 h for participation in 2 regular tests,  60 minutes each (and proportionately in supplementary tests)
• 28 h for solving 7 exercise sheets (4 h for each sheet)
• 16 h for solving the team task
• 26 h for private study, programming cafe, test preparation

• A positive rating of this course requires that at least 50% of the accomplishable achievements were accomplished for each of the following three parts:
• guided exercises
• 1st test (1st regular test or alternatively the corresponding supplementary test)
• 2nd test (2nd regular test or alternatively the corresponding supplemantary test)
• If the rating of the course is positive, the mark results from the average of the percentages of achievements of the three parts:

1. :  87.5% to 100% (sehr gut)
2. :  75% to 87,5% (gut)
3. :  62.5% to 75% (befriedigend)
4. :  50% to 62.5% (genügend)
• The percentage of achievements for the guided exercises is the sum of "points" in the following three areas (at most 100 points in sum):
• up to 35 points: sum of the ratings of 7 exercise sheets and their presentations in guided exercise meetings (up to 5 points per exercise sheet), each calculated by (participation factor * points for solved tasks on the exercise sheet) where the exercise instructor determines the participation facor (1 usually; 0 on absence from the meeting, refusal of participation or obvious misunderstanding of a self-uploaded solution; a value between 0 and 1 if there are deficits in presenting),
• up to 32 points: sum of the ratings of 8 exercise tests (up to 4 points for each) by the exercise instructor,
• up to 33 points: rating of the team task by the exercise instructor, where the team task is rated with at most 17 points if no feedback was collected from a tutor before uploading the final solution.

Register for a group of this course. Group registration is regarded as registration for the course.

A script is available for download (in German only).

Before participating in the course students must be able to

• develop, modify, debug and document simple programs in Java as well as trace their executions,
• describe basic precedural concepts of Java,
• describe basic algorithms for searching in and sorting of arrays,
• describe sources of errors in simple procedural programs,
• act autonomously when solving programming tasks and communicate basic properties of simple programs.