Lecture notes

Martin Goik

Stuttgart Media University / MI

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

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

Building a reveal.js editor
Authoring journey descriptions
Gitlab pages integration of Docbook
Codingbat reloaded
XML based exercise compilations
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
SDI exercises related DNS server

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