Lecture notes

Martin Goik

Stuttgart Media University / MI

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