Lecture notes

Martin Goik

Stuttgart Media University / MI

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