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.
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
Cancelling fractions
Building a library of mathematical functions.
Value types and reference types
Method calls, the details
A unit testing example
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
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
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 Eclipse
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
Suggested readings
XML Schema
Structural descriptions for documents
A machine readable description
Relating schema's and SQL - DDL
The airline example revisited
Relating schema's and Java™ class descriptions.
XML schema exercises
The Extensible stylesheet Language XSL
Required knowledge
A Hello, world XSL example
XPath and node sets
Example: memo recipients
Some important XSL elements
A complete HTML formatting example
Listing the recipients of a memo
XSL and mixed content
The function id()
XSL axis definitions
Splitting documents into chunks
Transforming arbitrary XML to XHTML
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
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 Extensible stylesheet Language XSL
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
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
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
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. Newly created archive
34. Hit »Choose File« in ILIAS
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. Check your answers again!
42. Proceed finishing ...
43. Finish the test
44. The codingbat sleepIn example.
45. Cash register
46. Zuse Z3
47. Eniac
48. Microprocessor ICs
49. Zilog Z80 CPU
50. Address and data bus sizes
51. Signed 3 bit integer representation
52. Signed 8 bit integer binary representation
53. 7-bit ASCII
54. 7-bit ASCII with even parity bit
55. ISO Latin 1 encoding
56. Some Unicode UTF-8 samples
57. Handle to memory
58. Variable declaration
59. Declare and use
60. Declaration and initialization
61. Multiple variables of same type
62. Variable naming conventions
63. Constants
64. Variable names (identifier)
65. Java™ keywords.
66. Case sensitivity
67. Define before use
68. Type safety
69. Forcing conversions
70. Watch out!
71. C: Don't worry, be happy ...
72. ... and watch the outcome
73. From the report
74. Maximum and minimum values
75. Dynamic typing in PERL
76. Using final
77. Two categories of variables
78. Reference type examples
79. float and double
80. Four ways representing 35
81. Know your limits!
82. Literal examples
83. int literals
84. int literals explained
85. Java™ literals
86. Just kidding ...
87. Strange things
88. Overflow
89. Limited precision
90. FloatConverter
91. Widening from byte to short
92. Narrowing from int to char
93. The binary plus operator
94. Binary operator output type
95. Arithmetic overflow pitfalls
96. Detecting arithmetic overflow (Java 8+)
97. Dividing by zero
98. Operator type behaviour
99. Binary operator type examples
100. Operator examples
101. Two comment flavors
102. Inline comments
103. Purposes of statements
104. General Syntax
105. Example: Declaring and assigning variables
106. Expression vs. statement
107. Multiple statements per line
108. Debugging multiple statements per line
109. Blocks
110. if block execution selection
111. if execution syntax
112. if ... else block execution selection
113. if ... else execution syntax
114. Best practices comparing for equality
115. Single statement branches
116. Corporate network security
117. Online banking
118. IP Spoofing
119. SSL Certificate error
120. The Apple goto fail SSL bug
121. Static code analysis
122. Nested if ... else
123. if ... else if ... else
124. if ... else if ... else syntax
125. User input recipe
126. Using a Scanner class collecting user input.
127. Converting numbers to day's names
128. Implementing day's number to name
129. Better: Using switch
130. switch Syntax
131. Switching on strings
132. Why loops?
133. Hard to parameterize
134. A while loop
135. while syntax
136. Combining increment and termination condition
137. A do ... while loop
138. do ... while syntax
139. Frequent usage of while
140. Replacing while by for
141. for syntax
142. for variable scope
143. for variable scope equivalence
144. for vs. while relationship
145. Nested loops
146. Calculating values
147. Instances of a Class
148. General class structure
149. What's a class anyway?
150. Rectangle objects
151. A class describing rectangles
152. Rectangle class and instances
153. Generated diagrams
154. Creating rectangle instances
155. Syntax creating instances
156. Assigning attribute values
157. Memory representation
158. References and null
159. References and null
160. Packages
161. Rules and conventions
162. Qualified name vs. import
163. Don't be too lazy!
164. Classes from java.lang
165. Class, package and file system
166. Source hierarchy view
167. Object methods
168. Scaling a rectangle
169. Scaling implementation
170. Using scale(...)
171. Method definition syntax
172. A rectangle's perimeter
173. Get perimeter implementation
174. Using Rectangle.getPerimeter()
175. Access control: Overall objectives
176. Example: Implementing time and date
177. Access violation
178. Access rules
179. Tips on Choosing an Access Level
180. Direct access vs. setter method
181. Why adding setter methods?
182. Implementation by minutes only
183. Package hierarchy of the employee example
184. Type signatures
185. Defining type signatures
186. A method signature
187. What is overloading?
188. Overloading, alternate names
189. No such concept in C
190. What about return type?
191. Method signatures rationale
192. Method signatures rationale
193. Example: System.out.print(...)
194. Creating and initializing rectangles
195. Defining a constructor
196. Constructor syntax
197. Constructors
198. Multiple constructors by overloading
199. Instances by overloaded constructors
200. No constructor vs. default constructor
201. Absent default constructor
202. Club membership objectives
203. Implementing membership numbers.
204. Showing membership numbers.
205. Access to the club's overall member count?
206. Accessing the club's member count
207. Do we require an instance?
208. Favour class over instance method
209. Syntax accessing class members
210. Defining a dependency to another Maven artifact.
211. Pascal's triangle representing binomial coefficients.
212. An implementation sketch for the exponential
213. Comparing exponential and approximation
214. Comparing sin(x) and its approximation.
215. Value vs. reference types
216. Example
217. Value variable Details
218. Reference variable Details
219. Only »call-by-value« in Java
220. »call-by-value« details
221. »call-by-reference« for objects?
222. »call-by-reference« details
223. No »call-by-reference« in Java
224. No »call-by-reference« details
225. C++ offers true »call-by-reference«
226. C++ »call-by-reference« details
227. Method calling
228. Three variable scopes
229. Scope lifetimes
230. Two runtime memory categories
231. Stack: Four operations
232. Example: Storing integer values
233. Method calling
234. Call stack trace
235. IDE debugger
236. Informal problem specification
237. Illustrating examples
238. Javadoc™ method specification
239. Execution using main(...)
240. Junit based specification test
241. Unit test execution
242. Execution result
243. More tests
244. Mass test examples
245. Observations
246. Correcting the implementation
247. Execution result
248. Final implementation
249. Execution result
250. Available comparison methods
251. Maven command line usage
252. Caution comparing float / double
253. Weird arithmetics?
254. Limited representation precision
255. Solving the issue
256. Superclass Object
257. String literals
258. OpenJDK String implementation
259. String copy constructor
260. Copy constructor and heap
261. Operator == and equals()
262. Hashing principle
263. Rectangle equals(...) and hashCode()
264. Rectangle hash values
265. Rectangle equals(...) and hashCode()
266. Contract equals(...) and hashCode()
267. Motivating Arrays
268. Per member repeating tasks
269. Example: int array of primes
270. Loop prime values
271. Mind the limit!
272. Safer: Using length
273. Safer: Use for-each style loop
274. Mind the limit, part two
275. One step initialization
276. Array
277. Two syntax variants
278. Array instances are special!
279. Array creation details
280. Array parameter passing
281. Parameter passing details
282. Value and reference types
283. Arrays.toString(...) and Arrays.sort(...)
284. Arrays.binarySearch(...)
285. Arrays.fill(...)
286. Arrays.copyOfRange(...)
287. Arrays.equals(...)
288. Extension problem
289. Extending an array
290. Extension result
291. Using Arrays.copyOf()
292. public static void main(String[] args)
293. Intellij IDEA run configuration
294. Intellij IDEA run configuration
295. Creating executable jar
296. Multidimensional arrays
297. Behind the scenes
298. Memory allocation
299. Two Tic-tac-toe players fighting each other.
300. Two Tic-tac-toe players fighting each other.
301. Duplicate code
302. Common and specific properties
303. Basic shape inheritance
304. Inheritance
305. Implementing Shape hierarchy
306. Creating instances
307. Shape constructor
308. Shape log info
309. Overwriting toString()
310. Shape extending Object
311. Creating Rectangle instances
312. Rectangle constructor
313. Logging Rectangle instances
314. Override toString() again.
315. Rectangle extending Shape´
316. Implementing Circle
317. Shape and toString()
318. Moving Shape instances
319. Implementing Shape movements
320. Fools are everywhere!
321. Solution: final prevents overriding
322. Calculating a shape's area
323. Desired: Polymorphic getArea() call
324. Problems:
325. abstract method getArea()
326. abstract method getArea()
327. What's a shape anyway?
328. No instances of abstract classes.
329. Mandatory getArea() implementation.
330. Facts about abstract fields, methods and classes.
331. Moving shapes
332. protected access
333. final classes
334. final classes, rationale
335. Defeating polymorphism
336. Defining equals(...) of Shape instances
337. Comparing center coordinates
338. Implementing Rectangle.equals()
339. Implementing Circle.equals()
340. Testing equality of Shape objects
341. Compile- and runtime errors
342. NullPointerException (NPE for short)
343. NullPointerException is a class
344. Throwing an exception
345. Catching an exception by try {...} catch {...}
346. try {...} catch {...} syntax
347. Checked and unchecked exceptions
348. Checked and unchecked exceptions
349. Expected exceptions in Junit
350. Just finally
351. try-with-resources (Java™ 7)
352. Method printStackTrace()
353. Ascending inheritance ordering
354. Descending inheritance ordering
355. Implementing convert
356. Problem: Silent errors
357. Step 1: Find exception base class
358. Step 2: Derive CardinalException
359. Step 3: Throwing CardinalException
360. Step 4: Unit test throwing CardinalException
361. Stack of integer values
362. Java™ collection features
363. Behind the scenes
364. Boxing and unboxing
365. Boxing syntax comparison
366. Parsing Integer user input
367. Parsing binary representation
368. Standard parse methods
369. Excerpt from java.util.Locale
370. Locale properties
371. Get a NumberFormat instance
372. Create a custom formatter
373. Polymorphic number parsing
374. Limited float precision
375. Limited double precision
376. Using BigDecimal
377. BigDecimal features
378. Using static double random​()
379. Seeding a pseudo random generator
380. Interface examples
381. Observations
382. Writing strings to file
383. Using Text2File
384. Possible Text2File errors:
385. Employ try-with-resources
386. interface syntax
387. The AutoCloseable promise
388. abstract class replacement
389. interface vs. abstract class
390. interface MyAutoCloseable
391. Extending MyAutoCloseable
392. Using MyFlushable
393. Inheritance hierarchy
394. Upcoming topics
395. What's the use of hashing anyway?
396. Account hierarchy
397. Students and lecturers
398. An array of strings
399. An associative array describing month lengths
400. Grouping towns by country names
401. Unit tests in examinations
402. Example interface definition
403. Corresponding test
404. Unit tests strategy in examinations
405. Bonus points
406. Collaborative efforts
407. Project rules
408. Internal code documentation
409. Internal code documentation hints
410. Javadoc™ mismatches
411. (Automated) tests
412. Deployment and execution
413. Marking criteria
414. Minimalist token scanner
415. Scanner output -1.34 0.34 + sqrt
416. Adding error detection
417. Error message
418. Running the currency converter terminal application.
419. Adding a JDBC™ Driver for Mysql to the database plugin.
420. Configuring a JDBC™ connection to a (local) Mysql database server.
421. Executing SQL statements, browsing schema and retrieving data
422. Rendering XHTML markup
423. Xhtml tree structure
424. A formula in MathML representation.
425. A tree graph representation of the MathML example given before.
426. XML basic structure
427. The representation of a short message.
428. An invalid XML document due to the omission of </from>.
429. Proper nesting of XML elements
430. Improperly nested elements
431. An XML Memo having attributes.
432. memo having email and paragraphs.
433. The pain of well-formedness
434. Memo business rules
435. Desired vocabulary
436. A memo schema.
437. XSD attributes revisited
438. A memo document instance holding a reference to a document external schema.
439. A schema reference to a FTP server.
440. Well-formed and valid documents
441. A first schema version for book documents
442. Invoice integrity constraints
443. Relational implementation
444. XML schema's and Java™ class declarations.
445. Version 2 of book.xsd
446. XSL target formats
447. Motivating XSL
448. A memo document instance with an internal reference.
449. Extracting the sender's name
450. Execution and Result
451. XSL processor transforming XML using a stylesheet
452. Transformation syntax details
453. SQL query result
454. Comparing SQL and XPath
455. Similarities and differences
456. Simple XPath queries
457. Relative file system search using find
458. find starting from absolute path
459. XPath and context nodes
460. Union
461. Union / descent
462. Recursive search for element name
463. Recursive + index search
464. Surprise!
465. Siblings
466. Following siblings
467. Disjoint XPath axis definitions.
468. Element restricted following siblings
469. Elements containing non-whitespace text
470. Elements containing text containing 'house'
471. Elements containing text of minimal length
472. Searching for attribute presence
473. Searching for attribute value
474. List of recipient nodes iteration.
475. Selecting node sets from memo document instances
476. XPath content/para starting from context node <memo>.
477. Exporting SQL statements.
478. A graphical representation of our <catalog>.
479. A memo with 9 recipients
480. A <book> document with two chapters
481. Visualizing arbitrary XML input data.
482. Required knowledge
483. A context node's children
484. org.w3c.dom.Node subtypes
485. DOM Java™ binding inheritance interface hierarchy
486. DOM modules.
487. Using Jdom
488. Maven pom.xml configuration.
489. Exporting data as XML
490. XML document creation from scratch.
491. Accessing a XML Tree purely by DOM methods.
492. DOM and Javascript
493. DOM Javascript example
494. DOM Javascript demo
495. Why using XPath ?
496. XPath and Jdom
497. HTML containing <img> tags.
498. Objective: Find contained images
499. XSL script extracting images.
500. Setting up the parser
501. Search using XPath //html:img
502. Searching for images
503. Parameterized search expressions
504. A simplified XML product catalog
505. A XSL style sheet for catalog transformation to HTML.
506. Transforming an XML document instance to HTML by a XSL style sheet.
507. A driver class for the xml2xml transformer.
508. Prerequisite knowledge
509. Persistence [Bauer2015]
510. Java™ transient instances
511. RDBMS persistent records
512. Persisting transient User instances
513. Observations
514. Networking between clients and database server
515. JDBC™ features
516. JDBC™ in a three-tier application
517. JDBC™ connecting application server and database.
518. JDBC™ connection parameter
519. Components of a JDBC™ URL
520. IETF Uniform Resource Identifier
521. URL examples
522. Sub protocol examples
523. No standard port assignments ...
524. ... but Mysql made it into Linux
525. JDBC™ architecture
526. DriverManager: Bootstrapping connections
527. Example: Mysql connection implementation
528. Driver libraries
529. Driver libraries, Maven
530. Driver unavailable
531. Connection interface
532. Statement interface
533. JDBC™ instances and relationships.
534. Important Connection methods
535. Important Statement methods
536. JDBC™ and threading.
537. JDBC™ connection pooling
538. pom.xml driver runtime scope
539. Person table
540. Objective: insert person record
541. JDBC™ backed data insert
542. Result
543. Two JDBC™ configurations
544. Figure 541, “JDBC™ backed data insert ” deficiencies
545. Why properties?
546. string externalization
547. Properties code sketch
548. Intellij IDEA settings, preconditions
549. Database related unit test phases
550. Implementing unit tests
551. Spring is your friend
552. Project layout
553. Closing connections
554. Employ AutoCloseable
555. Sniffing a JDBC™ connection by an intruder.
556. Setting up Wireshark
557. Capturing results
558. Mysql™ security
559. Mysql™ security
560. Assembling SQL
561. SQL injection principle
562. Trouble at school
563. SQL injection impact
564. SQL injection relevance, [Clarke2009]
565. Lessons learned?
566. Validating user input prior to dynamically composing SQL statements.
567. Error message being presented to the user.
568. SQL statements in Java™ applications get parsed at the database server
569. Two questions
570. Addressing performance
571. Addressing performance mitigation
572. Addressing security
573. Solution: Use java.sql.PreparedStatement
574. PreparedStatement principle.
575. Three phases using parameterized queries
576. PreparedStatement example
577. Injection attempt example
578. JDBC™ read and write
579. Server / client object's life cycle
580. JDBC™ record container
581. Reading data from a database server.
582. Names and birth dates of friends
583. Accessing friend's database records
584. Important ResultSet states
585. JDBC™ to Java™ type conversions
586. Java™ to JDBC™ type conversions
587. Fixed type accessors
588. Polymorphic accessors
589. Access by column name
590. Access by column index
591. Problem: null value ambiguity
592. Resolving null value ambiguity
593. Users and groups
594. Isolation level
595. JDBC™ Isolation level
596. Setting the isolation level
597. Why using JPA ?
598. What about impedance?
599. OR impedance mismatch
600. JPA 2.0
601. JPA 2.1
602. JPA 2.2
603. JPA overview
604. JPA components
605. Maven pom.xml
606. Right click »Add Framework Support«
607. Enable Hibernate support
608. »File« --> »Project Structure«
609. Criteria / Querydsl annotation processing
610. Class StudyCourse
611. Transient instance
612. Persistence: Business rules
613. StudyCourse entity definition
614. persistence.xml configuration
615. CreateStudyCourse using a transaction
616. Database state
617. ReadStudyCourseById retrieval by primary key
618. Retrieving all instances
619. Type conversion problems
620. Reading shortName values
621. Adding a setter
622. Update language
623. Populating the database
624. JPQL: Domain model and database
625. JPA query alternatives
626. JPQL
627. JPQL parameter
628. JPQL record retrieval
629. Criteria entity metamodel
630. Criteria query
631. No injection susceptibility
632. Querydsl entity metamodel
633. From Querying JPA
634. Querydsl query
635. No injection susceptibility
636. Business and surrogate keys
637. Database generation strategies
638. INSERT omitting id
639. Generated surrogate id
640. StudyCourse creation
641. Entity Student
642. Database schema
643. Providing enrollment
644. CreateUniversity
645. Editing a Docbok 5 document using the XMLMind editor.
646. A simple GUI to insert data into a database server.
647. PersistenceHandler state transitions.
648. A GUI frontend for adding personal data to a server.
649. Login credentials for database connection
650. Intended usage behaviour for insertion of data records.
651. Generating HTML from a XML document and an RDBMS.
652. A XML based catalog.
653. A Relation containing price information.
654. HTML generated output.
655. Parsing a XML document creates a corresponding sequence of events.
656. SAX Principle
657. Counting XML elements.
658. A non well formed document.
659. An invalid XML document.
660. A sample catalog containing products and corresponding descriptions.
661. The most simple FO document
662. Regions being defined in a page.
663. A complete FO parameterizing of a physical page and the fo:region-body.
664. Parameterizing page- and region view port. All length dimensions are in mm.
665. Parameterizing header and footer.
666. A fo:block with a fo:inline descendant.
667. An itemized list and result.
668. Two simulated entries in a table of contents.
669. Four entries separated by equal amounts of dotted space.
670. A horizontal line separator between header and body of a page.
671. Roman style page numbers.
672. A dictionary with running page headers.
673. Two blocks mutual page referencing each other.
674. Two blocks with mutual page- and hypertext references.
675. Different target formats from common source.
676. Generating a sender's surname for printing.
677. A memo document instance.
678. Why XML based publishing?
679. XML features
680. Editors, compositors, designers ...
681. Promises in publishing
682. Publishing reality
683. Single source publishing
684. Separating Structure, content and format
685. Separating concerns
686. Content
687. Hierarchical structure
688. Hierarchical structure, XML source
689. Presentation
690. Example 1: HTML 5, pure structure
691. Example 2: TeX / LaTeX
692. Separating structure and presentation(s)
693. Sample technical document
694. Observations
695. Pros and cons of TeX / LaTeX
696. Tools of the trade
697. Inline formatting
698. Paragraphs
699. Lists
700. Tables
701. Images
702. Mathematical formulas
703. Cross references
704. Document sectioning
705. Modular document components
706. What is Docbook?
707. Authoring and publishing
708. Document representation
709. Software centric schema
710. Document targets
711. Docbook components
712. Target format overview
713. Tooling / Software
714. Different schema languages
715. Plain HTML
716. Web help
717. Eclipse help
718. Printed output
719. Paragraph
720. Itemized list
721. Ordered list
722. Glossary list
723. Nested lists
724. Reference
725. A table
726. A MathML equation
727. A TeX equation
728. Reference
729. Figure
730. Image map + calloutlist
731. Video
732. A warning
733. Reference
734. Recursive sections
735. Non-recursive sections
736. Two different link flavours
737. Choosing a top level element
738. Allowed 5.1 top level elements
739. Schematron on top of RelaxNG
740. Example: xml:id and permalink
741. Using Display #Anchors
742. Considerations author based permalink
743. Schematron permalink rule
744. HTML customization overview
745. Target specific configuration
746. Link stability
747. = 1
748. Parameter:
749. Customization parameter
750. callout.unicode /
751. Links
752. Hooking into XSL
753. Categories
754. Example: videos
755. Links
756. Customize by CSS
757. Example CSS modifications
758. Styling the editor
759. Motivating modular documents
760. Monolithic document problems
761. Document decomposition
762. A monolithic document
763. Decomposing documents
764. XML grammar defining languages
765. Address list schema
766. Format conversion problem
767. XSL template rules
768. Example: Formatting <title> elements
769. Basic FO introduction
770. XMLMind Editor
771. Oxygenxml Author
772. Vendor links
773. Inverse editing
774. Document representation
775. Components
776. BibTeX
777. Makeindex example
778. Makeindex work flow
779. Extension example: MusiXTeX
780. Flavours
781. Components
782. Editors
783. Two departments billing and research populated with sample user entries
784. Optimistic concurrency control
785. Failure with optimistic transactions
786. Reasons for using Maven
787. Transitive dependencies
788. A basic persistence.xml JPA configuration file.
789. JPA persistence provider
790. Mapping hibintro.v1.model.User instances to a database.
791. A basic User class.
792. Mapping properties to attributes.
793. Annotating integrity constraints
794. Database schema mapping instances of hibintro.v1.model.User.
795. Loading a single object by a primary key value.
796. Retrieving hibintro.v1.model.User instances by HQL.
797. Business rules for projects
798. Persistence related object states
799. Introducing inheritance mapping
800. Modelling payment.
801. A single relation mapping.
802. Mapping the inheritance hierarchy.
803. Inserting payment information
804. Figure subclasses
805. Joined subclass mapping.
806. Implementing Object.equals(Object) by natural keys
807. JPA caches.
808. Basics on Jax-RS
809. An example LDAP Tree