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