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

Past Software Development 1 examinations

SE1 Klausur Sommer 2018
SE1 Klausur Winter 2018
SD1 examination summer 2019

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