Lecture notes

Martin Goik

Stuttgart Media University / MI

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