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