Lecture notes

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