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

while
do ... while
for

Logic related external exercises

Using automated tests.

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

Method calls, the details

Enumerations (enum)

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

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

Core Classes

Using class Math
String exercises
Analyzing file pathnames

Varargs method parameter

Reconsidering System.out.format().

java.util.Arrays helpers

Extending arrays

Storing integer values

Understanding static int main(String[] args)

Multi-dimensional arrays

Tic-tac-toe

Tic-tac-toe using a two-dimensional array
Changing the game's internal representation
Tic-tac-toe, Computer vs. human

Providing statistical data

Prime numbers revisited

A simple algorithm
Improving performance

The median of a given sample.

Plotting functions

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

SD1 examination summer 2025
SD1 examination winter 2024
SD1 examination summer 2024
SD1 examination winter 2023
SD1 examination summer 2023
Sd1 examination winter 2022
SD1 examination winter 2021
SD1 examination summer 2021
SD1 examination winter 2020/1
SD1 examination winter 2020/2
SD1 examination summer 2020
SD1 examination winter 2019
SD1 examination summer 2019
SE1 Klausur Winter 2018
SE1 Klausur Sommer 2018
SE1 Klausur Winter 2017
SD1 Klausur 2017
SE1 Exam winter 2015
SE1 Klausur Sommer 2015
SE1 Klausur Winter 2014

Past Software Development 1 exam preparing tests

Test 01
Test 02
Test 03
Test 04
Test 05

Working with git

Apache Maven

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

List of 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 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
Database schema evolution tool

List of Exercises

113475 Software defined Infrastructure

Manual server management

Documentation guidelines

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
Terraform states
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 Exercises

Common topics

Project documentation

Bibliographic links

List of Figures

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