Lecture notes

Martin Goik

Stuttgart Media University / MI

	Available formats:	Webhelp (this document) Zip archive for offline usage EPUB PDF
	Hosted at:	freedocs.mi.hdm-stuttgart.de freedocs.xtraservice.de
	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

113105 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 Intellij IDEA

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

Using automated tests.

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
Programmer's favourite expression
Lotteries revisited
The greatest common divisor and the common multiple
Maven support.
Project dependencies and Maven
Building a library of mathematical functions.

Unit testing

Tests and implementation
Improving the algorithm
Helpful Junit methods
Technical details
Example: A class representing fractions

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
Using class Math
String exercises
Analyzing file pathnames

Reconsidering System.out.format().

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

Exercising past examinations

Starting an exam
Implementing the project skeleton
Finish the exam

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

Past Software Development 1 examinations

SD1 examination winter 2021
SD1 examination summer 2021
SD1 examination winter 2020/1
SD1 examination winter 2020/2
SD1 examination summer 2020
SD1 examination winter 2019
SD1 examination summer 2019
SE1 Klausur Winter 2018
SE1 Klausur Sommer 2018

Working with git

Apache Maven

The project object model pom.xml
Plugins
Dependencies
Lifecycle, phases and goals

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

Project proposals

Authoring reveal.js presentations
Gitlab pages integration of Docbook
Codingbat reloaded
XML based exercise compilations
Representing and editing BiBTeX data
Past projects

List of Exercises

113473 Database and application development

Database features

Selected database products overview

Installation
Features
Exercises

Installation
Features
High performance sharding cluster
Exercises

JDBC: 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

Configuring a Maven based Eclipse Java™ project with Hibernate

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

Project ideas

Database copy tool
Database schema evolution tool
Extending UNIX grep to databases

List of Exercises

Software defined Infrastructure

UNIX / LINUX Basics

Prerequisites

Ubuntu / Debian Package management

Prerequisites

Getting started

Accessing your virtual machine
Global configurations

Preliminaries

Querying DNS data.
Installing Bind
Reverse lookups
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
Extending an existing entry
Filter based search
Accessing LDAP data by a mail client
LDAP configuration
LDAP based user login
Backup and recovery / restore
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. How much time to invest?
2. Recommended reading resources I
3. Recommended reading resources II
4. Your biggest enemies
5. German humour
6. 4 most imperative study objectives
7. Online tutorials
8. Unix and the terminal
9. Online programming, automated feedback
10. Online programming I
11. Online programming II
12. Java Visualizer
13. Live lecture additions
14. Intellij IDEA IDE (See installation details)
15. Virtualbox / VMware player based virtualized Linux image
16. Virtualbox™ settings
17. Embedded exercises
18. Using the exercises
19. HdM mail server
20. Configure MI VPN client access
21. MI Cloud server
22. E-examination resources
23. MI File server
24. MI Git versioning server
25. Coached exercises
26. Bonus points
27. Seminar rules and bonus points
28. Presenting exercise solutions
29. Edit - compile - execute
30. Editing Java™ files
31. Defining class HelloWorld
32. Compiling Java™ file
33. Command line Java™ file compilation
34. Java byte code file HelloWorld.class
35. Source code vs. bytecode
36. Executing byte code file HelloWorld.class
37. Command line byte code file HelloWorld.class execution
38. JDK™ installation options
39. Downloading IntelliJ idea
40. Idea »Ultimate« license types
41. Alternative: Using the HdM license server
42. Creating a new Java project
43. Manual calculation: Abacus
44. Mechanical calculation: Cash register
45. Electromechanical calculation: Zuse Z3
46. Vacuum Tube: Eniac
47. Transistor: Microprocessor ICs
48. Z80 8-bit data bus
49. Progress in hardware 1
50. Progress in hardware 2
51. Simple facts:
52. Unsigned 3 bit integer representation
53. Binary system addition
54. 3 bit two-complement representation
55. 3 bit two complement rationale: “Usual” addition
56. Signed 8 bit integer binary representation
57. 7-bit ASCII
58. 7-bit ASCII with even parity bit
59. Western European characters: ISO Latin 1 encoding
60. Unicode UTF-8 samples
61. Java types
62. Java primitive types, Part 1
63. Java primitive types, Part 2
64. Variables: Handles to memory
65. Variable declaration
66. Declare, assign and use
67. Combining declaration and initialization
68. Multiple variables of same type
69. Identifier in Java™:
70. Identifier name examples:
71. Java™ keywords.
72. Variable naming conventions
73. Constant variables
74. Case sensitivity
75. Define before use
76. Type safety
77. Compile time analysis
78. Forcing conversions
79. Watch out!
80. Casting long to int
81. Don't worry, be happy ...
82. ... and watch the outcome
83. From the report
84. Maximum and minimum values
85. Dynamic typing in PERL
86. Dynamic typing in PERL, part 2
87. Using final
88. Two categories of variables
89. Reference type examples
90. float and double
91. Four ways representing 35
92. Choose your output representation
93. Know your limits!
94. Literal examples
95. int literals
96. int literals explained
97. Java™ primitive literals
98. Java™ String and null literals
99. Just kidding ...
100. Strange things I
101. Strange things II
102. Arithmetic overflow pitfalls
103. Limited precision
104. Nearest float to 2.1
105. FloatConverter
106. Widening from byte literal to short
107. Narrowing from int literal to char variable
108. A widening «ladder»
109. A narrowing «ladder»
110. The binary plus operator
111. Binary operator output type
112. Detecting arithmetic overflow (Java 8+)
113. Dividing by zero
114. Generic binary operator
115. The modulus operator %
116. Binary operator type examples
117. No binary + operator yielding byte
118. int expression assignment
119. Constant expression assignment
120. The logical “and” operator &
121. The += operator
122. The &= operator
123. Assignment operators #1 / 2
124. Assignment operators #2 / 2
125. Increment operator ++
126. Different range behaviour!
127. Cast required
128. Prefix and postfix notation
129. Operator examples
130. Java™ comment flavors
131. Inline comments
132. Javadoc™ comments
133. Statements: General syntax
134. Statement examples: Declaring and assigning variables
135. Expression vs. statement
136. Multiple statements per line
137. Debugging multiple statements per line
138. Blocks
139. Conditional block execution
140. if syntax
141. if ... else
142. if ... else syntax
143. Best practices comparing for equality
144. Single statement branches
145. Nested if ... else
146. Enhanced readability: if ... else if ... else
147. if ... else if ... else syntax
148. User input recipe
149. Using a Scanner class collecting user input.
150. Converting numbers to day's names
151. Numbers to day's names: The hard way
152. Better: Using switch
153. switch Syntax
154. Switching on strings
155. Why loops?
156. Arbitrary number of repetitions
157. A while loop
158. Combining increment and termination condition
159. while syntax
160. Empty while body
161. A do ... while loop
162. do ... while syntax
163. Frequent usage of while
164. Replacing while by for
165. for syntax
166. for variable scope
167. for variable scope equivalence
168. for vs. while relationship
169. Nested loops
170. Better readability: Use row and column in favour of i and j
171. Calculating values
172. Response to coding errors
173. Unit test concept
174. alarmClock(...) with errors
175. Testing alarmClock(...)
176. Testing alarmClock(...) details
177. Instances of a Class
178. General class structure
179. What's a class anyway?
180. Rectangle objects
181. A class describing rectangles
182. Rectangle class and instances
183. Generated diagrams
184. The new operator: Creating rectangle instances
185. Syntax creating instances
186. Assigning attribute values to class instances
187. Instance memory representation
188. References and null
189. Checking for object presence
190. Why packages ?
191. Rules and conventions
192. Fully qualified class name vs. import
193. Don't be too lazy!
194. Special: Classes in package java.lang
195. Class, package and file system
196. Source hierarchy view
197. Object methods
198. Scaling a rectangle
199. Scaling method implementation
200. Scaling method signature
201. Using the scale(...) method
202. Method definition syntax
203. A rectangle's perimeter
204. getPerimeter() method implementation
205. Using Rectangle.getPerimeter()
206. Access control: Overall objectives
207. Example: Implementing time and date
208. Access violation
209. Access rules
210. “Tips on Choosing an Access Level”
211. Direct access vs. setter method
212. Why adding setter methods?
213. Implementation by minutes only
214. Defining type signatures
215. Type signature examples
216. Defining method signatures
217. Method signature examples
218. Method overloading: Same name, different signature
219. Overloading, alternate names
220. No overloading in »C«
221. »C« requires unique function names
222. No distinction on return type
223. Method signatures rationale
224. Method signatures rationale
225. Example: System.out.print(...)
226. Creating and initializing rectangles
227. Defining a constructor
228. Constructor syntax
229. Constructors
230. Multiple overloaded constructors
231. Constructor calls within constructor
232. Instances by overloaded constructors
233. No constructor vs. default constructor
234. Non - default constructor, but no default constructor
235. Employee example package hierarchy
236. Circle and variable scopes
237. Documenting classes and methods
238. Generated Javadoc
239. Refactoring «r» ⇒ «radius»
240. Scope assignment problem
241. this overriding method scope
242. Club membership objectives
243. Implementing club members.
244. Showing membership info.
245. Implementing membership numbers.
246. Showing membership numbers.
247. Member creation steps
248. Accessing the club's overall member count?
249. Accessing the club's member count
250. Do we really require an instance?
251. static: Favour class method over instance method
252. Syntax accessing class members
253. static / non-static wrap up
254. Finally understanding System.out.print(ln)
255. Using Maven
256. Maven archetypes
257. CLI example
258. Supplementary MI Maven archetypes
259. CLI archetype test
260. CLI archetype details
261. Generated project layout
262. Maven compile
263. Compilation file view
264. Execution
265. Maven package
266. Executing Java™ archive first-0.9.jar
267. Maven javadoc:javadoc
268. Maven clean
269. Intellij IDEA Maven support
270. Adding MI Maven server
271. New MI archetype project
272. pom.xml content changes
273. Intellij IDEA generating Javadoc™
274. Newton's letter to Robert Hooke
275. Project «lottery» depending on «helper»
276. Providing project «helper»
277. Install project «Helper»
278. helper-0.9.jar archive content
279. Consuming project «Lottery»
280. External libraries view
281. Using Helper.factorial(...) computing $(\begin{matrix} n \\ k \end{matrix}) = \frac{n!}{k! (n - k)!}$
282. Maven artifact dependency.
283. Maven repositories
284. Pascal's triangle representing binomial coefficients.
285. An implementation sketch for the exponential
286. Comparing exponential and approximation
287. Comparing sin(x) and its approximation.
288. Recommended reading
289. Test categories
290. Example: Computing prime numbers
291. Unit test principle
292. Test driven development
293. Steps in Unit Testing
294. Step 1 + 2: Specify method, write skeleton
295. Execution yet being flawed
296. Sample test data
297. Step 3: Junit based specification test
298. Junit skeleton test result (Maven CLI)
299. Junit skeleton test result (IDE)
300. Step 3: Providing more prime tests
301. Step 3: Prime mass testing
302. Step 4: Implement skeleton
303. Step 5: Testing our first implementation
304. Implementation observation
305. Changing the implementation
306. Regression test
307. Systematic error debugging
308. Error correction in detail
309. Available comparison methods
310. Caution comparing float / double !!
311. Weird arithmetics?
312. Limited representation precision
313. Solving the issue
314. The @Test annotation
315. The Assert class
316. Importing dependencies
317. Dependency archive content
318. Value vs. reference type variables
319. Different behaviour!
320. Value variable Details
321. Reference variable Details
322. Only «call-by-value» in Java™
323. «call-by-value» details
324. «call-by-reference» for objects?
325. «call-by-reference» details
326. No «call-by-reference» in Java™!
327. No «call-by-reference» details
328. C++ offers «call-by-reference» by virtue of “&”
329. C++ «call-by-reference» details
330. Method calling
331. Three variable scopes
332. Scope lifetimes
333. Two runtime memory categories
334. Stack: Four operations
335. Example: Storing integer values
336. Method calling
337. Call stack trace
338. IDE debugger
339. Motivation
340. Weekly offered lectures
341. Weekly offered lectures by simple numbers
342. Weekdays int representation
343. Weekly offered lectures using constants
344. Converting index values to day names
345. Providing lecture info
346. Sample lectures
347. Bogus index value
348. Pitfall: Method argument order mismatch
349. Enumeration by class instances
350. Class instance per enumeration value
351. switch no longer works
352. Re-writing getPrice()
353. Compile time argument mismatch error
354. Pitfall: Creating an undesired instance
355. Define a private Day constructor
356. Preventing undesired Day instance creation
357. Adding a day name attribute
358. enum Day replacing public class Day
359. switch statements working again
360. enum constructor being implicitly private
361. From https://www.urbandictionary.com
362. Useful links
363. Initialize git project
364. Configure author related data.
365. Adding resources to project index and staging area
366. Committing change set
367. Project versioning status
368. Adding a comment
369. git diff tracing changes
370. Reverting individual file.
371. Compiling, Math.class and Print.class.
372. Math.class, Print.class and versioning.
373. Show project's log
374. Switch to an older revision ...
375. ... and forth to current master's HEAD
376. Centralized remote repository
377. Step 1: Create remote repository
378. Step 2: Retrieve remote repository address
379. Step 2: Connect to remote repository
380. Step 3: Push local to remote
381. Step 3: Pull remote to local
382. Alternative: Create remote, then clone
383. Conflicting changes
384. Commit schedule
385. User B: git push fails
386. User B: git pull fails as well
387. Merge conflict details
388. Struggling for resolution
389. Merging Print.java manually
390. Commit and push merge
391. Superclass Object
392. String literals
393. OpenJDK String implementation
394. String copy constructor
395. Copy constructor and heap
396. Operator == and equals()
397. Remarks == vs. equals()
398. Hashing principle
399. Quickly identify by “simple” value
400. Hashing in Java and equals()
401. Rectangle equals(...) and hashCode()
402. Rectangle hash values
403. Better hashCode() method
404. Math.sin(double x)
405. Motivating Arrays
406. Per member repeating tasks
407. Example: int array of primes
408. Loop prime values
409. Mind the limit!
410. Safer: Using length
411. Even better: “for-each” style loop
412. Mind the limit, part two
413. One step initialization
414. Array
415. Two syntax variants
416. Array instances are special!
417. Array creation details
418. Array parameter passing
419. Parameter passing details
420. Value and reference types
421. Arrays.toString(...) and Arrays.sort(...)
422. Arrays.binarySearch(...)
423. Arrays.fill(...)
424. Arrays.copyOfRange(...)
425. Arrays.equals(...)
426. Lack of extendability
427. Extending an array
428. Extension result
429. Using Arrays.copyOf()
430. public static void main(String[] args)
431. Intellij IDEA run configuration
432. Intellij IDEA run configuration
433. Creating executable jar
434. Two-dimensional arrays
435. Behind the scenes
436. Memory allocation
437. Static array initialization
438. Static array initialization, variable lengths
439. Two Tic-tac-toe players fighting each other.
440. Two Tic-tac-toe players fighting each other.
441. Guess who's inheriting the money
442. Biology and inheritance
443. Duplicate code
444. Idea: Centralize common code
445. Common and specific properties
446. Basic shape inheritance
447. Inheritance
448. Implementing Shape hierarchy
449. Creating instances
450. Shape constructor
451. Creating Rectangle instances
452. Rectangle constructor
453. Shape.equals()
454. Rectangle.equals()
455. Shape log info
456. Overwriting toString()
457. Shape extending Object
458. Logging Rectangle instances
459. Override toString() again.
460. Rectangle extending Shape
461. Implementing Circle.toString()
462. Shape and toString()
463. Moving Shape instances
464. Implementing Shape movements
465. Fools are everywhere!
466. Solution: final prevents overriding
467. Calculating a shape's area
468. Desired: Polymorphic getArea() call
469. Problems:
470. abstract method getArea()
471. abstract method getArea()
472. What's a “shape” anyway?
473. No instances of abstract classes.
474. Mandatory getArea() implementation.
475. Facts about abstract fields, methods and classes.
476. Moving shapes
477. protected access
478. final classes
479. final classes rationale
480. “Defeating” polymorphism
481. Defining equals(...): Expectations
482. Defining equals(...) of Shape instances
483. Comparing center coordinates
484. Implementing Rectangle.equals()
485. Implementing Circle.equals()
486. Testing equality of Shape objects
487. Overriding Object.toString()
488. @Override: Easy compile time error detection
489. Compile- and runtime errors
490. NullPointerException (NPE for short)
491. NullPointerException is a class
492. Throwing an exception
493. Catching an exception by try {...} catch {...}
494. try {...} catch {...} syntax
495. Checked and unchecked exceptions
496. Checked and unchecked exceptions
497. Expected exceptions in Junit
498. Just finally, no catch
499. try-with-resources (Java™ 7)
500. Scanner implementing AutoCloseable
501. No close() method in e.g. class String
502. Method printStackTrace()
503. Ascending inheritance ordering
504. Descending inheritance ordering
505. Implementing convert
506. Problem: “Silent” errors
507. Step 1: Find exception base class
508. Step 2: Derive CardinalException
509. Step 3: Throwing CardinalException
510. Step 4: Unit test throwing CardinalException
511. Stack of integer values
512. Java™ collection features
513. Behind the scenes
514. Boxing and unboxing
515. Boxing syntax comparison
516. Parsing Integer user input
517. Parsing binary representation
518. Standard parse methods
519. Excerpt from java.util.Locale
520. Locale properties
521. Get a NumberFormat instance
522. Create a custom formatter
523. Polymorphic number parsing
524. Limited float precision
525. Limited double precision
526. Using BigDecimal
527. Chaining BigDecimal operations
528. BigDecimal features
529. Using static double random()
530. Seeding a pseudo random generator
531. Interface examples
532. Observations
533. Writing strings to file
534. Using Text2File
535. Possible Text2File errors:
536. Employ “try-with-resources”
537. interface syntax
538. The AutoCloseable promise
539. abstract class replacement
540. interface vs. abstract class
541. interface MyAutoCloseable
542. Extending MyAutoCloseable to flush
543. Using MyFlushable
544. Inheritance hierarchy
545. Upcoming topics
546. Interfaces implemented by class String
547. The Comparable interface
548. class String and Comparable
549. Comparison examples
550. Ascending and descending names
551. API requirements
552. Sorting strings alphabetically
553. Situation dependent sorting criteria
554. Implementing flexible sorting
555. Comparator in action
556. Case insensitive sort
557. Sort descending by lambda expression
558. What's the use of hashing anyway?
559. Account hierarchy
560. Students and lecturers
561. An array of strings
562. An associative array describing month lengths
563. Grouping towns by country names
564. Exam training by Guacamole
565. Environment hints:
566. Preparing an examination
567. Generating Javadoc™.
568. Programming hints
569. The implement - test - implement cycle
570. Finishing the exam
571. Personal examination cheat sheets
572. Unit tests in examinations
573. Example interface definition
574. Corresponding test
575. Don't cheat!
576. Unit tests strategy in examinations
577. Collaborative efforts
578. Project rules
579. Internal code documentation
580. Internal code documentation hints
581. Javadoc™ mismatches
582. (Automated) tests
583. Deployment and execution
584. Marking criteria
585. Sample forecast session
586. Sample forecast invocation
587. Underlying data provider
588. cities.list.json.gz providing cities
589. ma/Copy URL result to file
590. Parse city data
591. Parse weather data
592. Requirements
593. Logging
594. Minimalist token scanner
595. Scanner output -1.34 0.34 + sqrt
596. Adding error detection
597. Error message
598. Running the currency converter terminal application.
599. Steps creating a new project
600. Creating a project at MI gitlab
601. Cloning a git project
602. Enter project folder, add Readme.md
603. Committing change set
604. Push to upstream repository
605. Inserting a Maven project
606. git status 1
607. Adding Maven files to repository
608. git status 2
609. Commit Maven project files
610. git status 3
611. Push to upstream again
612. Reverting changes
613. Pull changes from upstream
614. Maven: Recommended reading
615. What is Maven anyway?
616. Maven: Facts and benefits
617. Convention Over Configuration
618. Maven project layout
619. The project object model file
620. pom.xml characteristics
621. pom.xml vs. Makefile
622. «Hello, world» pom.xml
623. Executing «compile» phase
624. Examining the Java™ version culprit
625. Resolving encoding / Java™ version issues
626. POM inheritance
627. The Super POM
628. pom-4.0.0.xml content
629. Favour https in ~/.m2/settings.xml
630. Resolving to effective pom.xml
631. Plugin architecture
632. Sample plugins
633. Example: The maven-javadoc-plugin
634. Adding test capabilities
635. Dependency listing
636. Absence of hamcrest in pom.xml
637. ~/.m2/repository/junit/junit/4.12/junit-4.12.pom
638. Transitive dependencies
639. Oblivious to test implementation: TestNG
640. Phases
641. Maven lifecyles and phases
642. hooking into phase
643. Why XML based publishing?
644. XML features
645. Editors, compositors, designers ...
646. Promises in publishing
647. Publishing reality
648. Single source publishing
649. Separating Structure, content and format
650. Separating concerns
651. Content
652. Hierarchical structure
653. Hierarchical structure, XML source
654. Presentation
655. Example 1: HTML 5, pure structure
656. Example 2: TeX / LaTeX
657. Separating structure and presentation(s)
658. Sample technical document
659. Observations
660. Pros and cons of TeX / LaTeX
661. Tools of the trade
662. Inline formatting
663. Paragraphs
664. Lists
665. Tables
666. Images
667. Mathematical formulas
668. Cross references
669. Document sectioning
670. Modular document components
671. What is Docbook?
672. Authoring and publishing
673. Document representation
674. Software centric schema
675. Document targets
676. Docbook components
677. Target format overview
678. Tooling / Software
679. Different schema languages
680. Plain HTML
681. Web help
682. Eclipse help
683. Printed output
684. Paragraph
685. Itemized list
686. Ordered list
687. Glossary list
688. Nested lists
689. Reference
690. A table
691. A MathML equation
692. A TeX equation
693. Reference
694. Figure
695. Image map + calloutlist
696. Video
697. A warning
698. Reference
699. Recursive sections
700. Non-recursive sections
701. Two different link flavours
702. Choosing a top level element
703. Allowed 5.1 top level elements
704. Schematron on top of RelaxNG
705. Example: xml:id and permalink
706. Using Display #Anchors
707. Considerations author based permalink
708. Schematron permalink rule
709. HTML customization overview
710. Target specific configuration
711. Link stability
712. use.id.as.filename = 1
713. Parameter: use.id.as.filename
714. Customization parameter ulink.target
715. callout.unicode / callout.graphics
716. Links
717. Hooking into XSL
718. Categories
719. Example: videos
720. Links
721. Customize by CSS
722. Example CSS modifications
723. Styling the editor
724. Motivating modular documents
725. Monolithic document problems
726. Document decomposition
727. A monolithic document
728. Decomposing documents
729. XML grammar defining languages
730. Address list schema
731. Format conversion problem
732. XSL template rules
733. Example: Formatting <title> elements
734. Basic FO introduction
735. XMLMind Editor
736. Oxygenxml Author
737. Vendor links
738. Inverse editing
739. Document representation
740. Components
741. BibTeX
742. Makeindex example
743. Makeindex work flow
744. Extension example: MusiXTeX
745. Flavours
746. Components
747. Editors
748. reveal.js authoring tools: Principle
749. reveal.js features #1 of 3
750. reveal.js features #2 of 3
751. reveal.js features #3 of 3
752. reveal.js observations
753. Authoring tool project goals
754. Principle
755. Codingbat: Desired features
756. Desired features
757. Example BiBTeX data
758. BiBTeX: Tasks
759. CRUD operation
760. Query
761. Schema
762. Procedures / triggers
763. Transactions / recovery
764. Data access control
765. API support
766. Installing Docker
767. Why LDAP?
768. LDAP introduction
769. Running a Docker container
770. Using docker-compose
771. Installing Apache Directory Studio
772. Administrator access to your DIT
773. Administrator access to your server's data tree
774. Administrator access to your server's configuration
775. Terminology
776. Adding an entry
777. Adding a new attribute
778. Replacing an attribute value
779. Deleting an attribute entirely
780. Multi valued attributes
781. Set semantics of multivalued attributes
782. Deleting selected attribute values
783. Query scope
784. Query filter
785. Schema support
786. Implementations
787. Implementations
788. Exercises
789. Why MongoDB?
790. Running a Docker container
791. Using docker-compose
792. Manual user creation (mongo-init.js fail)
793. Log in as user explorer
794. Using IntelliJ
795. Idea show all databases
796. Terminology / Hierarchy
797. Adding a document
798. Updating attributes
799. Deleting a document
800. Deleting multiple documents
801. Multi valued attributes
802. Set semantics of multivalued attributes
803. Deleting selected attribute values
804. Deleting an attribute
805. Query filter
806. Schema validation support
807. Violating required field
808. Schema types
809. Enforcing unique keys
810. On the downside
811. Implementations
812. Implementations
813. Sharding rationale
814. Sharding rationale
815. Exercises
816. Prerequisite knowledge
817. Persistence [Bauer2015]
818. Java™ transient instances
819. RDBMS persistent records
820. Persisting transient User instances
821. Observations
822. Networking between clients and database server
823. JDBC™ features
824. JDBC™ in a three-tier application
825. JDBC™ connecting application server and database.
826. JDBC™ connection parameter
827. Components of a JDBC™ URL
828. IETF Uniform Resource Identifier
829. URL examples
830. Sub protocol examples
831. No standard port assignments ...
832. ... but Postgresql made it into Linux
833. JDBC™ architecture
834. DriverManager: Bootstrapping connections
835. Example: Mysql connection implementation
836. Driver libraries
837. Driver libraries by Maven
838. Driver unavailable
839. Connection interface
840. Statement interface
841. JDBC™ instances and relationships.
842. Important Connection methods
843. Important Statement methods
844. JDBC™ and threading.
845. JDBC™ connection pooling
846. pom.xml driver runtime scope
847. Person table
848. Objective: insert person record
849. JDBC™ backed data insert
850. Result
851. Two JDBC™ configurations
852. Figure 849, “JDBC™ backed data insert ” deficiencies
853. Why properties?
854. message.properties string externalization
855. Properties code sketch
856. Intellij IDEA settings, preconditions
857. Database related unit test phases
858. Implementing unit tests
859. Spring is your friend
860. Project layout
861. Closing connections
862. Employ AutoCloseable
863. Sniffing a JDBC™ connection by an intruder.
864. Setting up Wireshark
865. Capturing results
866. Mysql™ security
867. Mysql™ security
868. Assembling SQL
869. SQL injection principle
870. Preventing traffic tickets
871. Trouble at school
872. SQL injection impact
873. SQL injection relevance, [Clarke2009]
874. Handling injection attacks, part 1
875. Handling injection attacks, part 2
876. Input filtering
877. Validating user input prior to dynamically composing SQL statements.
878. Error message being presented to the user.
879. SQL statements in Java™ applications get parsed at the database server
880. Two questions
881. Addressing performance
882. Addressing performance mitigation
883. Restating the SQL injection problem
884. Solution: Use java.sql.PreparedStatement
885. PreparedStatement principle.
886. Three phases using parameterized queries
887. PreparedStatement example
888. Injection attempt example
889. Limitation: No dynamic table support!
890. JDBC™ read and write
891. Server / client object's life cycle
892. JDBC™ record container
893. Reading data from a database server.
894. Names and birth dates of friends
895. Accessing friend's database records
896. Important ResultSet states
897. JDBC™ to Java™ type conversions
898. Java™ to JDBC™ type conversions
899. Error prone type accessors!
900. Polymorphic accessor
901. Access by column name
902. Access by column index
903. Problem: null value ambiguity
904. Resolving null value ambiguity
905. Users and groups
906. Isolation level
907. JDBC™ Isolation level
908. Setting the isolation level
909. Reasons for using Maven
910. Transitive dependencies
911. A basic persistence.xml JPA configuration file.
912. JPA persistence provider
913. Mapping hibintro.v1.model.User instances to a database.
914. A basic User class.
915. Mapping properties to attributes.
916. Annotating integrity constraints
917. Database schema mapping instances of hibintro.v1.model.User.
918. Loading a single object by a primary key value.
919. Retrieving hibintro.v1.model.User instances by HQL.
920. Business rules for projects
921. Persistence related object states
922. Introducing inheritance mapping
923. Modelling payment.
924. A single relation mapping.
925. Mapping the inheritance hierarchy.
926. Inserting payment information
927. Figure subclasses
928. Joined subclass mapping.
929. Implementing Object.equals(Object) by natural keys
930. JPA caches.
931. Shell / Bash
932. Secure Shell
933. Working with files
934. Gathering network related information
935. Handle processes
936. vim text editor introduction
937. Creating a ssh public/private key pair
938. Configuration file permissions on windows network file systems
939. Resulting permissions and configuration test
940. Suggested readings:
941. .deb packages
942. The dpkg command
943. The apt command
944. Rationale using PPA's
945. Result of ssh-keygen execution
946. Extended ACLs, ways too open
947. Revoking permissions using setfacl
948. Corrected permissions
949. Logging in
950. Documentation links
951. DNS query commands
952. DNS forward lookup
953. Display A-record result only
954. Important record types
955. Name Servers: Query type NS
956. Recommended readings
957. Openldap server documentation
958. What is LDAP anyway?
959. LDAP Server cli bind
960. Document Information Tree (DIT)
961. Relative and absolute DNs
962. User example
963. objectClass
964. objectClass clarifications
965. Augmenting inetOrgPerson by posixAccount
966. Structural objectClass definitions
967. Search scopes
968. Predicate based queries
969. LDAP bind types
970. LDIF exchange format
971. LDIF sample
972. OpenLdap server architecture
973. An example LDAP Tree
974. External documentation
975. URI to filesystem mapping
976. Virtual hosting
977. Implementing virtual hosting
978. IP based virtual hosting
979. IP based, pros / cons
980. Name based virtual hosting
981. Name based, pros / cons
982. LDAP backed authentication
983. PHP FPM server
984. File services
985. Customer demands
986. Driving factors
987. Selected cloud file services
988. Selected self hosting products
989. Nextcloud features
990. Lightning integration
991. Installation
992. Docker hub
993. Search images
994. Pull image using CLI
995. Pull Nextcloud image
996. Nextcloud based on Alpine
997. Inspect image
998. Search an image's tags
999. Nextcloud image by version
1000. List images by CLI
1001. Nextcloud latest image
1002. Duplicate Nextcloud images
1003. Maven ringing a bell?
1004. Un tag image by version
1005. Remove image by version
1006. Starting Nextcloud container
1007. List running containers
1008. Enter running container
1009. Remove container
1010. List volumes
1011. List orphaned volumes
1012. Remove volumes

List of Tables

1. 4 Byte Two's complement representation of int values.
2. Exercises in 113105 Software development 1
3. Exercises in Technical Documentation
4. Exercises in 113473 Database and application development
5. 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