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 Maven Intellij IDEA import and project upload.

Language Fundamentals

Integer, ASCII and Unicode
Variables
Literals
Arithmetic limitations
Conversions
Operators and expressions
Comments

The if conditional statement

The switch statement

while
do ... while
for

Logic related external exercises

Objects and Classes

Working with objects

Object methods

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

Static Members

A mathematical table.
Interest calculations
Lotteries revisited
The greatest common divisor and the common multiple
Project dependencies and Maven
Cancelling fractions
Building a library of mathematical functions.

Value types and reference types

Method calls, the details

Unit testing

Core Classes

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

java.util.Arrays helpers

Extending an array

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 (8.12.)

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

Recommended external exercises

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

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

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

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