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 hints.

Starting an exam
Implementing the project skeleton
Finish the exam

Language Fundamentals

Integer, ASCII and Unicode

Primitive types

Arithmetic limitations

Conversions

Operators and expressions

Arithmetic and logical operators
Assignment operators
Unary operators

The if conditional statement

if-then-else
Using else if

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
Building a library of mathematical functions.

Unit testing

Tests and implementation
Improving the algorithm
Helpful Junit methods
Technical details

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

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

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

Past SDA1 examinations

SDA1 examination summer 2019

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