Lecture notes

Martin Goik

Stuttgart Media University / MI

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