Lecture notes

Martin Goik

Stuttgart Media University / MI

	Available formats:	Webhelp (this document) Zip archive for offline usage EPUB PDF
	Available at:	Hosted at HdM Hosted at BWCloud
	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 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

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
Project dependencies and Maven
Building a library of mathematical functions.

Unit testing

Tests and implementation
Improving the algorithm
Helpful Junit methods
Technical details
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

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

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

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