Lecture notes

Martin Goik

Stuttgart Media University / MI

	Available formats:	Webhelp (this document) Zip archive for offline usage EPUB
	Hosted at:	HdM Stuttgart (primary site) medieninformatik.cloud (alternate site)
	Source code provided at `https://gitlab.mi.hdm-stuttgart.de/goik/GoikLectures`
	Published under the terms of the Creative Commons Attribution 4.0 International Public License.

Table of Contents

113105 Software development 1

Getting started

Lecture related resources

Using the exercises

Related resources

Coached exercises

Using plain Java™

Using Intellij IDEA

“Hello, World” and friends.
Simple calculations
A conditional
A loop

Language Fundamentals

Integer, ASCII and Unicode

Primitive types

Arithmetic limitations

Conversions

Operators and expressions

Arithmetic and logical operators
Assignment operators
Unary operators
Operator precedence

The if conditional statement

if-then-else
Using else if

The switch statement

From blocks to methods

while
do ... while
for

Logic related external exercises

Using automated tests.

Multi-dimensional arrays

Objects and Classes

Static methods

Working with objects

Object methods

Encapsulation and access control
Getter and setter methods
Signatures
Method overloading
Constructors
Scopes

Class members and methods

A mathematical table.
Interest calculations
Programmer's favourite expression
Lotteries revisited
The greatest common divisor and the common multiple

Maven project dependencies

Maven command line usage
Intellij IDEA on top of Maven

Building a library of mathematical functions.

Maximum and absolute value
Factorial, the direct way
Factorial, the recursive way
Binomials, the recursive way
Implementing exponentials.
Adding sine
Strange things happen

Unit testing

Tests and implementation
Improving the algorithm
Parameterized testing
Helpful Junit methods
Technical details
Example: A class representing fractions

Value types and reference types

Arrays reconsidered

Varargs method parameter
Reconsidering System.out.format().
java.util.Arrays helpers
Extending arrays
Understanding static int main(String[] args)
Tic-tac-toe
Providing statistical data
Prime numbers revisited
The median of a given sample.
Plotting functions

Method calls, the details

Enumerations (enum)

Enumeration by integer representation
Enumeration by dedicated class
Defining a private constructor
enum replacing class

Core Classes

Using class Math
String exercises
Analyzing file pathnames

Inheritance

Overriding equals() and hashCode()

Overriding toString()

final methods

Abstract methods

Geometry classes reconsidered

protected access

final classes

The instanceof operator

The @Override annotation.

Runtime polymorphism

Error Handling

Checked vs unchecked exceptions
Exceptions and Junit
Variants
Class java.lang.Exception

Working with Numbers

Boxing and unboxing
Number Parsing
Number Formatting
Working with Money
Generating Random Numbers

Advanced topics

interface definitions and abstract Classes

Interfaces and sorting
A nonsense generator
An interface based plotter

Application deployment I

Preparations
Exercises
Part II, Exercises

Reading character streams

Preparations
Exercises

Collections

Preparations
Collections I, Exercises
Collections I, Exercises
Collections III, Exercises
Collections IV, Exercises
Maps 1, Preparations
Exercises
Towns and country names
Creating an overview of grades

Examination bonus point projects

Weather forecast
Reverse Polish notation (RPN) calculator
Currency converter, Summer 2017
An address database, Winter 2016
Poor man's UNIX grep, Summer 2016
Project Euler's sieve, Winter 2015

Exercising past examinations

Starting an exam
Implementing the project skeleton
Finish the exam

Examination hints

Past Software Development 1 examinations

2025 winter
2025 summer
2024 winter
2024 summer
2023 winter
2023 summer
2022 winter
2021 winter
2021 summer
2020/1 winter
2020/2 winter
2020 summer
2019 winter
2019 summer
2018 winter
2018 summer
2017 winter
2017 winter
2015 winter
2015 Sommer
2014 Winter

Past Software Development 1 exam preparing tests

Test 01
Test 02
Test 03
Test 04
Test 05

Working with git

Working with git locally.
Shared development with centralized remote.
Conflicts

Apache Maven

The project object model pom.xml
Plugins
Dependencies
Lifecycle, phases and goals

List of software development 1 lecture exercises

113492 Technical Documentation

Software independent considerations

General remarks

Common building blocks

Block level elements

Target formats
Selected elements
Schematron
Customizing
Assemblies
Styling the editor application

Modular documents

RelaxNG Schema

Transforming documents

Target format HTML
Target format print

TeX / LaTeX
Docbook

LaTeX hello,... world
Important elements
Macro
A complete document

Project proposals

Building a reveal.js editor
Authoring journey descriptions
Gitlab pages integration of Docbook
Codingbat reloaded
XML based exercise compilations
Past projects

List of software development 1 lecture exercises

113473 Database and application development

Database features

Selected database products overview

Installation
Features
Exercises

Installation
Features
High performance sharding cluster
Exercises

JDBC: Accessing Relational Data

Persistence in Object Oriented languages

Introduction to JDBC™

Write access, principles
Write access, coding!
JDBC™ and security
Read Access
Dynamically load a JDBC™ driver
Handling surrogate keys
Transactions

Configuring a Maven based Eclipse Java™ project with Hibernate

Creating a JPA configuration

A round trip working with objects

Persisting objects
Loading Objects by primary key
Loading objects by queries
Criteria based queries

Mapping single entities and database tables

Transient properties
Properties and NULL values
Defining keys
Composed keys
Indexes (non-unique)
Renaming tables and attributes
Changing the default type mapping
Object states and transitions
XML to JPA using JAXB

Inheritance

Single table per class hierarchy
Joined subclasses
Table per concrete class

Mapping related Components and entities

Primary keys revisited
Entity and value types
Mapping components

orphanRemoval vs. CascadeType.DELETE

Project ideas

Extending UNIX grep to databases
Database copy tool
Creating data samples
Database schema evolution tool

List of Database and application development lecture exercises

113475 Software defined Infrastructure

Manual server management

Preliminaries

Hetzner cloud administration GUI

Public / private key pair
Pass phrases and ssh agent
Agent forwarding
Port forwarding
X11 forwarding
Network data transfer using scp, rsync and ssh

Prerequisites

Ubuntu / Debian Package management

Prerequisites

Cloud provider

Working with Terraform
Cloud-init
Terraform modules
Volumes
Terraform loops
Terraform and DNS
Generating web SSL certificates
Private networks

Preliminaries
Exercises

Recommended Preparations
Exercises

Apache web server

Preliminaries
Exercises

Exercises

Network file systems served by Samba

Prerequisites
Samba server installation

Recommended Preparations
Exercises

Introduction
Exercises

Functional checks
SNMP based checks
ssh based checks

List of Software defined Infrastructure lecture exercises

Common topics

Project documentation

Bibliographic links

List of Figures

1. How much time to invest?
2. Your biggest enemies
3. German humour
4. AI tools and learning
5. 4 most imperative study objectives
6. Tuition attendance and exam results summer 2025
7. Examinations and result
8. Moodle and tuition groups
9. BW Lehrpool pool rooms
10. Recommended reading resources I
11. Recommended reading resources II
12. Online tutorials
13. Unix and the terminal
14. Online programming, automated feedback
15. Online programming I
16. Online programming II
17. Choosing the SD1 bwLehrpool VM
18. Intellij IDEA IDE
19. Live lecture additions
20. Embedded exercises
21. Using the exercises
22. HdM mail server
23. Configure MI VPN client access
24. MI Cloud server
25. MI File server
26. MI Git versioning server
27. Coached exercises
28. Edit - compile - execute
29. Defining class Hello
30. Compiling Java™ file
31. Command line Java™ file compilation
32. Java byte code file Hello.class
33. Source code vs. bytecode
34. Executing byte code file Hello.class
35. Command line byte code file Hello.class execution
36. Wrap up: The edit - compile - execute cycle
37. Intellij IDEA requires a JDK™
38. Intellij IDEA installation
39. Idea »Ultimate« license types
40. Alternative: Using the HdM license server
41. Creating a new Java project
42. Getting first Java™ impressions
43. Manual calculation: Abacus
44. Mechanical calculation: Cash register
45. Electromechanical calculation: Zuse Z3
46. Vacuum Tube: Eniac
47. Transistor: Microprocessor ICs
48. Z80 8-bit data bus
49. Progress in hardware 1
50. Progress in hardware 2
51. Simple facts:
52. Unsigned 3 bit integer representation
53. Binary system addition
54. 3 bit two-complement representation
55. 3 bit two complement rationale: “Usual” addition
56. Signed 8 bit integer binary representation
57. 7-bit ASCII
58. 7-bit ASCII with even parity bit
59. Western European characters: ISO Latin 1 encoding
60. Unicode UTF-8 samples
61. Java types
62. Java signed integer primitive types
63. Four int literal representations of decimal 29
64. Java unsigned integer, floating point and boolean primitive types
65. Variables: Handles to memory
66. Local variable declaration
67. Declare, assign and use
68. Combining declaration and initialization
69. Compound declarations
70. Identifier in Java™:
71. Identifier name examples:
72. Java™ keywords.
73. Note on contextual keywords
74. Variable naming conventions
75. Constant variables
76. Case sensitivity
77. Define before use
78. Type safety
79. Compile time analysis
80. Type inference (JDK™ 10)
81. Forcing conversions by cast
82. Watch out!
83. Casting long to int
84. Casting double to short
85. «C» programming language “liberal” assignment policy:
86. Consequences
87. From the report
88. Dynamic typing in PERL
89. Dynamic typing in PERL, part 2
90. Using final
91. Reference type examples
92. float and double
93. Four ways representing 35
94. Choose your output representation
95. Know your limits!
96. Literal examples
97. int literals
98. Just kidding ...
99. Strange things I
100. Strange things II
101. Limited floating point arithmetic precision
102. Nearest float to 0.1F
103. FloatConverter
104. Integer division: Take care!
105. Widening from byte to short
106. Narrowing from int literal to char variable
107. A widening «ladder»
108. A narrowing «ladder»
109. The binary plus operator
110. Binary operator output type
111. Detecting arithmetic overflow (Java 8+)
112. Dividing by zero
113. Generic binary operator
114. The modulus operator %
115. Binary operator type examples
116. No binary + operator yielding byte
117. int expression assignment
118. Constant expression assignment
119. The logical “and” operator &
120. The += operator
121. The &= operator
122. Arithmetic assignment operators
123. Logical assignment operators
124. Increment operator ++
125. Different range behaviour!
126. Cast required
127. Prefix and postfix notation
128. Operator examples
129. Precedence of “*” and “/” “+” over “+” and “-”
130. A binary operator's operands evaluation priority
131. “left to right” or “right to left”
132. Operator precedence references
133. “+” acting as string concatenation operator
134. Implicit string conversion and concatenation
135. Java™ comment flavors
136. Inline comments by /* ... */
137. Javadoc™ comments
138. Statements: General syntax
139. Statement examples: Declaring and assigning variables
140. Expression vs. statement
141. Multiple statements per line
142. Debugging multiple statements per line
143. Method local variable scope
144. Nested blocks and variable scopes
145. Block purposes
146. Principle of swapping two variables
147. Swapping two variables
148. Swapping two variables using a block
149. Conditional block execution
150. if syntax
151. if ... else
152. if ... else syntax
153. Best practices comparing for equality
154. Single statement branches
155. Nested if ... else
156. Enhanced readability: if ... else if ... else
157. if ... else if ... else syntax
158. User input recipe
159. Using a Scanner class collecting user input.
160. Converting numbers to day's names
161. Numbers to day's names: The hard way
162. Better: Using switch
163. switch Syntax
164. Switching on strings
165. switch expressions
166. Assigning switch expressions
167. Allowed types for switch statements
168. Labels must be constant expressions
169. Two blocks, same logic
170. Replacing two blocks by one method
171. Passing values to methods
172. Passing values to methods
173. Why loops?
174. Number of repetitions given by user input
175. A while loop
176. Combining increment and termination condition
177. while syntax
178. Empty while body
179. A do ... while loop
180. do ... while vs. while
181. do ... while syntax
182. Frequent usage of while
183. Replacing while(...) by for(...;...;...)
184. for syntax
185. for variable scope
186. for variable scope equivalence
187. for vs. while relationship
188. Nested loops 1
189. Nested loops 2
190. Better readability: row and column in favour of i and j
191. Calculating values
192. Response to coding errors
193. Unit test concept
194. alarmClock(...) with errors
195. Testing alarmClock(...)
196. Testing alarmClock(...) details
197. Motivating Arrays
198. Per member repeating tasks
199. Example: int array of primes
200. Loop prime values
201. Mind the limit!
202. Safer: Using length
203. Even better: “for-each” style loop
204. Mind the limit, part two
205. Primitive data one step initialization
206. Array
207. Two syntax variants
208. Passing an anonymous array to a method
209. Two-dimensional arrays
210. Behind the scenes
211. Memory allocation
212. Nested array initialization
213. Nested »ragged« array initialization
214. A method adding two values
215. Syntax of method definition
216. The static modifier matters!
217. Documentation: Javadoc™ is your friend!
218. Separating usage and definition
219. Representing two-dimensional points
220. General class structure
221. What's a class anyway?
222. Rectangle objects
223. A class describing rectangles
224. Rectangle class and instances
225. Generated diagrams
226. The new operator: Creating rectangle instances
227. Syntax creating instances
228. Assigning attribute values to class instances
229. Instance memory representation
230. References and null
231. Checking for object presence
232. Why packages ?
233. Rules and conventions
234. Fully qualified class name vs. import
235. Don't be too lazy!
236. Special: Classes in package java.lang
237. Class, package and file system
238. Source hierarchy view
239. Object methods
240. Get a rectangle's area
241. Currently: rectangle's area by class method
242. OO: rectangle's area by instance method
243. Transition to OO
244. Scaling a rectangle
245. Scaling method implementation
246. Scaling method signature
247. Using the scale(...) method
248. Method definition syntax
249. A rectangle's perimeter
250. getPerimeter() method implementation
251. Using Rectangle.getPerimeter()
252. Access control: Overall objectives
253. Example: Two ways implementing a day's time
254. private modifier access violation
255. Absent access modifier, access violation
256. Access rules
257. “Tips on Choosing an Access Level”
258. Direct access vs. setter method
259. Why adding setter methods?
260. Implementation change: Minutes only, no hours
261. Defining type signatures
262. Type signature examples
263. Defining method signatures
264. Method signature examples: Ignore return type!
265. Method overloading: Same name, different signature
266. Overloading, alternate names
267. No overloading in »C«
268. »C« requires unique function names
269. No distinction on return type
270. Method signatures rationale
271. Method signatures rationale
272. Example: IO.print(...)
273. Creating and initializing rectangles
274. Defining a constructor
275. Constructor syntax
276. Constructors
277. Multiple overloaded constructors
278. Constructor calls within constructor
279. Instances by overloaded constructors
280. No constructor vs. default constructor
281. Non - default constructor, but no default constructor
282. Employee example package hierarchy
283. Circle and variable scopes
284. Documenting classes and methods
285. Generated Javadoc
286. Refactoring «r» ⇒ «radius»
287. Scope assignment problem
288. this overriding method scope
289. Why should we require an instance?
290. Solution: Replace instance method by class method using static
291. Club membership objectives
292. Step 1: Implementing club member names.
293. Showing membership info.
294. Step 2: Adding membership numbers.
295. Showing membership numbers.
296. Member creation steps
297. Accessing the club's overall member count?
298. Accessing the club's member count
299. Syntax accessing class members
300. static / non-static wrap up
301. Finally understanding IO.print(ln)
302. Newton's letter to Robert Hooke
303. Application execution prerequisites
304. Why Maven project management?
305. Example: Creating PDF using iText7
306. Maven iText library pom.xml definition
307. Itext transitive dependencies
308. Class location in iText library
309. Class location in iText library
310. Maven repositories
311. Maven archetypes
312. Project «lottery» depending on «common»
313. Providing project «common»
314. Publish project «Common»'s library
315. Content of archive common-1.0.jar
316. Consuming project «lottery»
317. External libraries view
318. Using Helper.factorial(...) computing $(\begin{matrix} n \\ k \end{matrix}) = \frac{n!}{k! (n - k)!}$
319. Maven artifact dependency.
320. Using the MI Sd1 project template
321. CLI example
322. Supplementary MI Maven archetypes
323. CLI testing mi-maven-archetype-quickstart
324. CLI archetype details
325. Generated project layout
326. Maven compile
327. Compilation file view
328. Maven package
329. Executing Java™ archive second-0.9.jar
330. Maven javadoc:javadoc
331. Maven clean
332. Intellij IDEA Maven support
333. Adding MI Maven server
334. New MI archetype project
335. pom.xml content changes
336. Intellij IDEA generating Javadoc™
337. Pascal's triangle representing binomial coefficients.
338. An implementation sketch for the exponential
339. Comparing exponential and approximation
340. Comparing sin(x) and its approximation.
341. Recommended reading
342. Test categories
343. Example: Computing prime numbers
344. Unit test principle
345. Test driven development
346. Steps in Unit Testing
347. Step 1 + 2: Specify method, write skeleton
348. Execution yet being flawed
349. Sample test data
350. Step 3: Junit based specification test
351. Junit skeleton test result (Maven CLI)
352. Junit skeleton test result (IDE)
353. Providing explanatory failure messages:
354. Step 3: Providing more prime tests
355. Step 3: Prime mass testing
356. Step 4: Implement skeleton
357. Step 5: Testing our first implementation
358. Implementation observation
359. Changing the implementation
360. Regression test
361. Systematic error debugging
362. Error correction in detail
363. Parameterized tests
364. CSV parameter testing
365. CSV parameter testing results
366. CSV parameter file based testing
367. Available comparison methods
368. Caution comparing float / double !!
369. Weird arithmetics?
370. Limited representation precision
371. Solving the issue
372. The @Test annotation
373. The Assertions class
374. Importing dependencies
375. Dependency archive content
376. Value vs. reference type variables
377. Different behaviour!
378. Value variable Details
379. Reference variable Details
380. Only «call-by-value» in Java™
381. «call-by-value» details
382. «call-by-reference» for objects?
383. «call-by-reference» details
384. No «call-by-reference» in Java™!
385. No «call-by-reference» details
386. C++ reference operator “&”
387. C++ offers «call-by-reference» by virtue of “&”
388. C++ «call-by-reference» details
389. Reference data one step initialization
390. Array instances are special!
391. Array creation details
392. Array parameter passing
393. Parameter passing details
394. Array initializer: Value and reference types
395. Expecting one int argument
396. One, two or three int arguments by overloading
397. Observations
398. Arbitrary number of arguments by array
399. Vararg: Syntactic sugar by ellipsis »...«
400. Varargs preconditions
401. Further reading on varargs
402. Arrays.toString(...) and Arrays.sort(...)
403. Arrays.binarySearch(...)
404. Arrays.fill(...)
405. Arrays.copyOfRange(...)
406. Arrays.equals(...)
407. Lack of extendability
408. Extending an array
409. Extension result
410. Using Arrays.copyOf()
411. static void main(String[] args)
412. Intellij IDEA run configuration
413. Intellij IDEA run configuration
414. Creating executable jar
415. Two Tic-tac-toe players fighting each other.
416. Two Tic-tac-toe players fighting each other.
417. Method calling
418. Three variable scopes
419. Scope lifetimes
420. Two runtime memory categories
421. Stack: Four operations
422. Example: Storing integer values
423. Method calling
424. Call stack trace
425. IDE debugger
426. Motivation
427. Weekly offered lectures
428. Weekly offered lectures by simple numbers
429. Weekdays int representation
430. Weekly offered lectures using constants
431. Converting index values to day names
432. Providing lecture info
433. Sample lectures
434. Pitfall #1 of 2: Bogus day index value
435. Pitfall #2 of 2: Method argument order mismatch
436. Enumeration by class instances
437. Class instance per enumeration value
438. switch no longer works
439. Re-writing getPrice()
440. Pitfall: Creating an undesired instance
441. Define a private Day constructor
442. Preventing undesired Day instance creation
443. Adding a day name attribute
444. enum Day replacing public class Day
445. switch statements working again
446. enum constructor being implicitly private
447. Openjdk source code repository
448. Java Visualizer
449. Superclass Object
450. String literals
451. OpenJDK String implementation
452. String copy constructor
453. Copy constructor and heap
454. Operator == and equals()
455. Remarks == vs. equals()
456. Operator == and equals() implications
457. equals() is being defined within respective class!
458. Math.sin(double x)
459. Guess who's inheriting the money
460. Biology and inheritance
461. Duplicate code
462. Idea: Centralize common code
463. Common and specific properties
464. Basic shape inheritance
465. Inheritance
466. Implementing Shape hierarchy
467. Creating instances
468. Shape constructor
469. Creating Rectangle instances
470. Rectangle constructor
471. Shape.equals()
472. Rectangle.equals()
473. Printing a Shape's info
474. Overwriting toString()
475. Shape extending Object
476. Logging Rectangle instances
477. Overriding toString() in Rectangle.
478. Rectangle extending Shape
479. Implementing Circle.toString()
480. Shape and toString()
481. Moving Shape instances
482. Implementing Shape movements
483. Fools are everywhere!
484. Solution: final prevents overriding
485. Calculating a shape's area
486. Desired: Polymorphic getArea() call
487. Problems:
488. abstract method getArea()
489. abstract method getArea()
490. What's a “shape” anyway?
491. No instances of abstract classes.
492. Mandatory getArea() implementation.
493. Facts about abstract fields, methods and classes.
494. Moving shapes
495. protected access
496. final classes
497. final classes rationale
498. “Defeating” polymorphism
499. Defining equals(...): Expectations
500. Defining equals(...) of Shape instances
501. Comparing center coordinates
502. Implementing Rectangle.equals()
503. Implementing Circle.equals()
504. Testing equality of Shape objects
505. Overriding Object.toString()
506. @Override: Compile time error detection
507. Meta info of an instance
508. Getting instance meta info
509. Implementing getArea()
510. Polymorphic getArea() call
511. Runtime polymorphic dispatch
512. Polymorphic dispatch pseudo implementation
513. Compile- vs. runtime errors
514. NullPointerException (NPE for short)
515. NullPointerException is a class
516. Throwing an exception
517. Catching an exception by try {...} catch {...}
518. try {...} catch {...} syntax
519. Checked and unchecked exceptions
520. Further readings
521. Checked and unchecked exceptions
522. Expected exceptions in Junit
523. Just finally, no catch
524. try-with-resources (Java™ 7)
525. Scanner implementing AutoCloseable
526. No close() method in e.g. class String
527. Method printStackTrace()
528. Ascending inheritance ordering
529. Wrong ordering
530. Implementing convert
531. Problem: “Silent” errors
532. Step 1: Find exception base class
533. Step 2: Derive CardinalException
534. Step 3: Throwing CardinalException
535. Step 4: Unit test throwing CardinalException
536. Stack of integer values
537. Java™ collection features
538. Behind the scenes
539. Boxing and unboxing
540. Boxing syntax comparison
541. Parsing Integer user input
542. Parsing binary representation
543. Standard parse methods
544. Excerpt from java.util.Locale
545. Locale properties
546. Get a NumberFormat instance
547. Create a custom formatter
548. Polymorphic number parsing
549. Limited float precision
550. Limited double precision
551. Using BigDecimal
552. Chaining BigDecimal operations
553. BigDecimal features
554. Using static double random()
555. Seeding a pseudo random generator
556. Interface examples
557. Observations
558. Writing strings to file
559. Using Text2File
560. Possible Text2File errors:
561. Employ “try-with-resources”
562. interface syntax
563. The AutoCloseable promise
564. abstract class replacement
565. interface vs. abstract class
566. interface MyAutoCloseable
567. Extending MyAutoCloseable to flush
568. Using MyFlushable
569. Inheritance hierarchy
570. Upcoming topics
571. Interfaces implemented by class String
572. The Comparable interface
573. class String and Comparable
574. Comparison examples
575. Ascending and descending names
576. API requirements
577. Sorting strings alphabetically
578. Situation dependent sorting criteria
579. Implementing flexible sorting
580. Comparator in action
581. Case insensitive sort
582. Sort descending by lambda expression
583. Account hierarchy
584. Students and lecturers
585. An array of strings
586. An associative array describing month lengths
587. Grouping towns by country names
588. Collaborative efforts
589. Project rules
590. Internal code documentation
591. Internal code documentation hints
592. Javadoc™ mismatches
593. (Automated) tests
594. Deployment and execution
595. Marking criteria
596. Sample forecast session
597. Sample forecast invocation
598. Underlying data provider
599. cities.list.json.gz providing cities
600. ma/Copy URL result to file
601. Parse city data
602. Parse weather data
603. Requirements
604. Logging
605. Minimalist token scanner
606. Scanner output -1.34 0.34 + sqrt
607. Adding error detection
608. Error message
609. Running the currency converter terminal application.
610. Exam training by Guacamole
611. Environment hints:
612. Preparing an examination
613. Generating Javadoc™.
614. Programming hints
615. The implement - test - implement cycle
616. Finishing the exam
617. Personal examination cheat sheets
618. Unit tests in examinations
619. Example interface definition
620. Corresponding test
621. Don't cheat!
622. Unit tests strategy in examinations
623. Steps creating a new project
624. Creating a project at MI gitlab
625. Cloning a git project
626. Enter project folder, add Readme.md
627. Committing change set
628. Push to upstream repository
629. Inserting a Maven project
630. git status 1
631. Adding Maven files to repository
632. git status 2
633. Commit Maven project files
634. git status 3
635. Push to upstream again
636. Reverting changes
637. Pull changes from upstream
638. From https://www.urbandictionary.com
639. Useful links
640. Initialize git project
641. Configure author related data.
642. Adding resources to project index and staging area
643. Committing change set
644. Project versioning status
645. Adding a comment
646. git diff tracing changes
647. Reverting individual file.
648. Compiling, Math.class and Print.class.
649. Math.class, Print.class and versioning.
650. Show project's log
651. Switch to an older revision ...
652. ... and forth to current master's HEAD
653. Centralized remote repository
654. Step 1: Create remote repository
655. Step 2: Retrieve remote repository address
656. Step 2: Connect to remote repository
657. Step 3: Push local to remote
658. Step 3: Pull remote to local
659. Alternative: Create remote, then clone
660. Conflicting changes
661. Commit schedule
662. User B: git push fails
663. User B: git pull fails as well
664. Merge conflict details
665. Struggling for resolution
666. Merging Print.java manually
667. Commit and push merge
668. Maven: Recommended reading
669. What is Maven anyway?
670. Maven: Facts and benefits
671. Convention Over Configuration
672. Maven project layout
673. The project object model file
674. pom.xml characteristics
675. pom.xml vs. Makefile
676. «Hello, world» pom.xml
677. Executing «compile» phase
678. Examining the Java™ version culprit
679. Resolving encoding / Java™ version issues
680. POM inheritance
681. The Super POM
682. pom-4.0.0.xml content
683. Favour https in ~/.m2/settings.xml
684. Resolving to effective pom.xml
685. Plugin architecture
686. Sample plugins
687. Example: The maven-javadoc-plugin
688. Adding test capabilities
689. Dependency listing
690. Absence of hamcrest in pom.xml
691. ~/.m2/repository/junit/junit/4.12/junit-4.12.pom
692. Transitive dependencies
693. Oblivious to test implementation: TestNG
694. Phases
695. Maven lifecyles and phases
696. hooking into phase
697. Why XML based publishing?
698. XML features
699. Editors, compositors, designers ...
700. Promises in publishing
701. Publishing reality
702. Single source publishing
703. Separating Structure, content and format
704. Separating concerns
705. Content
706. Hierarchical structure
707. Hierarchical structure, XML source
708. Presentation
709. Example 1: HTML 5, pure structure
710. Example 2: TeX / LaTeX
711. Separating structure and presentation(s)
712. Sample technical document
713. Observations
714. Pros and cons of TeX / LaTeX
715. Tools of the trade
716. Inline formatting
717. Paragraphs
718. Lists
719. Tables
720. Images
721. Mathematical formulas
722. Cross references
723. Document sectioning
724. Modular document components
725. What is Docbook?
726. Authoring and publishing
727. Document representation
728. Software centric schema
729. Document targets
730. Docbook components
731. Target format overview
732. Tooling / Software
733. Different schema languages
734. Plain HTML
735. Web help
736. Eclipse help
737. Printed output
738. Paragraph
739. Itemized list
740. Ordered list
741. Glossary list
742. Nested lists
743. Reference
744. A table
745. A MathML equation
746. A TeX equation
747. Reference
748. Figure
749. Image map + calloutlist
750. Video
751. A warning
752. Reference
753. Recursive sections
754. Non-recursive sections
755. Two different link flavours
756. Choosing a top level element
757. Allowed 5.1 top level elements
758. Schematron on top of RelaxNG
759. Example: xml:id and permalink
760. Using Display #Anchors
761. Considerations author based permalink
762. Schematron permalink rule
763. HTML customization overview
764. Target specific configuration
765. Link stability
766. use.id.as.filename = 1
767. Parameter: use.id.as.filename
768. Customization parameter ulink.target
769. callout.unicode / callout.graphics
770. Links
771. Hooking into XSL
772. Categories
773. Example: videos
774. Links
775. Customize by CSS
776. Example CSS modifications
777. Styling the editor
778. Motivating modular documents
779. Monolithic document problems
780. Document decomposition
781. A monolithic document
782. Decomposing documents
783. XML grammar defining languages
784. Address list schema
785. Format conversion problem
786. XSL template rules
787. Example: Formatting <title> elements
788. Basic FO introduction
789. XMLMind Editor
790. Oxygenxml Author
791. Vendor links
792. Inverse editing
793. Document representation
794. Components
795. BibTeX
796. Makeindex example
797. Makeindex work flow
798. Extension example: MusiXTeX
799. Flavours
800. Components
801. Editors
802. reveal.js authoring tools: Principle
803. reveal.js features #1 of 3
804. reveal.js features #2 of 3
805. reveal.js features #3 of 3
806. reveal.js observations
807. Authoring tool project goals
808. Principle
809. Required / to be acquired skills
810. Principle
811. Codingbat: Desired features
812. Desired features
813. CRUD operation
814. Query
815. Schema
816. Procedures / triggers
817. Transactions / recovery
818. Data access control
819. API support
820. Installing Docker
821. Why LDAP?
822. LDAP introduction
823. Running a Docker container
824. Using docker-compose
825. Installing Apache Directory Studio
826. Administrator access to your DIT
827. Administrator access to your server's data tree
828. Administrator access to your server's configuration
829. Terminology
830. Adding an entry
831. Adding a new attribute
832. Replacing an attribute value
833. Deleting an attribute entirely
834. Multi valued attributes
835. Set semantics of multivalued attributes
836. Deleting selected attribute values
837. Query scope
838. Query filter
839. Schema support
840. Implementations
841. Implementations
842. Exercises
843. Why MongoDB?
844. Running a Docker container
845. Using docker-compose
846. Manual user creation
847. Log in as user explorer
848. Using IntelliJ
849. Idea show all databases
850. Terminology / Hierarchy
851. Adding a document
852. Updating attributes
853. Deleting a document
854. Deleting multiple documents
855. Multi valued attributes
856. Set semantics of multivalued attributes
857. Deleting selected attribute values
858. Deleting an attribute
859. Query filter
860. Schema validation support
861. Violating required field
862. Schema types
863. Enforcing unique keys
864. On the downside
865. Implementations
866. Implementations
867. Sharding rationale
868. Sharding rationale
869. Exercises
870. Prerequisite knowledge
871. Persistence [Bauer2015]
872. Java™ transient instances
873. RDBMS persistent records
874. Persisting transient User instances
875. Observations
876. Networking between clients and database server
877. JDBC™ features
878. JDBC™ in a three-tier application
879. JDBC™ connecting application server and database.
880. JDBC™ connection parameter
881. Components of a JDBC™ URL
882. IETF Uniform Resource Identifier
883. URL examples
884. Sub protocol examples
885. No standard port assignments ...
886. ... but Postgresql made it into Linux
887. JDBC™ architecture
888. DriverManager: Bootstrapping connections
889. Example: Mysql connection implementation
890. Driver libraries
891. Driver libraries by Maven
892. Driver unavailable
893. Connection interface
894. Statement interface
895. JDBC™ instances and relationships.
896. Important Connection methods
897. Important Statement methods
898. JDBC™ and threading.
899. JDBC™ connection pooling
900. pom.xml driver runtime scope
901. Person table
902. Objective: insert person record
903. JDBC™ backed data insert
904. Result
905. Two JDBC™ configurations
906. Figure 903, “JDBC™ backed data insert ” deficiencies
907. Why properties?
908. message.properties string externalization
909. Properties code sketch
910. Intellij IDEA settings, preconditions
911. Database related unit test phases
912. Implementing unit tests
913. Spring is your friend
914. Project layout
915. Closing connections
916. Employ AutoCloseable
917. Sniffing a JDBC™ connection by an intruder.
918. Setting up Wireshark
919. Capturing results
920. Mysql™ security
921. Mysql™ security
922. Assembling SQL
923. SQL injection principle
924. Preventing traffic tickets
925. Trouble at school
926. SQL injection impact
927. SQL injection relevance, [Clarke2009]
928. Handling injection attacks, part 1
929. Handling injection attacks, part 2
930. Input filtering
931. Validating user input prior to dynamically composing SQL statements.
932. Error message being presented to the user.
933. SQL statements in Java™ applications get parsed at the database server
934. Two questions
935. Addressing performance
936. Addressing performance mitigation
937. Restating the SQL injection problem
938. Solution: Use java.sql.PreparedStatement
939. PreparedStatement principle.
940. Three phases using parameterized queries
941. PreparedStatement example
942. Injection attempt example
943. Limitation: No dynamic table support!
944. JDBC™ read and write
945. Server / client object's life cycle
946. JDBC™ record container
947. Reading data from a database server.
948. Names and birth dates of friends
949. Accessing friend's database records
950. Important ResultSet states
951. JDBC™ to Java™ type conversions
952. Java™ to JDBC™ type conversions
953. Error prone type accessors!
954. Polymorphic accessor
955. Access by column name
956. Access by column index
957. Problem: null value ambiguity
958. Resolving null value ambiguity
959. Problem: Dynamic driver configuration
960. Shim driver (facade)
961. Users and groups
962. Isolation level
963. JDBC™ Isolation level
964. Setting the isolation level
965. Reasons for using Maven
966. Transitive dependencies
967. A basic persistence.xml JPA configuration file.
968. JPA persistence provider
969. Mapping hibintro.v1.model.User instances to a database.
970. A basic User class.
971. Mapping properties to attributes.
972. Annotating integrity constraints
973. Database schema mapping instances of hibintro.v1.model.User.
974. Loading a single object by a primary key value.
975. Retrieving hibintro.v1.model.User instances by HQL.
976. Business rules for projects
977. Persistence related object states
978. Introducing inheritance mapping
979. Modelling payment.
980. A single relation mapping.
981. Mapping the inheritance hierarchy.
982. Inserting payment information
983. Figure subclasses
984. Joined subclass mapping.
985. Implementing Object.equals(Object) by natural keys
986. JPA caches.
987. Common project steps #1/3
988. Common project steps #2/3
989. Common project steps #3/3
990. Common technologies
991. UNIX grep sample
992. Similarities and differences
993. Database grep requirements
994. Connection profile handling
995. Search level specification
996. Property based searches
997. Source and target database
998. Copy process
999. Considerations
1000. Sample data creation
1001. Schema evolution
1002. Techniques
1003. Subscribe to lecture
1004. Versioned code and documentation content
1005. Online documentation samples
1006. Create and publish a Hetzner account
1007. Your cloud project
1008. Server creation prerequisite: A Firewall
1009. Your first server
1010. Server access by ssh
1011. No ssh password based login
1012. Server access by web gui
1013. Current server security flaws
1014. Safety considerations
1015. ssh-keygen for elliptic key creation
1016. An elliptic ssh public / private key pair
1017. Result of ssh-keygen execution (client side)
1018. Transfer public key from client to server
1019. Cleaning up!
1020. Tedious: Passphrase required for each remote login
1021. Solving the passphrase issue
1022. Behind the scenes: How does it work?
1023. Intermediate host hopping
1024. Intermediate host hopping fails
1025. Intermediate host hopping options
1026. Enable ssh agent forwarding
1027. Forwarding port 80 to 2000 at localhost
1028. Frequent use e.g. connecting to remote database server
1029. X11 browser application forwarding
1030. Network file copy using scp
1031. Network file copy using rsync and ssh.
1032. Shell / Bash
1033. Choosing a text editor
1034. Secure Shell
1035. Working with files
1036. Network
1037. Processes handling
1038. Suggested readings:
1039. .deb packages
1040. The dpkg command
1041. The apt command
1042. Rationale using PPA's
1043. What's it all about?
1044. Terraform resources
1045. Creating databases
1046. Creating cloud resources
1047. Your course documentation: Code structure
1048. The env.template file
1049. Getting started: The Hetzner API token
1050. Minimal Terraform configuration
1051. Terraform init
1052. Terraform plan
1053. Terraform apply
1054. A word on storing secrets
1055. Credentials by E-Mail
1056. Problems: 😟
1057. ssh access, firewall
1058. ssh access, public key
1059. Apply ssh key access
1060. Output data details #1/2
1061. Output data details #2/2
1062. Problem 2: VCS and visible secrets 😱
1063. Addressing secrets by variable
1064. Addressing secrets by file
1065. Addressing secrets by Bash .env file
1066. Managing Terraform states
1067. Introduction and reference
1068. In a nutshell
1069. Configuration options
1070. Bash DIY
1071. Terraform interface to Cloud Init
1072. Using template files
1073. cloud-init file validation
1074. Yaml syntax quirk 1: Missing indentation
1075. Yaml missing indentation resolution
1076. Yaml syntax quirk 2: Wrong indentation
1077. Cloud-init configuration file validation
1078. Watch out for your enemies!
1079. Problem: Duplicate known_hosts entry on re-creating server
1080. Solution: Generating known_hosts ...
1081. ... cloud-init config using yamlencode / JSON
1082. ... and ssh wrapper
1083. Failsafe console login
1084. Avoiding Yaml parsing issues
1085. Terraform module Documentation
1086. Example: Creating a JSON host meta data file
1087. Parent module / sub module layout
1088. Parent module implementation
1089. Sub module implementation
1090. Sub module, JSON template file Tpl/hostdata.json and result
1091. Parent module vs. sub module context
1092. A volume: The easy way
1093. Unix mount
1094. Volume details
1095. Providing a mount point's name
1096. De-coupling server and volume creation
1097. Loop documentation
1098. Using count
1099. Subdomain per group
1100. Key file location
1101. Querying DNS by zone transfer
1102. Creating an »A« record with TTL=10
1103. Modify by delete/create
1104. Mind record caching
1105. Bind server ns1.hdm-stuttgart.cloud
1106. DNS provider
1107. DNS provider configuration
1108. Defining an “A” record
1109. Understanding web certificates
1110. Certificate trust level
1111. Certificates by Terraform
1112. dns_challenge provider
1113. rfc2136 provider configuration
1114. Bind server log file
1115. Private subnet overview
1116. Terraform network and subnetwork creation
1117. Gateway: External and internal interface
1118. intern host
1119. Lack of internet access
1120. Possible solutions
1121. http proxy apt-cacher-ng
1122. Cloud-init problem
1123. Service ready query script
1124. Terraform “service ready” dependency hook
1125. Documentation links
1126. DNS query commands
1127. DNS forward lookup
1128. Display A-record result only
1129. Important record types
1130. Name Servers: Query type NS
1131. Recommended readings
1132. Openldap server documentation
1133. What is LDAP anyway?
1134. LDAP Server cli bind
1135. Document Information Tree (DIT)
1136. Relative and absolute DNs
1137. User example
1138. objectClass
1139. objectClass clarifications
1140. Augmenting inetOrgPerson by posixAccount
1141. Structural objectClass definitions
1142. Search scopes
1143. Predicate based queries
1144. LDAP bind types
1145. LDIF exchange format
1146. LDIF sample
1147. OpenLdap server architecture
1148. An example LDAP Tree
1149. External documentation
1150. URI to filesystem mapping
1151. Virtual hosting
1152. Implementing virtual hosting
1153. IP based virtual hosting
1154. IP based, pros / cons
1155. Name based virtual hosting
1156. Name based, pros / cons
1157. LDAP backed authentication
1158. PHP FPM server
1159. File services
1160. Customer demands
1161. Driving factors
1162. Selected cloud file services
1163. Selected self hosting products
1164. Nextcloud features
1165. Lightning integration
1166. Installation
1167. Docker hub
1168. Search images
1169. Pull image using CLI
1170. Pull Nextcloud image
1171. Nextcloud based on Alpine
1172. Inspect image
1173. Search an image's tags
1174. Nextcloud image by version
1175. List images by CLI
1176. Nextcloud latest image
1177. Duplicate Nextcloud images
1178. Maven ringing a bell?
1179. Un tag image by version
1180. Remove image by version
1181. Starting Nextcloud container
1182. List running containers
1183. Enter running container
1184. Remove container
1185. List volumes
1186. List orphaned volumes
1187. Remove volumes
1188. Technical features
1189. Documentation tool chain proposal

List of Tables

1. 4 Byte Two's complement representation of int values.
2. Exercises in 113105 Software development 1
3. Exercises in 113492 Technical Documentation
4. Exercises in 113473 Database and application development
5. Exercises in 113475 Software defined Infrastructure

List of Equations

1. Calculating binomials by cancelling common factors.
1. Power series definition of $f (x) = e^{x}$
2. Power series definition of $f (x) = \sin (x)$
3. Reordering of terms with respect to an implementation.

		Next
		Preface