Lecture notes

Martin Goik

Stuttgart Media University / MI

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