Martin Goik

Stuttgart Media University / MI

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