Introduction to Software Engineering (INHN0006) - Summer 2022 (Heilbronn)
Intended Learning Outcomes
After successful completion of this module, students are familiar with the concepts and methods of the different phases of a software project, e.g. modeling the problem, reusing classes and components, and delivering the software. They have the ability to select and apply suitable concepts and methods for the development of software for concrete problems.
Students can explain the most important software engineering terms and workflows and are able to analyze and evaluate given problems. They can solve concrete problems in software engineering using development principles, methods and tools, e.g. design, architectural and testing patterns.
- Language: English
- SWS: 3V + 2Ü
- ECTS: 6
- Module: INHN0006 (Heilbronn)
- Course description: TUMOnline
- Prerequisite: Foundations of Programming (INHN0002)
- Only students, who passed INHN0002 or a comparable course, can participate in this course.
- You must have experience with object-oriented programming in Java.
- You can find more details below.
- TUMonline: You must register for this course in TUMonline before the course starts.
- Course Material: You can find slides and exercises on Artemis
- Code of Conduct: When participating in this course, you confirm to follow the:
- Time and Location:
- Mondays, 15:00 - 18:00 only on-campus (Heilbronn)
- Room D 2.01/02 - Bildungs Campus 2.
- Individual tutor groups (Registration required. More details in the first lecture.)
- Only on-campus (Heilbronn).
- Post your questions to the corresponding channels on Zulip.
- Please do not contact instructors on their personal email addresses!
- Announcements (Requires registration on TUMonline)
- Lectures and exercises are based on interaction; we expect active participation!
- Students can earn a bonus by completing in-class exercises, team exercises, and homework exercises successfully
- You must use your own computer during the lecture and during the tutor groups!
- You must have experience with object-oriented programming in Java, with an IDE (e.g. Eclipse, IntelliJ), and with git
Software engineering is the establishment and systematic use of engineering principles, methods, and tools for the division of work, the development and application of extensive, complex software systems. It deals with the development and production of software, the organization and modeling of data structures and objects, and the operation of software systems. Topics of the lecture include, among others:
- Model-based software engineering with the Unified Modeling Language (UML).
- Requirements elicitation and analysis (functional model, dynamic model, and object model).
- System design (specification, software architecture, architectural patterns, and design goals).
- Object design and implementation (reuse, design patterns, and interface specification).
- Testing (unit test, integration test, and system test, mock object pattern).
- Process models in software development, in particular agile development with Scrum.
- Configuration management, build management, release management, and container deployment.
- Quality management, software maintenance and evolution.
- Project organization and communication.
You need detailed experience in object-oriented programming to participate successfully in this course. You should be able to ...
- Understand Java syntax, create variables, write conditional statements (e.g. if and switch), and control structures (e.g. traditional for loop, enhanced for loop, and while loop)
- Use Java’s data types (e.g. bool, int, long, float, double, String) and operators (e.g. =, ==, !=, <, >)
- Create and invoke static and non-static methods
- Understand how to use collection types (e.g. Array, List, Set, Map, Stack) with generics
- Understand the differences between compile-time and runtime
- Understand the differences between compile-time types and runtime types
- Understand the differences between classes and objects
- Create classes, instantiate objects, use attributes, methods, constructors, and associations
- Use modifiers to apply information hiding
- Apply the concepts of encapsulation, polymorphism, and inheritance
- Write abstract classes and interfaces
- Understand the differences between overriding and overloading
- Apply exception handling
- Use lambda expressions and streams
- Create simple graphical user interfaces with JavaFX
- Use Maven (pom.xml) to configure dependencies
- Write simple test cases with JUnit 5
- Interact with git repositories (clone, commit, push)
Here are online tutorials to refresh your prerequisites:
- Interactive Java online tutorial: https://www.learnjavaonline.org
- Java beginners tutorial: https://javabeginnerstutorial.com/core-java-tutorial
- Core Java tutorial: https://www.studytonight.com/java
- In German: Online-Kurs Lernen objekt-orientierter Programmierung
- In German: Java ist auch eine Insel
- JavaFX tutorial: http://tutorials.jenkov.com/javafx
- JUnit 5 tutorial: https://www.vogella.com/tutorials/JUnit/article.html
- Interactive git tutorial: https://learngitbranching.js.org
- If you have not used Artemis before, please follow the tutorial (you might need to click on your login in the upper right corner and then on Continue Tutorial).
- Check if you meet the most important preconditions with the programming exercise. Try to solve this programming exercise on your own without the help of others. If you can solve all tasks in a few hours, you are well prepared for this course. If you have problems with some tasks, you should have another look at the online tutorials mentioned above. If you cannot solve all tasks in this programming exercise on your own, this course will be very difficult for you and we strongly recommend that you first learn the prerequisites in another course (e.g. INHN0001 and INHN0002) and then take the INHN0006 course.
Teaching and Learning Methods
By means of a slide presentation with animations, the interactive lecture introduces the concepts and methods of software engineering and explains them using examples. Small exercises, e.g. quizzes, modeling, and programming tasks, with individual feedback help students identify whether they have understood the concepts and methods.
Accompanying tutorials deepen the understanding of the concepts explained in the lecture by means of suitable group exercises and show the application of the different methods with the help of manageable problems in the different phases of software engineering. Homework enables students to deepen their knowledge in self-study. The presentation of the own solution in the accompanying tutorials improves communication skills, which are essential in software engineering. Individual feedback on homework allows students to measure learning progress and improve their skills.
Lecture with digital slides, online exercises (programming, modeling, quiz, text) with individual feedback, a communication platform for the exchange between instructors, tutors, and students.
Bernd Bruegge, Allen H. Dutoit: Object-Oriented Software Engineering: Using UML, Patterns and Java, 3rd Edition Publisher: Prentice Hall, 2009