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

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 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

Mysql 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

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. Rectangle equals(...) and hashCode()
338. Rectangle hash values
339. Rectangle equals(...) and hashCode()
340. Contractequals(...) and hashCode()
341. Motivating Arrays
342. Per member repeating tasks
343. Example: int array of primes
344. Loop prime values
345. Mind the limit!
346. Safer: Using length
347. Even better: “for-each” style loop
348. Mind the limit, part two
349. One step initialization
350. Array
351. Two syntax variants
352. Array instances are special!
353. Array creation details
354. Array parameter passing
355. Parameter passing details
356. Value and reference types
357. Arrays.toString(...) and Arrays.sort(...)
358. Arrays.binarySearch(...)
359. Arrays.fill(...)
360. Arrays.copyOfRange(...)
361. Arrays.equals(...)
362. Lack of extendability
363. Extending an array
364. Extension result
365. Using Arrays.copyOf()
366. public static void main(String[] args)
367. Intellij IDEA run configuration
368. Intellij IDEA run configuration
369. Creating executable jar
370. Multidimensional arrays
371. Behind the scenes
372. Memory allocation
373. Two Tic-tac-toe players fighting each other.
374. Two Tic-tac-toe players fighting each other.
375. Guess who's inheriting the money
376. Biology and inheritance
377. Duplicate code
378. Idea: Centralize common code
379. Common and specific properties
380. Basic shape inheritance
381. Inheritance
382. Implementing Shape hierarchy
383. Creating instances
384. Shape constructor
385. Shape log info
386. Overwriting toString()
387. Shape extending Object
388. Creating Rectangle instances
389. Rectangle constructor
390. Logging Rectangle instances
391. Override toString() again.
392. Rectangle extending Shape´
393. Implementing Circle.toString()
394. Shape and toString()
395. Moving Shape instances
396. Implementing Shape movements
397. Fools are everywhere!
398. Solution: final prevents overriding
399. Calculating a shape's area
400. Desired: Polymorphic getArea() call
401. Problems:
402. abstract method getArea()
403. abstract method getArea()
404. What's a “shape” anyway?
405. No instances of abstract classes.
406. Mandatory getArea() implementation.
407. Facts about abstract fields, methods and classes.
408. Moving shapes
409. protected access
410. final classes
411. final classes, rationale
412. “Defeating” polymorphism
413. Defining equals(...): Expectations
414. Defining equals(...) of Shape instances
415. Comparing center coordinates
416. Implementing Rectangle.equals()
417. Implementing Circle.equals()
418. Testing equality of Shape objects
419. Overriding Object.toString()
420. Failure: Not overriding Object.toString()
421. Compile- and runtime errors
422. NullPointerException (NPE for short)
423. NullPointerException is a class
424. Throwing an exception
425. Catching an exception by try {...} catch {...}
426. try {...} catch {...} syntax
427. Checked and unchecked exceptions
428. Checked and unchecked exceptions
429. Expected exceptions in Junit
430. Just finally, no catch
431. try-with-resources (Java™ 7)
432. Method printStackTrace()
433. Ascending inheritance ordering
434. Descending inheritance ordering
435. Implementing convert
436. Problem: “Silent” errors
437. Step 1: Find exception base class
438. Step 2: Derive CardinalException
439. Step 3: Throwing CardinalException
440. Step 4: Unit test throwing CardinalException
441. Stack of integer values
442. Java™ collection features
443. Behind the scenes
444. Boxing and unboxing
445. Boxing syntax comparison
446. Parsing Integer user input
447. Parsing binary representation
448. Standard parse methods
449. Excerpt from java.util.Locale
450. Locale properties
451. Get a NumberFormat instance
452. Create a custom formatter
453. Polymorphic number parsing
454. Limited float precision
455. Limited double precision
456. Using BigDecimal
457. BigDecimal features
458. Using static double random()
459. Seeding a pseudo random generator
460. Interface examples
461. Observations
462. Writing strings to file
463. Using Text2File
464. Possible Text2File errors:
465. Employ “try-with-resources”
466. interface syntax
467. The AutoCloseable promise
468. abstract class replacement
469. interface vs. abstract class
470. interface MyAutoCloseable
471. Extending MyAutoCloseable to flush
472. Using MyFlushable
473. Inheritance hierarchy
474. Upcoming topics
475. Interfaces implemented by class String
476. The Comparable interface
477. class String and Comparable
478. Comparison examples
479. Ascending and descending names
480. API requirements
481. Sorting strings alphabetically
482. Situation dependent sorting criteria
483. Implementing flexible sorting
484. Comparator in action
485. Case insensitive sort
486. Sort descending by lambda expression
487. What's the use of hashing anyway?
488. Account hierarchy
489. Students and lecturers
490. An array of strings
491. An associative array describing month lengths
492. Grouping towns by country names
493. Personal examination cheat sheets
494. Unit tests in examinations
495. Example interface definition
496. Corresponding test
497. Unit tests strategy in examinations
498. Bonus points
499. Collaborative efforts
500. Project rules
501. Internal code documentation
502. Internal code documentation hints
503. Javadoc™ mismatches
504. (Automated) tests
505. Deployment and execution
506. Marking criteria
507. Sample forecast session
508. Sample forecast invocation
509. Underlying data provider
510. cities.list.json.gz providing cities
511. ma/Copy URL result to file
512. Parse city data
513. Parse weather data
514. Requirements
515. Logging
516. Minimalist token scanner
517. Scanner output -1.34 0.34 + sqrt
518. Adding error detection
519. Error message
520. Running the currency converter terminal application.
521. Steps creating a new project
522. Creating a project at MI gitlab
523. Cloning a git project
524. Enter project folder, add Readme.md
525. Committing change set
526. Push to upstream repository
527. Inserting a Maven project
528. git status 1
529. Adding Maven files to repository
530. git status 2
531. Commit Maven project files
532. git status 3
533. Push to upstream again
534. Reverting changes
535. Pull changes from upstream
536. Maven: Recommended reading
537. What is Maven anyway?
538. Maven: Facts and benefits
539. Convention Over Configuration
540. Maven project layout
541. The project object model file
542. pom.xml characteristics
543. pom.xml vs. Makefile
544. »Hello, world« pom.xml
545. Executing »compile« phase
546. Examining the Java™ version culprit
547. Resolving encoding / Java™ version issues
548. POM inheritance
549. The Super POM
550. pom-4.0.0.xml content
551. Favour https in ~/.m2/settings.xml
552. Resolving to effective pom.xml
553. Plugin architecture
554. Sample plugins
555. Example: The maven-javadoc-plugin
556. Adding test capabilities
557. Dependency listing
558. Absence of hamcrest in pom.xml
559. ~/.m2/repository/junit/junit/4.12/junit-4.12.pom
560. Transitive dependencies
561. Oblivious to test implementation: TestNG
562. Phases
563. Maven lifecyles and phases
564. hooking into phase
565. Personal examination cheat sheets
566. Live lecture additions
567. List of exercises
568. Virtualized Linux images
569. Oxygenxml
570. Examples and exercises source code
571. Tooling options
572. Installing Mysql™
573. Setting database root password
574. Connect to database
575. New user and privileges
576. Testing hdmuser access
577. Installing Mysql™ driver using aptitude.
578. Installing Mysql™ driver using Maven.
579. Intellij IDEA Mysql™ driver configuration
580. Sqldeveloper Mysql™ driver configuration
581. Sqldeveloper Mysql™ connection configuration
582. Recommended reading
583. What is XML?
584. Application domains
585. Benefits
586. Relevance (2018/02)
587. JSON catches up!
588. Rendering (X)HTML markup
589. HTML tree structure
590. MathML formula
591. MathML tree graph representation
592. HTML / MathML document similarities
593. XML files: Representing data
594. Representing CAD data
595. XML basic structure
596. Minimal XML document
597. Empty tags
598. Representing messages.
599. Just plain XML?
600. MI department CLI parser
601. Non-wellformed, missing </from>
602. Improperly nested elements
603. Improperly nested elements: Result
604. Proper nesting of XML elements
605. Improperly nested elements
606. “date” and “priority” attributes.
607. Unique attribute names
608. Quotes required
609. Important well-formedness constraints
610. XML markup collision I
611. XML markup collision II
612. XML standard replacement entities
613. Using CDATA sections
614. Using replacement entities
615. Processing instruction (PI)
616. Recommended reading
617. XML and application code
618. HTML validity
619. Well-formed and valid
620. XML grammar examples
621. An address book
622. A <contact> record
623. <contact> business rules:
624. EBNF grammar representation
625. organizer.xsd XSD schema
626. Linking instance to schema
627. Centralized schema definition
628. Validating a contact
629. Uups, we fail!
630. Schema observations
631. Well-formed and valid documents
632. Terminology
633. V02: Define <email> as optional
634. V03: Multiple contacts
635. Choose <contact> as root
636. Graphical schema representation
637. Adding <birthDate>
638. Supply a <birthDate> type
639. <birthDate> element or attribute?
640. Using a birthDate attribute
641. Absent birthDate attribute
642. XSD attributes revisited
643. Consider <email>
644. User defined email type
645. Using new email type
646. Strange: The Ur type
647. Adding missing data types
648. Nested elements becoming invalid
649. Introducing categories
650. Category type violation
651. Ooops: Text content and attributes
652. SQL query result
653. Predicate based queries acting on XML documents
654. Comparing SQL and XPath
655. Similarities and differences
656. Simple XPath queries
657. Relative file system search using find
658. find starting from absolute path
659. XPath and context nodes
660. Union
661. Union / descent
662. Recursive search for element name
663. Recursive + index search
664. Surprise!
665. Axes / siblings
666. Following sibling
667. Disjoint XPath axis definitions.
668. Element restricted following sibling
669. Elements containing non-whitespace text
670. Elements containing text containing 'house'
671. Elements containing text of minimal length
672. Searching for attribute presence
673. Searching for attribute value
674. Boolean »or«
675. Introducing nicknames
676. Nickname semantics
677. <xs:unique>
678. Introducing id values
679. id semantics
680. <xs:key> vs. <xs:unique>
681. Enhancing error message understanding
682. Referencing contacts
683. Violating referential integrity
684. Enforcing referential integrity
685. Participant reference duplicates
686. Solution:New key constraint
687. Participant reference duplicates
688. Nested vs. reference
689. <memo> exercise series
690. Invoice integrity constraints
691. Relational implementation
692. XML schema's and Java™ class declarations.
693. A first schema version for book documents
694. Version 2 of book.xsd
695. Required knowledge
696. Important XML Java™ APIs
697. SAX: XML to events
698. SAX architecture
699. DOM assembly
700. SAX deficiencies
701. DOM: Language independence
702. DOM: Vendor independence
703. DOM Node CORBA 2.2 IDL
704. Defining a language binding
705. org.w3c.dom.Node Java™ binding.
706. A context node's children
707. org.w3c.dom.Node subtypes
708. DOM Java™ binding inheritance interface hierarchy
709. DOM modules.
710. Jdom vs. DOM: Advantages
711. Jdom vs. DOM: Disadvantages
712. Prerequisite: pom.xml configuration
713. Exporting data as XML
714. XML document creation from scratch.
715. XML catalog sample data
716. SAX error handler
717. Accessing an XML Tree purely by DOM methods.
718. Driver class execution entry point
719. Project sample code for import
720. DOM and Javascript
721. DOM Javascript example
722. DOM Javascript demo
723. Why using XPath ?
724. XPath and Jdom
725. XPath on top of Jdom
726. HTML containing <img> tags.
727. Objective: Find contained images
728. XSL script extracting images.
729. Setting up the parser
730. Search using XPath //html:img
731. Searching for images
732. Parameterized search expressions
733. A simplified XML product catalog
734. A XSL style sheet for catalog transformation to HTML.
735. Transforming an XML document instance to HTML by a XSL style sheet.
736. A driver class for the xml2xml transformer.
737. Prerequisite knowledge
738. Persistence [Bauer2015]
739. Java™ transient instances
740. RDBMS persistent records
741. Persisting transient User instances
742. Observations
743. Networking between clients and database server
744. JDBC™ features
745. JDBC™ in a three-tier application
746. JDBC™ connecting application server and database.
747. JDBC™ connection parameter
748. Components of a JDBC™ URL
749. IETF Uniform Resource Identifier
750. URL examples
751. Sub protocol examples
752. No standard port assignments ...
753. ... but Mysql made it into Linux
754. JDBC™ architecture
755. DriverManager: Bootstrapping connections
756. Example: Mysql connection implementation
757. Driver libraries
758. Driver libraries, Maven
759. Driver unavailable
760. Connection interface
761. Statement interface
762. JDBC™ instances and relationships.
763. Important Connection methods
764. Important Statement methods
765. JDBC™ and threading.
766. JDBC™ connection pooling
767. pom.xml driver runtime scope
768. Person table
769. Objective: insert person record
770. JDBC™ backed data insert
771. Result
772. Two JDBC™ configurations
773. Figure 770, “JDBC™ backed data insert ” deficiencies
774. Why properties?
775. message.properties string externalization
776. Properties code sketch
777. Intellij IDEA settings, preconditions
778. Database related unit test phases
779. Implementing unit tests
780. Spring is your friend
781. Project layout
782. Closing connections
783. Employ AutoCloseable
784. Sniffing a JDBC™ connection by an intruder.
785. Setting up Wireshark
786. Capturing results
787. Mysql™ security
788. Mysql™ security
789. Assembling SQL
790. SQL injection principle
791. Preventing traffic tickets
792. Trouble at school
793. SQL injection impact
794. SQL injection relevance, [Clarke2009]
795. Lessons learned?
796. Validating user input prior to dynamically composing SQL statements.
797. Error message being presented to the user.
798. SQL statements in Java™ applications get parsed at the database server
799. Two questions
800. Addressing performance
801. Addressing performance mitigation
802. Addressing security
803. Solution: Use java.sql.PreparedStatement
804. PreparedStatement principle.
805. Three phases using parameterized queries
806. PreparedStatement example
807. Injection attempt example
808. No dynamic table support
809. JDBC™ read and write
810. Server / client object's life cycle
811. JDBC™ record container
812. Reading data from a database server.
813. Names and birth dates of friends
814. Accessing friend's database records
815. Important ResultSet states
816. JDBC™ to Java™ type conversions
817. Java™ to JDBC™ type conversions
818. Fixed type accessors
819. Polymorphic accessors
820. Access by column name
821. Access by column index
822. Problem: null value ambiguity
823. Resolving null value ambiguity
824. Users and groups
825. Isolation level
826. JDBC™ Isolation level
827. Setting the isolation level
828. Why using JPA ?
829. What about “impedance”?
830. OR impedance mismatch
831. JPA 2.0
832. JPA 2.1
833. JPA 2.2
834. JPA overview
835. JPA components
836. Maven pom.xml
837. Right click »Add Framework Support«
838. Enable Hibernate support
839. »File« --> »Project Structure«
840. Criteria / Querydsl annotation processing
841. Class StudyCourse
842. Transient instance
843. Persistence: Business rules
844. StudyCourse entity definition
845. persistence.xml configuration
846. CreateStudyCourse using a transaction
847. Database state
848. ReadStudyCourseById retrieval by primary key
849. Retrieving all instances
850. Type conversion problems
851. Reading shortName values
852. Adding a setter
853. Update language
854. Populating the database
855. JPQL: Domain model and database
856. JPA query alternatives
857. JPQL
858. JPQL parameter
859. JPQL record retrieval
860. Criteria entity metamodel
861. Criteria query
862. No injection susceptibility
863. Querydsl entity metamodel
864. From “Querying JPA”
865. Querydsl query
866. No injection susceptibility
867. Business and surrogate keys
868. Database generation strategies
869. INSERT omitting id
870. Generated surrogate id
871. StudyCourse creation
872. Entity Student
873. Database schema
874. Providing enrollment
875. CreateUniversity
876. Editing a Docbok 5 document using the XMLMind editor.
877. A simple GUI to insert data into a database server.
878. PersistenceHandler state transitions.
879. A GUI frontend for adding personal data to a server.
880. Login credentials for database connection
881. Intended usage behaviour for insertion of data records.
882. XSL target formats
883. Motivating XSL
884. A memo document instance with an internal reference.
885. Extracting the sender's name
886. Execution and Result
887. XSL processor transforming XML using a stylesheet
888. Transformation syntax details
889. List of recipient nodes iteration.
890. Selecting node sets from memo document instances
891. XPath content/para starting from context node <memo>.
892. Exporting SQL statements.
893. A graphical representation of our <catalog>.
894. A memo with 9 recipients
895. A <book> document with two chapters
896. Visualizing arbitrary XML input data.
897. Generating HTML from a XML document and an RDBMS.
898. A XML based catalog.
899. A Relation containing price information.
900. HTML generated output.
901. Parsing a XML document creates a corresponding sequence of events.
902. SAX Principle
903. Counting XML elements.
904. A non well formed document.
905. An invalid XML document.
906. A sample catalog containing products and corresponding descriptions.
907. The most simple FO document
908. Regions being defined in a page.
909. A complete FO parameterizing of a physical page and the fo:region-body.
910. Parameterizing page- and region view port. All length dimensions are in mm.
911. Parameterizing header and footer.
912. A fo:block with a fo:inline descendant.
913. An itemized list and result.
914. Two simulated entries in a table of contents.
915. Four entries separated by equal amounts of dotted space.
916. A horizontal line separator between header and body of a page.
917. Roman style page numbers.
918. A dictionary with running page headers.
919. Two blocks mutual page referencing each other.
920. Two blocks with mutual page- and hypertext references.
921. Different target formats from common source.
922. Generating a sender's surname for printing.
923. A memo document instance.
924. Why XML based publishing?
925. XML features
926. Editors, compositors, designers ...
927. Promises in publishing
928. Publishing reality
929. Single source publishing
930. Separating Structure, content and format
931. Separating concerns
932. Content
933. Hierarchical structure
934. Hierarchical structure, XML source
935. Presentation
936. Example 1: HTML 5, pure structure
937. Example 2: TeX / LaTeX
938. Separating structure and presentation(s)
939. Sample technical document
940. Observations
941. Pros and cons of TeX / LaTeX
942. Tools of the trade
943. Inline formatting
944. Paragraphs
945. Lists
946. Tables
947. Images
948. Mathematical formulas
949. Cross references
950. Document sectioning
951. Modular document components
952. What is Docbook?
953. Authoring and publishing
954. Document representation
955. Software centric schema
956. Document targets
957. Docbook components
958. Target format overview
959. Tooling / Software
960. Different schema languages
961. Plain HTML
962. Web help
963. Eclipse help
964. Printed output
965. Paragraph
966. Itemized list
967. Ordered list
968. Glossary list
969. Nested lists
970. Reference
971. A table
972. A MathML equation
973. A TeX equation
974. Reference
975. Figure
976. Image map + calloutlist
977. Video
978. A warning
979. Reference
980. Recursive sections
981. Non-recursive sections
982. Two different link flavours
983. Choosing a top level element
984. Allowed 5.1 top level elements
985. Schematron on top of RelaxNG
986. Example: xml:id and permalink
987. Using Display #Anchors
988. Considerations author based permalink
989. Schematron permalink rule
990. HTML customization overview
991. Target specific configuration
992. Link stability
993. use.id.as.filename = 1
994. Parameter: use.id.as.filename
995. Customization parameter ulink.target
996. callout.unicode / callout.graphics
997. Links
998. Hooking into XSL
999. Categories
1000. Example: videos
1001. Links
1002. Customize by CSS
1003. Example CSS modifications
1004. Styling the editor
1005. Motivating modular documents
1006. Monolithic document problems
1007. Document decomposition
1008. A monolithic document
1009. Decomposing documents
1010. XML grammar defining languages
1011. Address list schema
1012. Format conversion problem
1013. XSL template rules
1014. Example: Formatting <title> elements
1015. Basic FO introduction
1016. XMLMind Editor
1017. Oxygenxml Author
1018. Vendor links
1019. Inverse editing
1020. Document representation
1021. Components
1022. BibTeX
1023. Makeindex example
1024. Makeindex work flow
1025. Extension example: MusiXTeX
1026. Flavours
1027. Components
1028. Editors
1029. Two departments billing and research populated with sample user entries
1030. Optimistic concurrency control
1031. Failure with optimistic transactions
1032. Reasons for using Maven
1033. Transitive dependencies
1034. A basic persistence.xml JPA configuration file.
1035. JPA persistence provider
1036. Mapping hibintro.v1.model.User instances to a database.
1037. A basic User class.
1038. Mapping properties to attributes.
1039. Annotating integrity constraints
1040. Database schema mapping instances of hibintro.v1.model.User.
1041. Loading a single object by a primary key value.
1042. Retrieving hibintro.v1.model.User instances by HQL.
1043. Business rules for projects
1044. Persistence related object states
1045. Introducing inheritance mapping
1046. Modelling payment.
1047. A single relation mapping.
1048. Mapping the inheritance hierarchy.
1049. Inserting payment information
1050. Figure subclasses
1051. Joined subclass mapping.
1052. Implementing Object.equals(Object) by natural keys
1053. JPA caches.
1054. Basics on Jax-RS
1055. An example LDAP Tree
1056. File services
1057. Customer demands
1058. Driving factors
1059. Selected cloud file services
1060. Selected self hosting products
1061. Nextcloud features
1062. Lightning integration
1063. Installation
1064. Docker hub
1065. Search images
1066. Pull image using CLI
1067. Pull Nextcloud image
1068. Nextcloud based on Alpine
1069. Inspect image
1070. Search an image's tags
1071. Nextcloud image by version
1072. List images by CLI
1073. Nextcloud latest image
1074. Duplicate Nextcloud images
1075. Maven ringing a bell?
1076. Un tag image by version
1077. Remove image by version
1078. Starting Nextcloud container
1079. List running containers
1080. Enter running container
1081. Remove container
1082. List volumes
1083. List orphaned volumes
1084. 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