Lecture notes

Martin Goik

Stuttgart Media University / MI

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

Table of Contents

Software development 1

Getting started

Lecture related resources

Using the exercises

Common software development related resources

Coached exercises

Using plain Java™

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

Using Maven and Intellij IDEA

Maven command line usage
Intellij IDEA on top of Maven

Examination hints.

Starting an exam
Implementing the project skeleton
Finish the exam

Language Fundamentals

Integer, ASCII and Unicode

Primitive types

Arithmetic limitations

Conversions

Operators and expressions

Arithmetic and logical operators
Assignment operators
Unary operators

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

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
Lotteries revisited
The greatest common divisor and the common multiple
Project dependencies and Maven
Building a library of mathematical functions.

Unit testing

Tests and implementation
Improving the algorithm
Helpful Junit methods
Technical details

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

Objects, equals() and hash-values
Reconsidering System.out.format().
Using class Math
String exercises
Analyzing file pathnames

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

Towns and country names

Creating an overview of grades

Examination hints

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

Working with git

Apache Maven

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

Past Software Development 1 examinations

SE1 Klausur Sommer 2018
SE1 Klausur Winter 2018
SD1 examination summer 2019
SD1 examination winter 2019

List of Exercises

Structured Data and Applications 1

Prerequisites

Lecture related resources

Postgresql database components
SQL client software

A relational recap exercise

Introduction to XML

The XML industry standard
Well formed XML documents

Beyond well- formedness

Structural descriptions for documents
Element definitions
Attribute definitions
XPath and node sets
Uniqueness Constraints
Referencing constraints
Best practices
Dealing with <memo> documents
Relating schema's and SQL - DDL
The airline example revisited
Relating schema's and Java™ class descriptions.
XML schema exercises

Language independence

New document

Simple DOM processing

Visualizing XML document elements
Reminder to functional programming elements in Java™.
Creating HTML output
Cleaning up HTML.

Using DOM with HTML/Javascript

DOM and XPath

DOM and XSL

Namespace / elements statistics

Accessing Relational Data

Persistence in Object Oriented languages

Introduction to JDBC™

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

Getting started with JPA

Notes on tooling

A round trip working with objects

Mapping OO domain model to database model
Inserting objects
Retrieving objects
Updating objects
Querydsl

Criteria queries

Enhancing the model

Persisting lecture instances

Exporting XML catalog data using JPA.

Prerequisites

Mongo Shell CRUD operations

Examination amending projects

Marking criteria / Hints
Exporting and importing relational data
Project Docbook CMS.
Project business cards

Using Vaadin

Configuring Maven.
Properties, editors and listeners
A first GUI sketch
Input validation and error handling
Decoupling GUI and database components
User initiated connect to database.
A user authentication “strategy”
Passwords and hash values
Gui authentication: The real McCoy
Architectural security considerations

The Extensible Stylesheet Language XSL

Required knowledge
A “Hello, world” XSL example
Example: memo recipients
Some important XSL elements
A complete HTML formatting example
Transforming arbitrary XML to XHTML

XML APIs, the Simple API for XML (SAX)

Recommended reading
The principle of a SAX application
First steps
Event- and error handler registration
SAX validation
Namespaces

online / print
Simple FO
Page layout
Header/footer
Important Objects
FO from XML
A catalog

Past SDA1 examinations

SDA1 examination summer 2019
SDA1 examination winter 2019

List of Exercises

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

Possible projects

Representing and editing BiBTeX data
Codingbat reloaded
XML based exercise compilations
Past projects

List of Exercises

Structured Data and Applications 2

ldap and JDBC

Getting started with LDAP

Setting up an Openldap server

Adding some sample data using Apache Directory Studio

LDIF export and import

Searching the DIT

UNIX to SQL to LDAP

Transactions in JDBC™

Account Transfer using pessimistic concurrency control
Account Transfer using optimistic concurrency control

Configuring a Maven based Eclipse Java™ project with Hibernate

Create a Maven based project in Eclipse
Adding a Mysql™ JDBC™ driver
Adding Hibernate dependencies
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

REST applications based on Java™-rs

List of Exercises

Software defined Infrastructure

UNIX / LINUX Basics

Prerequisites

Ubuntu / Debian Package management

Prerequisites

Getting started

Accessing your virtual machine
Global configurations

Preliminaries

Querying DNS data.
Installing Bind
Reverse lookups
Forwarders
Mail exchange record

Recommended Preparations

Browse an existing LDAP Server
Set up an OpenLdap server
Populating your DIT.
Testing a bind operation as non - admin user
Accessing LDAP data by a mail client
LDAP configuration
Filter based search
Extending an existing entry
LDAP based user login
Backup and recovery / restore
Replication
Accessing LDAP by a Java™ application.

Apache web server

Preliminaries

First Steps
Virtual hosts
SSL / TLS Support
LDAP authentication
Mysql™ database administration
Providing WEB based user management to your LDAP Server
Publish your documentation

Exercises

Network file systems served by Samba

Prerequisites
Samba server installation

Recommended Preparations

Install and send to local Users
Authentication Setup and Virtual Users
TLS
Spam and Virus defense

Introduction

Managing images
Running container
Volumes

The simple way: Using SQLite
The real McCoy: Using Mariadb

Functional checks
SNMP based checks
ssh based checks

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

List of Figures

1. How much time to invest?
2. Recommended reading resources I
3. Recommended reading resources II
4. Your biggest enemies
5. 4 most imperative study objectives
6. Online tutorials
7. Unix and the terminal
8. Online programming, automated feedback
9. Online programming I
10. Online programming II
11. Java Visualizer
12. Live lecture additions
13. Intellij IDEA IDE (See installation details)
14. Virtualbox / VMware player based virtualized Linux image
15. Virtualbox™ settings
16. Embedded exercises
17. Using the exercises
18. HdM mail server
19. Configure MI VPN client access
20. MI Cloud server
21. E-examination resources
22. MI File server
23. MI Git versioning server
24. Coached exercises
25. Bonus points
26. Seminar rules / bonus points
27. Edit - compile - execute
28. Editing Java™ files
29. Defining class HelloWorld
30. Compiling Java™ file
31. Command line Java™ file compilation
32. Java byte code file HelloWorld.class
33. Source code vs. bytecode
34. Executing byte code file HelloWorld.class
35. Shell byte code file HelloWorld.class execution
36. JDK™ installation options
37. Downloading IntelliJ idea
38. Idea »Ultimate« license types
39. HdM license server
40. Using Maven
41. Maven archetypes
42. Supplementary MI Maven archetypes
43. CLI archetype test
44. CLI archetype details
45. Generated project layout
46. Maven compile
47. Compilation file view
48. Execution
49. Maven package
50. Executing Java™ archive first-0.9.jar
51. Maven javadoc:javadoc
52. Maven clean
53. Intellij IDEA Maven support
54. Intellij IDEA Maven archetype catalog plugin
55. Intellij IDEA MI archetype repository configuration
56. New MI archetype project
57. Selecting an archetype
58. Providing project identifier
59. Your project's root
60. pom.xml content change policy
61. Intellij IDEA generating Javadoc™
62. Preparing an examination
63. Generating Javadoc™.
64. Programming hints
65. The implement - test - implement cycle
66. Finishing the exam
67. Manual calculation: Abacus
68. Mechanical calculation: Cash register
69. Electromechanical calculation: Zuse Z3
70. Vacuum Tube: Eniac
71. Transistor: Microprocessor ICs
72. Z80 8-bit data bus
73. Progress in hardware
74. Simple facts:
75. Unsigned 3 bit integer representation
76. Binary system addition
77. 3 bit two-complement representation
78. 3 bit two complement rationale: “Usual” addition
79. Signed 8 bit integer binary representation
80. 7-bit ASCII
81. 7-bit ASCII with even parity bit
82. Western European characters: ISO Latin 1 encoding
83. Unicode UTF-8 samples
84. Java types
85. Java primitive types, Part 1
86. Java primitive types, Part 2
87. Variables: Handles to memory
88. Variable declaration
89. Declare, assign and use
90. Combining declaration and initialization
91. Multiple variables of same type
92. Identifier in Java™:
93. Identifier name examples:
94. Java™ keywords.
95. Variable naming conventions
96. Constant variables
97. Case sensitivity
98. Define before use
99. Type safety
100. Compile time analysis
101. Forcing conversions
102. Watch out!
103. Casting long to int
104. Don't worry, be happy ...
105. ... and watch the outcome
106. From the report
107. Maximum and minimum values
108. Dynamic typing in PERL
109. Dynamic typing in PERL, part 2
110. Using final
111. Two categories of variables
112. Reference type examples
113. float and double
114. Four ways representing 35
115. Choose your output representation
116. Know your limits!
117. Literal examples
118. int literals
119. int literals explained
120. Java™ primitive literals
121. Java™ String and null literals
122. Just kidding ...
123. Strange things I
124. Strange things II
125. Arithmetic overflow pitfalls
126. Limited precision
127. Nearest float to 2.1
128. FloatConverter
129. Widening from byte literal to short
130. Narrowing from int literal to char variable
131. A widening «ladder»
132. A narrowing «ladder»
133. The binary plus operator
134. Binary operator output type
135. Detecting arithmetic overflow (Java 8+)
136. Dividing by zero
137. Generic binary operator
138. The modulus operator %
139. Binary operator type examples
140. No binary + operator yielding byte
141. int expression assignment
142. Constant expression assignment
143. The logical “and” operator &
144. The += operator
145. The &= operator
146. Assignment operators #1 / 2
147. Assignment operators #2 / 2
148. Increment operator ++
149. Prefix and postfix notation
150. Operator examples
151. Java™ comment flavors
152. Inline comments
153. Javadoc™ comments
154. Purposes of statements
155. Statements: General syntax
156. Statement examples: Declaring and assigning variables
157. Expression vs. statement
158. Multiple statements per line
159. Debugging multiple statements per line
160. Blocks
161. Conditional block execution
162. if syntax
163. if ... else
164. if ... else syntax
165. Best practices comparing for equality
166. Single statement branches
167. Aside: Corporate network security
168. Online banking
169. DNS Spoofing
170. Turn DNS name into IP address
171. SSL Certificate error
172. The Apple “goto fail” SSL bug
173. Static code analysis
174. Nested if ... else
175. Enhanced readability: if ... else if ... else
176. if ... else if ... else syntax
177. User input recipe
178. Using a Scanner class collecting user input.
179. Converting numbers to day's names
180. Numbers to day's names: The hard way
181. Better: Using switch
182. switch Syntax
183. Switching on strings
184. Why loops?
185. Arbitrary number of repetitions
186. A while loop
187. Combining increment and termination condition
188. while syntax
189. Empty while body
190. A do ... while loop
191. do ... while syntax
192. Frequent usage of while
193. Replacing while by for
194. for syntax
195. for variable scope
196. for variable scope equivalence
197. for vs. while relationship
198. Nested loops
199. Better readability: Use row and column in favour of i and j
200. Calculating values
201. Response to coding errors
202. Unit test concept
203. alarmClock(...) with errors
204. Testing alarmClock(...)
205. Testing alarmClock(...) details
206. Instances of a Class
207. General class structure
208. What's a class anyway?
209. Rectangle objects
210. A class describing rectangles
211. Rectangle class and instances
212. Generated diagrams
213. The new operator: Creating rectangle instances
214. Syntax creating instances
215. Assigning attribute values to class instances
216. Instance memory representation
217. References and null
218. Checking for object presence
219. Why packages ?
220. Rules and conventions
221. Fully qualified class name vs. import
222. Don't be too lazy!
223. Special: Classes in package java.lang
224. Class, package and file system
225. Source hierarchy view
226. Object methods
227. Scaling a rectangle
228. Scaling method implementation
229. Scaling method signature
230. Using the scale(...) method
231. Method definition syntax
232. A rectangle's perimeter
233. getPerimeter() method implementation
234. Using Rectangle.getPerimeter()
235. Access control: Overall objectives
236. Example: Implementing time and date
237. Access violation
238. Access rules
239. “Tips on Choosing an Access Level”
240. Direct access vs. setter method
241. Why adding setter methods?
242. Implementation by minutes only
243. Defining type signatures
244. Type signature examples
245. Defining method signatures
246. Method signature examples
247. Method overloading: Same name, different signature
248. Overloading, alternate names
249. No such concept in C
250. What about return type?
251. Method signatures rationale
252. Method signatures rationale
253. Example: System.out.print(...)
254. Creating and initializing rectangles
255. Defining a constructor
256. Constructor syntax
257. Constructors
258. Multiple overloaded constructors
259. Constructor calls within constructor
260. Instances by overloaded constructors
261. No constructor vs. default constructor
262. Non - default constructor, but no default constructor
263. Employee example package hierarchy
264. Circle and variable scopes
265. Documenting classes and methods
266. Generated Javadoc
267. Refactoring «r» ⇒ «radius»
268. Scope assignment problem
269. this overriding method scope
270. Club membership objectives
271. Implementing club members.
272. Showing membership info.
273. Implementing membership numbers.
274. Showing membership numbers.
275. Member creation steps
276. Accessing the club's overall member count?
277. Accessing the club's member count
278. Do we really require an instance?
279. static: Favour class method over instance method
280. Syntax accessing class members
281. static / non-static wrap up
282. Finally understanding System.out.print(ln)
283. Newton's letter to Robert Hooke
284. Project «lottery» depending on «helper»
285. Providing project «helper»
286. Install project «Helper»
287. helper-0.9.jar archive content
288. Consuming project «Lottery»
289. External libraries view
290. Using Helper.factorial(...) computing $(\begin{matrix} n \\ k \end{matrix}) = \frac{n!}{k! (n - k)!}$
291. Maven artifact dependency.
292. Maven repositories
293. Pascal's triangle representing binomial coefficients.
294. An implementation sketch for the exponential
295. Comparing exponential and approximation
296. Comparing sin(x) and its approximation.
297. Recommended reading
298. Test categories
299. Example: Computing prime numbers
300. Unit test principle
301. Test driven development
302. Steps in Unit Testing
303. Step 1 + 2: Specify method, write skeleton
304. Execution yet being flawed
305. Sample test data
306. Step 3: Junit based specification test
307. Junit skeleton test result (Maven CLI)
308. Junit skeleton test result (IDE)
309. Step 3: Providing more prime tests
310. Step 3: Prime mass testing
311. Step 4: Implement skeleton
312. Step 5: Testing our first implementation
313. Implementation observation
314. Changing the implementation
315. Regression test
316. Systematic error debugging
317. Error correction in detail
318. Available comparison methods
319. Caution comparing float / double !!
320. Weird arithmetics?
321. Limited representation precision
322. Solving the issue
323. The @Test annotation
324. The Assert class
325. Importing dependencies
326. Dependency archive content
327. Value vs. reference type variables
328. Different behaviour!
329. Value variable Details
330. Reference variable Details
331. Only «call-by-value» in Java™
332. «call-by-value» details
333. «call-by-reference» for objects?
334. «call-by-reference» details
335. No «call-by-reference» in Java™!
336. No «call-by-reference» details
337. C++ offers «call-by-reference» by virtue of “&”
338. C++ «call-by-reference» details
339. Method calling
340. Three variable scopes
341. Scope lifetimes
342. Two runtime memory categories
343. Stack: Four operations
344. Example: Storing integer values
345. Method calling
346. Call stack trace
347. IDE debugger
348. Motivation
349. Weekly offered lectures
350. Weekly offered lectures by simple numbers
351. Weekdays int representation
352. Weekly offered lectures using constants
353. Converting index values to day names
354. Providing lecture info
355. Sample lectures
356. Bogus index value
357. Pitfall: Method argument order mismatch
358. Enumeration by class instances
359. Class instance per enumeration value
360. switch no longer works
361. Re-writing getPrice()
362. Compile time argument mismatch error
363. Pitfall: Creating an undesired instance
364. Define a private Day constructor
365. Preventing undesired Day instance creation
366. Adding a day name attribute
367. enum Day replacing public class Day
368. switch statements working again
369. enum constructor being implicitly private
370. From https://www.urbandictionary.com
371. Useful links
372. Initialize git project
373. Configure author related data.
374. Adding resources to project index and staging area
375. Committing change set
376. Project versioning status
377. Adding a comment
378. git diff tracing changes
379. Reverting individual file.
380. Compiling, Math.class and Print.class.
381. Math.class, Print.class and versioning.
382. Show project's log
383. Switch to an older revision ...
384. ... and forth to current master's HEAD
385. Centralized remote repository
386. Step 1: Create remote repository
387. Step 2: Retrieve remote repository address
388. Step 2: Connect to remote repository
389. Step 3: Push local to remote
390. Step 3: Pull remote to local
391. Alternative: Create remote, then clone
392. Conflicting changes
393. Commit schedule
394. User B: git push fails
395. User B: git pull fails as well
396. Merge conflict details
397. Struggling for resolution
398. Merging Print.java manually
399. Commit and push merge
400. Superclass Object
401. String literals
402. OpenJDK String implementation
403. String copy constructor
404. Copy constructor and heap
405. Operator == and equals()
406. Remarks == vs. equals()
407. Hashing principle
408. Quickly identify by “simple” value
409. Hashing in Java and equals()
410. Rectangle equals(...) and hashCode()
411. Rectangle hash values
412. Better hashCode() method
413. Motivating Arrays
414. Per member repeating tasks
415. Example: int array of primes
416. Loop prime values
417. Mind the limit!
418. Safer: Using length
419. Even better: “for-each” style loop
420. Mind the limit, part two
421. One step initialization
422. Array
423. Two syntax variants
424. Array instances are special!
425. Array creation details
426. Array parameter passing
427. Parameter passing details
428. Value and reference types
429. Arrays.toString(...) and Arrays.sort(...)
430. Arrays.binarySearch(...)
431. Arrays.fill(...)
432. Arrays.copyOfRange(...)
433. Arrays.equals(...)
434. Lack of extendability
435. Extending an array
436. Extension result
437. Using Arrays.copyOf()
438. public static void main(String[] args)
439. Intellij IDEA run configuration
440. Intellij IDEA run configuration
441. Creating executable jar
442. Two-dimensional arrays
443. Behind the scenes
444. Memory allocation
445. Static array initialization
446. Static array initialization, variable lengths
447. Two Tic-tac-toe players fighting each other.
448. Two Tic-tac-toe players fighting each other.
449. Guess who's inheriting the money
450. Biology and inheritance
451. Duplicate code
452. Idea: Centralize common code
453. Common and specific properties
454. Basic shape inheritance
455. Inheritance
456. Implementing Shape hierarchy
457. Creating instances
458. Shape constructor
459. Creating Rectangle instances
460. Rectangle constructor
461. Shape.equals()
462. Rectangle.equals()
463. Shape log info
464. Overwriting toString()
465. Shape extending Object
466. Logging Rectangle instances
467. Override toString() again.
468. Rectangle extending Shape
469. Implementing Circle.toString()
470. Shape and toString()
471. Moving Shape instances
472. Implementing Shape movements
473. Fools are everywhere!
474. Solution: final prevents overriding
475. Calculating a shape's area
476. Desired: Polymorphic getArea() call
477. Problems:
478. abstract method getArea()
479. abstract method getArea()
480. What's a “shape” anyway?
481. No instances of abstract classes.
482. Mandatory getArea() implementation.
483. Facts about abstract fields, methods and classes.
484. Moving shapes
485. protected access
486. final classes
487. final classes rationale
488. “Defeating” polymorphism
489. Defining equals(...): Expectations
490. Defining equals(...) of Shape instances
491. Comparing center coordinates
492. Implementing Rectangle.equals()
493. Implementing Circle.equals()
494. Testing equality of Shape objects
495. Overriding Object.toString()
496. @Override: Easy compile time error detection
497. Compile- and runtime errors
498. NullPointerException (NPE for short)
499. NullPointerException is a class
500. Throwing an exception
501. Catching an exception by try {...} catch {...}
502. try {...} catch {...} syntax
503. Checked and unchecked exceptions
504. Checked and unchecked exceptions
505. Expected exceptions in Junit
506. Just finally, no catch
507. try-with-resources (Java™ 7)
508. Method printStackTrace()
509. Ascending inheritance ordering
510. Descending inheritance ordering
511. Implementing convert
512. Problem: “Silent” errors
513. Step 1: Find exception base class
514. Step 2: Derive CardinalException
515. Step 3: Throwing CardinalException
516. Step 4: Unit test throwing CardinalException
517. Stack of integer values
518. Java™ collection features
519. Behind the scenes
520. Boxing and unboxing
521. Boxing syntax comparison
522. Parsing Integer user input
523. Parsing binary representation
524. Standard parse methods
525. Excerpt from java.util.Locale
526. Locale properties
527. Get a NumberFormat instance
528. Create a custom formatter
529. Polymorphic number parsing
530. Limited float precision
531. Limited double precision
532. Using BigDecimal
533. BigDecimal features
534. Using static double random()
535. Seeding a pseudo random generator
536. Interface examples
537. Observations
538. Writing strings to file
539. Using Text2File
540. Possible Text2File errors:
541. Employ “try-with-resources”
542. interface syntax
543. The AutoCloseable promise
544. abstract class replacement
545. interface vs. abstract class
546. interface MyAutoCloseable
547. Extending MyAutoCloseable to flush
548. Using MyFlushable
549. Inheritance hierarchy
550. Upcoming topics
551. Interfaces implemented by class String
552. The Comparable interface
553. class String and Comparable
554. Comparison examples
555. Ascending and descending names
556. API requirements
557. Sorting strings alphabetically
558. Situation dependent sorting criteria
559. Implementing flexible sorting
560. Comparator in action
561. Case insensitive sort
562. Sort descending by lambda expression
563. What's the use of hashing anyway?
564. Account hierarchy
565. Students and lecturers
566. An array of strings
567. An associative array describing month lengths
568. Grouping towns by country names
569. Personal examination cheat sheets
570. Unit tests in examinations
571. Example interface definition
572. Corresponding test
573. Unit tests strategy in examinations
574. Collaborative efforts
575. Project rules
576. Internal code documentation
577. Internal code documentation hints
578. Javadoc™ mismatches
579. (Automated) tests
580. Deployment and execution
581. Marking criteria
582. Sample forecast session
583. Sample forecast invocation
584. Underlying data provider
585. cities.list.json.gz providing cities
586. ma/Copy URL result to file
587. Parse city data
588. Parse weather data
589. Requirements
590. Logging
591. Minimalist token scanner
592. Scanner output -1.34 0.34 + sqrt
593. Adding error detection
594. Error message
595. Running the currency converter terminal application.
596. Steps creating a new project
597. Creating a project at MI gitlab
598. Cloning a git project
599. Enter project folder, add Readme.md
600. Committing change set
601. Push to upstream repository
602. Inserting a Maven project
603. git status 1
604. Adding Maven files to repository
605. git status 2
606. Commit Maven project files
607. git status 3
608. Push to upstream again
609. Reverting changes
610. Pull changes from upstream
611. Maven: Recommended reading
612. What is Maven anyway?
613. Maven: Facts and benefits
614. Convention Over Configuration
615. Maven project layout
616. The project object model file
617. pom.xml characteristics
618. pom.xml vs. Makefile
619. «Hello, world» pom.xml
620. Executing «compile» phase
621. Examining the Java™ version culprit
622. Resolving encoding / Java™ version issues
623. POM inheritance
624. The Super POM
625. pom-4.0.0.xml content
626. Favour https in ~/.m2/settings.xml
627. Resolving to effective pom.xml
628. Plugin architecture
629. Sample plugins
630. Example: The maven-javadoc-plugin
631. Adding test capabilities
632. Dependency listing
633. Absence of hamcrest in pom.xml
634. ~/.m2/repository/junit/junit/4.12/junit-4.12.pom
635. Transitive dependencies
636. Oblivious to test implementation: TestNG
637. Phases
638. Maven lifecyles and phases
639. hooking into phase
640. Personal examination cheat sheets
641. Live lecture additions
642. List of exercises
643. Virtualized Linux images
644. Oxygenxml
645. Examples and exercises source code
646. Tooling options
647. Installing Postgresql™
648. Configure Postgresql™
649. Installing Postgresql™ JDBC driver using the aptitude.
650. Installing Postgresql™ driver using Maven.
651. Intellij IDEA Postgresql™ driver configuration
652. Recommended reading
653. What is XML?
654. Application domains
655. Benefits
656. Relevance (2018/02)
657. JSON catches up!
658. Rendering (X)HTML markup
659. HTML tree structure
660. MathML formula
661. MathML tree graph representation
662. HTML / MathML document similarities
663. XML files: Representing data
664. Representing CAD data
665. XML basic structure
666. Minimal XML document
667. Empty tags
668. Representing messages.
669. Just plain XML?
670. MI department CLI parser
671. Non-wellformed, missing </from>
672. Improperly nested elements
673. Improperly nested elements: Result
674. Proper nesting of XML elements
675. Improperly nested elements
676. “date” and “priority” attributes.
677. Unique attribute names
678. Quotes required
679. Important well-formedness constraints
680. XML markup collision I
681. XML markup collision II
682. XML standard replacement entities
683. Using CDATA sections
684. Using replacement entities
685. Processing instruction (PI)
686. Recommended reading
687. XML and application code
688. HTML validity
689. Well-formed and valid
690. XML grammar examples
691. An address book
692. A <contact> record
693. <contact> business rules:
694. EBNF grammar representation
695. organizer.xsd schema
696. Linking instance to schema
697. Centralized schema definition
698. Validating a contact
699. Uups, we fail!
700. Schema observations
701. Well-formed and valid documents
702. Terminology
703. V02: Define <email> as optional
704. V03: Multiple contacts
705. Choose <contact> as root
706. Graphical schema representation
707. Adding <birthDate>
708. Supply a <birthDate> type
709. <birthDate> element or attribute?
710. Using a birthDate attribute
711. Absent birthDate attribute
712. XSD attributes revisited
713. Consider <email>
714. User defined email type
715. Using new email type
716. Strange: The Ur type
717. Adding missing data types
718. Nested elements now becoming invalid
719. Introducing categories
720. Category type violation
721. Ooops: Text content and attributes
722. SQL query result
723. Predicate based queries acting on XML documents
724. Comparing SQL and XPath
725. Similarities and differences
726. Simple XPath queries
727. Relative file system search using find
728. find starting from absolute path
729. XPath and context nodes
730. Union
731. Union / descent
732. Recursive search for element name
733. Recursive + index search
734. Surprise!
735. Axes / siblings
736. Following sibling
737. Disjoint XPath axis definitions.
738. Element restricted following sibling
739. Elements containing non-whitespace text
740. Elements containing text containing 'house'
741. Elements containing text of minimal length
742. Searching for attribute presence
743. Searching for attribute value
744. Boolean «or»
745. Introducing nicknames
746. Nickname semantics
747. <xs:unique>
748. Introducing id values
749. id semantics
750. <xs:key> vs. <xs:unique>
751. Enhancing error message understanding
752. Referencing contacts
753. Violating referential integrity
754. Enforcing referential integrity
755. Participant reference duplicates
756. Solution:Additional key constraint
757. Participant reference duplicates
758. Nested vs. reference
759. Common pitfalls
760. Get types fixed!
761. Get type references right!
762. References: Mind your types!
763. <memo> exercise series
764. Invoice integrity constraints
765. Relational implementation
766. XML schema's and Java™ class declarations.
767. A first schema version for book documents
768. Version 2 of book.xsd
769. Required knowledge
770. Important XML Java™ APIs
771. SAX: XML to events
772. SAX architecture
773. DOM assembly
774. SAX deficiencies
775. DOM: Language independence
776. DOM: Vendor independence
777. DOM Node CORBA 2.2 IDL
778. Defining a language binding
779. org.w3c.dom.Node Java™ binding.
780. A context node's children
781. org.w3c.dom.Node subtypes
782. DOM Java™ binding inheritance interface hierarchy
783. DOM modules.
784. Jdom vs. DOM: Advantages
785. Jdom vs. DOM: Disadvantages
786. Prerequisite: pom.xml configuration
787. Roadmap: Exporting data as XML
788. XML document creation from scratch.
789. XML catalog sample data
790. SAX error handler, see Figure 772, “SAX architecture ”
791. Accessing an XML Tree purely by DOM methods.
792. Driver class execution entry point
793. Project sample code for import
794. DOM and Javascript
795. DOM Javascript example
796. DOM Javascript demo
797. Why using XPath ?
798. XPath and Jdom
799. XPath on top of Jdom
800. HTML containing <img> tags.
801. Objective: Find contained images
802. XSL script extracting images.
803. Setting up the parser
804. Search using XPath //img
805. Search and namespace
806. Searching for images
807. Parameterized search expressions
808. A simplified XML product catalog
809. A XSL style sheet for catalog transformation to HTML.
810. Transforming an XML document instance to HTML by a XSL style sheet.
811. A driver class for the xml2xml transformer.
812. Prerequisite knowledge
813. Persistence [Bauer2015]
814. Java™ transient instances
815. RDBMS persistent records
816. Persisting transient User instances
817. Observations
818. Networking between clients and database server
819. JDBC™ features
820. JDBC™ in a three-tier application
821. JDBC™ connecting application server and database.
822. JDBC™ connection parameter
823. Components of a JDBC™ URL
824. IETF Uniform Resource Identifier
825. URL examples
826. Sub protocol examples
827. No standard port assignments ...
828. ... but Postgresql made it into Linux
829. JDBC™ architecture
830. DriverManager: Bootstrapping connections
831. Example: Mysql connection implementation
832. Driver libraries
833. Driver libraries, Maven
834. Driver unavailable
835. Connection interface
836. Statement interface
837. JDBC™ instances and relationships.
838. Important Connection methods
839. Important Statement methods
840. JDBC™ and threading.
841. JDBC™ connection pooling
842. pom.xml driver runtime scope
843. Person table
844. Objective: insert person record
845. JDBC™ backed data insert
846. Result
847. Two JDBC™ configurations
848. Figure 845, “JDBC™ backed data insert ” deficiencies
849. Why properties?
850. message.properties string externalization
851. Properties code sketch
852. Intellij IDEA settings, preconditions
853. Database related unit test phases
854. Implementing unit tests
855. Spring is your friend
856. Project layout
857. Closing connections
858. Employ AutoCloseable
859. Sniffing a JDBC™ connection by an intruder.
860. Setting up Wireshark
861. Capturing results
862. Mysql™ security
863. Mysql™ security
864. Assembling SQL
865. SQL injection principle
866. Preventing traffic tickets
867. Trouble at school
868. SQL injection impact
869. SQL injection relevance, [Clarke2009]
870. Lessons learned?
871. Validating user input prior to dynamically composing SQL statements.
872. Error message being presented to the user.
873. SQL statements in Java™ applications get parsed at the database server
874. Two questions
875. Addressing performance
876. Addressing performance mitigation
877. Addressing security
878. Solution: Use java.sql.PreparedStatement
879. PreparedStatement principle.
880. Three phases using parameterized queries
881. PreparedStatement example
882. Injection attempt example
883. No dynamic table support
884. JDBC™ read and write
885. Server / client object's life cycle
886. JDBC™ record container
887. Reading data from a database server.
888. Names and birth dates of friends
889. Accessing friend's database records
890. Important ResultSet states
891. JDBC™ to Java™ type conversions
892. Java™ to JDBC™ type conversions
893. Fixed type accessors
894. Polymorphic accessors
895. Access by column name
896. Access by column index
897. Problem: null value ambiguity
898. Resolving null value ambiguity
899. Users and groups
900. Isolation level
901. JDBC™ Isolation level
902. Setting the isolation level
903. Why using JPA ?
904. What about “impedance”?
905. OR impedance mismatch
906. JPA 2.0
907. JPA 2.1
908. JPA 2.2
909. JPA overview
910. JPA components
911. Maven pom.xml
912. Right click «Add Framework Support»
913. Enable Hibernate support
914. «File» --> «Project Structure»
915. Criteria / Querydsl annotation processing
916. Class StudyCourse
917. Transient instance
918. Persistence: Business rules
919. StudyCourse entity definition
920. persistence.xml configuration
921. CreateStudyCourse using a transaction
922. Database state
923. ReadStudyCourseById retrieval by primary key
924. Retrieving all instances
925. Type conversion problems
926. Reading shortName values
927. Adding a setter
928. Update language
929. Populating the database
930. JPQL: Domain model and database
931. JPA query alternatives
932. JPQL
933. JPQL parameter
934. JPQL record retrieval
935. Criteria entity metamodel
936. Criteria query
937. No injection susceptibility
938. Querydsl entity metamodel
939. From “Querying JPA”
940. Querydsl query
941. No injection susceptibility
942. Business and surrogate keys
943. Database generation strategies
944. INSERT omitting id
945. Generated surrogate id
946. StudyCourse creation
947. Entity Student
948. Database schema
949. Providing enrollment
950. CreateUniversity
951. Editing a Docbok 5 document using the XMLMind editor.
952. A simple GUI to insert data into a database server.
953. PersistenceHandler state transitions.
954. A GUI frontend for adding personal data to a server.
955. Login credentials for database connection
956. Intended usage behaviour for insertion of data records.
957. XSL target formats
958. Motivating XSL
959. A memo document instance with an internal reference.
960. Extracting the sender's name
961. Execution and Result
962. XSL processor transforming XML using a stylesheet
963. Transformation syntax details
964. List of recipient nodes iteration.
965. Selecting node sets from memo document instances
966. XPath content/para starting from context node <memo>.
967. Exporting SQL statements.
968. A graphical representation of our <catalog>.
969. A memo with 9 recipients
970. A <book> document with two chapters
971. Visualizing arbitrary XML input data.
972. Generating HTML from a XML document and an RDBMS.
973. A XML based catalog.
974. A Relation containing price information.
975. HTML generated output.
976. Parsing a XML document creates a corresponding sequence of events.
977. SAX Principle
978. Counting XML elements.
979. A non well formed document.
980. An invalid XML document.
981. A sample catalog containing products and corresponding descriptions.
982. The most simple FO document
983. Regions being defined in a page.
984. A complete FO parameterizing of a physical page and the fo:region-body.
985. Parameterizing page- and region view port. All length dimensions are in mm.
986. Parameterizing header and footer.
987. A fo:block with a fo:inline descendant.
988. An itemized list and result.
989. Two simulated entries in a table of contents.
990. Four entries separated by equal amounts of dotted space.
991. A horizontal line separator between header and body of a page.
992. Roman style page numbers.
993. A dictionary with running page headers.
994. Two blocks mutual page referencing each other.
995. Two blocks with mutual page- and hypertext references.
996. Different target formats from common source.
997. Generating a sender's surname for printing.
998. A memo document instance.
999. Why XML based publishing?
1000. XML features
1001. Editors, compositors, designers ...
1002. Promises in publishing
1003. Publishing reality
1004. Single source publishing
1005. Separating Structure, content and format
1006. Separating concerns
1007. Content
1008. Hierarchical structure
1009. Hierarchical structure, XML source
1010. Presentation
1011. Example 1: HTML 5, pure structure
1012. Example 2: TeX / LaTeX
1013. Separating structure and presentation(s)
1014. Sample technical document
1015. Observations
1016. Pros and cons of TeX / LaTeX
1017. Tools of the trade
1018. Inline formatting
1019. Paragraphs
1020. Lists
1021. Tables
1022. Images
1023. Mathematical formulas
1024. Cross references
1025. Document sectioning
1026. Modular document components
1027. What is Docbook?
1028. Authoring and publishing
1029. Document representation
1030. Software centric schema
1031. Document targets
1032. Docbook components
1033. Target format overview
1034. Tooling / Software
1035. Different schema languages
1036. Plain HTML
1037. Web help
1038. Eclipse help
1039. Printed output
1040. Paragraph
1041. Itemized list
1042. Ordered list
1043. Glossary list
1044. Nested lists
1045. Reference
1046. A table
1047. A MathML equation
1048. A TeX equation
1049. Reference
1050. Figure
1051. Image map + calloutlist
1052. Video
1053. A warning
1054. Reference
1055. Recursive sections
1056. Non-recursive sections
1057. Two different link flavours
1058. Choosing a top level element
1059. Allowed 5.1 top level elements
1060. Schematron on top of RelaxNG
1061. Example: xml:id and permalink
1062. Using Display #Anchors
1063. Considerations author based permalink
1064. Schematron permalink rule
1065. HTML customization overview
1066. Target specific configuration
1067. Link stability
1068. use.id.as.filename = 1
1069. Parameter: use.id.as.filename
1070. Customization parameter ulink.target
1071. callout.unicode / callout.graphics
1072. Links
1073. Hooking into XSL
1074. Categories
1075. Example: videos
1076. Links
1077. Customize by CSS
1078. Example CSS modifications
1079. Styling the editor
1080. Motivating modular documents
1081. Monolithic document problems
1082. Document decomposition
1083. A monolithic document
1084. Decomposing documents
1085. XML grammar defining languages
1086. Address list schema
1087. Format conversion problem
1088. XSL template rules
1089. Example: Formatting <title> elements
1090. Basic FO introduction
1091. XMLMind Editor
1092. Oxygenxml Author
1093. Vendor links
1094. Inverse editing
1095. Document representation
1096. Components
1097. BibTeX
1098. Makeindex example
1099. Makeindex work flow
1100. Extension example: MusiXTeX
1101. Flavours
1102. Components
1103. Editors
1104. Example BiBTeX data
1105. BiBTeX: Tasks
1106. Codingbat: Desired features
1107. Desired features
1108. Two departments billing and research populated with sample user entries
1109. Optimistic concurrency control
1110. Failure with optimistic transactions
1111. Reasons for using Maven
1112. Transitive dependencies
1113. A basic persistence.xml JPA configuration file.
1114. JPA persistence provider
1115. Mapping hibintro.v1.model.User instances to a database.
1116. A basic User class.
1117. Mapping properties to attributes.
1118. Annotating integrity constraints
1119. Database schema mapping instances of hibintro.v1.model.User.
1120. Loading a single object by a primary key value.
1121. Retrieving hibintro.v1.model.User instances by HQL.
1122. Business rules for projects
1123. Persistence related object states
1124. Introducing inheritance mapping
1125. Modelling payment.
1126. A single relation mapping.
1127. Mapping the inheritance hierarchy.
1128. Inserting payment information
1129. Figure subclasses
1130. Joined subclass mapping.
1131. Implementing Object.equals(Object) by natural keys
1132. JPA caches.
1133. Basics on Jax-RS
1134. Shell / Bash
1135. Secure Shell
1136. Working with files
1137. Gathering network related information
1138. Handle processes
1139. vim text editor introduction
1140. Creating a ssh public/private key pair
1141. Configuration file permissions on windows network file systems
1142. Resulting permissions and configuration test
1143. Suggested readings:
1144. .deb packages
1145. The dpkg command
1146. The apt command
1147. Rationale using PPA's
1148. Result of ssh-keygen execution
1149. Extended ACLs, ways too open
1150. Revoking permissions using setfacl
1151. Corrected permissions
1152. Logging in
1153. Documentation links
1154. DNS query commands
1155. DNS forward lookup
1156. Display A-record result only
1157. Important record types
1158. Name Servers: Query type NS
1159. Recommended readings
1160. Openldap server documentation
1161. What is LDAP anyway?
1162. Document Information Tree (DIT)
1163. Relative and absolute DNs
1164. User example
1165. objectClass
1166. objectClass clarifications
1167. Augmenting inetOrgPerson by posixAccount
1168. Structural objectClass definitions
1169. Filtering scopes
1170. Predicate based queries
1171. LDAP bind types
1172. LDIF exchange format
1173. LDIF sample
1174. An example LDAP Tree
1175. File services
1176. Customer demands
1177. Driving factors
1178. Selected cloud file services
1179. Selected self hosting products
1180. Nextcloud features
1181. Lightning integration
1182. Installation
1183. Docker hub
1184. Search images
1185. Pull image using CLI
1186. Pull Nextcloud image
1187. Nextcloud based on Alpine
1188. Inspect image
1189. Search an image's tags
1190. Nextcloud image by version
1191. List images by CLI
1192. Nextcloud latest image
1193. Duplicate Nextcloud images
1194. Maven ringing a bell?
1195. Un tag image by version
1196. Remove image by version
1197. Starting Nextcloud container
1198. List running containers
1199. Enter running container
1200. Remove container
1201. List volumes
1202. List orphaned volumes
1203. Remove volumes

List of Tables

1. 4 Byte Two's complement representation of int values.
2. Exercises in Software development 1
3. The Person table
4. Mapping elements from book.xsd to Xhtml
5. Exercises in Structured Data and Applications 1
6. Exercises in Technical Documentation
7. Exercises in Structured Data and Applications 2
8. 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.
4. Power series definition of $\cos (x)$

		Next
		Preface