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