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 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
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. Recommended reading
420. What is XML?
421. Application domains
422. Benefits
423. Relevance (2018/02)
424. JSON catches up!
425. Rendering (X)HTML markup
426. HTML tree structure
427. MathML formula
428. MathML tree graph representation
429. HTML / MathML document similarities
430. XML files: Representing data
431. Representing CAD data
432. XML basic structure
433. Minimal XML document
434. Empty tags
435. Representing messages.
436. MI department CLI parser
437. Non-wellformed, missing </from>
438. Parsing non-wellformed
439. Improperly nested elements
440. Improperly nested elements: Result
441. Proper nesting of XML elements
442. Improperly nested elements
443. date and priority attributes.
444. Unique attribute names
445. Quotes required
446. Important well-formedness constraints
447. XML markup collision I
448. XML markup collision II
449. XML standard replacement entities
450. Using CDATA sections
451. Using replacement entities
452. Processing instruction (PI)
453. Recommended reading
454. XML and application code
455. HTML validity
456. Well-formed and valid
457. XML grammar examples
458. A <contact> record
459. <contact> business rules:
460. <contact> EBNF grammar
461. Initial organizer schema
462. Linking instance to schema
463. Centralized schema definition
464. Validating a contact
465. Uups, we fail!
466. Schema observations
467. Well-formed and valid documents
468. Terminology
469. V02: Define <email> as optional
470. V03: Multiple contacts
471. Choose <contact> as root
472. Graphical schema representation
473. Adding <birthDate>
474. Supply a <birthDate> type
475. Why <birthDate> element?
476. Using a birthDate attribute
477. Absent birthDate attribute
478. XSD attributes revisited
479. Consider <email>
480. User defined email type
481. Using new email type
482. Strange: The Ur type
483. Adding missing data types
484. Nested elements becoming invalid
485. Introducing categories
486. Category type violation
487. Ooops: Text content and attributes
488. SQL query result
489. Comparing SQL and XPath
490. Similarities and differences
491. Simple XPath queries
492. Relative file system search using find
493. find starting from absolute path
494. XPath and context nodes
495. Union
496. Union / descent
497. Recursive search for element name
498. Recursive + index search
499. Surprise!
500. Siblings
501. Following siblings
502. Disjoint XPath axis definitions.
503. Element restricted following siblings
504. Elements containing non-whitespace text
505. Elements containing text containing 'house'
506. Elements containing text of minimal length
507. Searching for attribute presence
508. Searching for attribute value
509. Introducing nicknames
510. Nickname semantics
511. <xs:unique>
512. Introducing id values
513. id semantics
514. <xs:key> vs. <xs:unique>
515. Enhancing error message understanding
516. Referencing contacts
517. Violating referential integrity
518. Enforcing referential integrity
519. Participant reference duplicates
520. Solution:New key constraint
521. Participant reference duplicates
522. Nested vs. reference
523. <memo> exercise series
524. Invoice integrity constraints
525. Relational implementation
526. XML schema's and Java™ class declarations.
527. A first schema version for book documents
528. Version 2 of book.xsd
529. Required knowledge
530. A context node's children
531. org.w3c.dom.Node subtypes
532. DOM Java™ binding inheritance interface hierarchy
533. DOM modules.
534. Using Jdom
535. Maven pom.xml configuration.
536. Exporting data as XML
537. XML document creation from scratch.
538. Accessing a XML Tree purely by DOM methods.
539. DOM and Javascript
540. DOM Javascript example
541. DOM Javascript demo
542. Why using XPath ?
543. XPath and Jdom
544. HTML containing <img> tags.
545. Objective: Find contained images
546. XSL script extracting images.
547. Setting up the parser
548. Search using XPath //html:img
549. Searching for images
550. Parameterized search expressions
551. A simplified XML product catalog
552. A XSL style sheet for catalog transformation to HTML.
553. Transforming an XML document instance to HTML by a XSL style sheet.
554. A driver class for the xml2xml transformer.
555. Prerequisite knowledge
556. Persistence [Bauer2015]
557. Java™ transient instances
558. RDBMS persistent records
559. Persisting transient User instances
560. Observations
561. Networking between clients and database server
562. JDBC™ features
563. JDBC™ in a three-tier application
564. JDBC™ connecting application server and database.
565. JDBC™ connection parameter
566. Components of a JDBC™ URL
567. IETF Uniform Resource Identifier
568. URL examples
569. Sub protocol examples
570. No standard port assignments ...
571. ... but Mysql made it into Linux
572. JDBC™ architecture
573. DriverManager: Bootstrapping connections
574. Example: Mysql connection implementation
575. Driver libraries
576. Driver libraries, Maven
577. Driver unavailable
578. Connection interface
579. Statement interface
580. JDBC™ instances and relationships.
581. Important Connection methods
582. Important Statement methods
583. JDBC™ and threading.
584. JDBC™ connection pooling
585. pom.xml driver runtime scope
586. Person table
587. Objective: insert person record
588. JDBC™ backed data insert
589. Result
590. Two JDBC™ configurations
591. Figure 588, “JDBC™ backed data insert ” deficiencies
592. Why properties?
593. string externalization
594. Properties code sketch
595. Intellij IDEA settings, preconditions
596. Database related unit test phases
597. Implementing unit tests
598. Spring is your friend
599. Project layout
600. Closing connections
601. Employ AutoCloseable
602. Sniffing a JDBC™ connection by an intruder.
603. Setting up Wireshark
604. Capturing results
605. Mysql™ security
606. Mysql™ security
607. Assembling SQL
608. SQL injection principle
609. Trouble at school
610. SQL injection impact
611. SQL injection relevance, [Clarke2009]
612. Lessons learned?
613. Validating user input prior to dynamically composing SQL statements.
614. Error message being presented to the user.
615. SQL statements in Java™ applications get parsed at the database server
616. Two questions
617. Addressing performance
618. Addressing performance mitigation
619. Addressing security
620. Solution: Use java.sql.PreparedStatement
621. PreparedStatement principle.
622. Three phases using parameterized queries
623. PreparedStatement example
624. Injection attempt example
625. No dynamic table support
626. JDBC™ read and write
627. Server / client object's life cycle
628. JDBC™ record container
629. Reading data from a database server.
630. Names and birth dates of friends
631. Accessing friend's database records
632. Important ResultSet states
633. JDBC™ to Java™ type conversions
634. Java™ to JDBC™ type conversions
635. Fixed type accessors
636. Polymorphic accessors
637. Access by column name
638. Access by column index
639. Problem: null value ambiguity
640. Resolving null value ambiguity
641. Users and groups
642. Isolation level
643. JDBC™ Isolation level
644. Setting the isolation level
645. Why using JPA ?
646. What about impedance?
647. OR impedance mismatch
648. JPA 2.0
649. JPA 2.1
650. JPA 2.2
651. JPA overview
652. JPA components
653. Maven pom.xml
654. Right click »Add Framework Support«
655. Enable Hibernate support
656. »File« --> »Project Structure«
657. Criteria / Querydsl annotation processing
658. Class StudyCourse
659. Transient instance
660. Persistence: Business rules
661. StudyCourse entity definition
662. persistence.xml configuration
663. CreateStudyCourse using a transaction
664. Database state
665. ReadStudyCourseById retrieval by primary key
666. Retrieving all instances
667. Type conversion problems
668. Reading shortName values
669. Adding a setter
670. Update language
671. Populating the database
672. JPQL: Domain model and database
673. JPA query alternatives
674. JPQL
675. JPQL parameter
676. JPQL record retrieval
677. Criteria entity metamodel
678. Criteria query
679. No injection susceptibility
680. Querydsl entity metamodel
681. From Querying JPA
682. Querydsl query
683. No injection susceptibility
684. Business and surrogate keys
685. Database generation strategies
686. INSERT omitting id
687. Generated surrogate id
688. StudyCourse creation
689. Entity Student
690. Database schema
691. Providing enrollment
692. CreateUniversity
693. Editing a Docbok 5 document using the XMLMind editor.
694. A simple GUI to insert data into a database server.
695. PersistenceHandler state transitions.
696. A GUI frontend for adding personal data to a server.
697. Login credentials for database connection
698. Intended usage behaviour for insertion of data records.
699. XSL target formats
700. Motivating XSL
701. A memo document instance with an internal reference.
702. Extracting the sender's name
703. Execution and Result
704. XSL processor transforming XML using a stylesheet
705. Transformation syntax details
706. List of recipient nodes iteration.
707. Selecting node sets from memo document instances
708. XPath content/para starting from context node <memo>.
709. Exporting SQL statements.
710. A graphical representation of our <catalog>.
711. A memo with 9 recipients
712. A <book> document with two chapters
713. Visualizing arbitrary XML input data.
714. Generating HTML from a XML document and an RDBMS.
715. A XML based catalog.
716. A Relation containing price information.
717. HTML generated output.
718. Parsing a XML document creates a corresponding sequence of events.
719. SAX Principle
720. Counting XML elements.
721. A non well formed document.
722. An invalid XML document.
723. A sample catalog containing products and corresponding descriptions.
724. The most simple FO document
725. Regions being defined in a page.
726. A complete FO parameterizing of a physical page and the fo:region-body.
727. Parameterizing page- and region view port. All length dimensions are in mm.
728. Parameterizing header and footer.
729. A fo:block with a fo:inline descendant.
730. An itemized list and result.
731. Two simulated entries in a table of contents.
732. Four entries separated by equal amounts of dotted space.
733. A horizontal line separator between header and body of a page.
734. Roman style page numbers.
735. A dictionary with running page headers.
736. Two blocks mutual page referencing each other.
737. Two blocks with mutual page- and hypertext references.
738. Different target formats from common source.
739. Generating a sender's surname for printing.
740. A memo document instance.
741. Why XML based publishing?
742. XML features
743. Editors, compositors, designers ...
744. Promises in publishing
745. Publishing reality
746. Single source publishing
747. Separating Structure, content and format
748. Separating concerns
749. Content
750. Hierarchical structure
751. Hierarchical structure, XML source
752. Presentation
753. Example 1: HTML 5, pure structure
754. Example 2: TeX / LaTeX
755. Separating structure and presentation(s)
756. Sample technical document
757. Observations
758. Pros and cons of TeX / LaTeX
759. Tools of the trade
760. Inline formatting
761. Paragraphs
762. Lists
763. Tables
764. Images
765. Mathematical formulas
766. Cross references
767. Document sectioning
768. Modular document components
769. What is Docbook?
770. Authoring and publishing
771. Document representation
772. Software centric schema
773. Document targets
774. Docbook components
775. Target format overview
776. Tooling / Software
777. Different schema languages
778. Plain HTML
779. Web help
780. Eclipse help
781. Printed output
782. Paragraph
783. Itemized list
784. Ordered list
785. Glossary list
786. Nested lists
787. Reference
788. A table
789. A MathML equation
790. A TeX equation
791. Reference
792. Figure
793. Image map + calloutlist
794. Video
795. A warning
796. Reference
797. Recursive sections
798. Non-recursive sections
799. Two different link flavours
800. Choosing a top level element
801. Allowed 5.1 top level elements
802. Schematron on top of RelaxNG
803. Example: xml:id and permalink
804. Using Display #Anchors
805. Considerations author based permalink
806. Schematron permalink rule
807. HTML customization overview
808. Target specific configuration
809. Link stability
810. = 1
811. Parameter:
812. Customization parameter
813. callout.unicode /
814. Links
815. Hooking into XSL
816. Categories
817. Example: videos
818. Links
819. Customize by CSS
820. Example CSS modifications
821. Styling the editor
822. Motivating modular documents
823. Monolithic document problems
824. Document decomposition
825. A monolithic document
826. Decomposing documents
827. XML grammar defining languages
828. Address list schema
829. Format conversion problem
830. XSL template rules
831. Example: Formatting <title> elements
832. Basic FO introduction
833. XMLMind Editor
834. Oxygenxml Author
835. Vendor links
836. Inverse editing
837. Document representation
838. Components
839. BibTeX
840. Makeindex example
841. Makeindex work flow
842. Extension example: MusiXTeX
843. Flavours
844. Components
845. Editors
846. Two departments billing and research populated with sample user entries
847. Optimistic concurrency control
848. Failure with optimistic transactions
849. Reasons for using Maven
850. Transitive dependencies
851. A basic persistence.xml JPA configuration file.
852. JPA persistence provider
853. Mapping hibintro.v1.model.User instances to a database.
854. A basic User class.
855. Mapping properties to attributes.
856. Annotating integrity constraints
857. Database schema mapping instances of hibintro.v1.model.User.
858. Loading a single object by a primary key value.
859. Retrieving hibintro.v1.model.User instances by HQL.
860. Business rules for projects
861. Persistence related object states
862. Introducing inheritance mapping
863. Modelling payment.
864. A single relation mapping.
865. Mapping the inheritance hierarchy.
866. Inserting payment information
867. Figure subclasses
868. Joined subclass mapping.
869. Implementing Object.equals(Object) by natural keys
870. JPA caches.
871. Basics on Jax-RS
872. An example LDAP Tree