Martin Goik

Stuttgart Media University / MI

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