Lecture notes

Martin Goik

Stuttgart Media University / MI

	Source code provided at `https://gitlab.mi.hdm-stuttgart.de/goik/GoikLectures`
	Available formats:	Webhelp (this document) Zip archive for offline usage EPUB PDF
	Published under the terms of the Creative Commons Attribution 4.0 International Public License.

Table of Contents

Software development 1

Getting started

Lecture related resources

Using the exercises

Common software development related resources

Coached exercises

Using plain Java™

“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

The if conditional statement

The switch statement

while
do ... while
for

Logic related external exercises

Objects and Classes

Working with objects

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

Working with git locally.
Shared development with centralized remote.
Conflicts

Core Classes

Objects, equals() and hash-values
Reconsidering System.out.format().
Using class Math
String exercises
Analyzing file pathnames

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

Towns and country names

Creating an overview of grades

Examination hints

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

Postgresql database components
SQL client software

A relational recap exercise

Introduction to XML

The XML industry standard
Well formed XML documents

Beyond well- formedness

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

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

Criteria queries

Enhancing the model

Persisting lecture instances

Exporting XML catalog data using JPA.

Prerequisites

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
Namespaces

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

Target formats
Selected elements
Schematron
Customizing
Assemblies
Styling the editor application

Modular documents

RelaxNG Schema

Transforming documents

Target format HTML
Target format print

TeX / LaTeX
Docbook

LaTeX hello,... world
Important elements
Macro
A complete document

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

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

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

Preliminaries

Installing Bind
Basic configuration
Forwarders
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
LDAP based user login
Backup and recovery / restore
Replication
Accessing LDAP by a Java™ application.

Apache web server

Preliminaries

First Steps
Virtual hosts
SSL / TLS Support
LDAP authentication
Mysql™ database administration
Providing WEB based user management to your LDAP Server
Publish your documentation

Exercises

Network file systems served by Samba

Prerequisites
Samba server installation

Recommended Preparations

Install and send to local Users
Authentication Setup and Virtual Users
TLS
Spam and Virus defense

Introduction

Managing images
Running container
Volumes

The simple way: Using SQLite
The real McCoy: Using Mariadb

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

List of Figures

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