Lecture notes

Martin Goik

Stuttgart Media University / MI

Table of Contents
Preface
Software development 1
Getting started
Lecture related resources
Using the exercises
Common software development related resources
Supervised tutorials
Tools of the trade, part 1
Play!
“Hello, World” and friends.
Simple calculations
A conditional
A loop
Tools of the trade, part 2
Maven command line usage
Maven and Intellij IDEA
Examination Maven Intellij IDEA import.
Maven and Eclipse
Language Fundamentals
Integer, ASCII and Unicode
Variables
Literals
Arithmetic limitations
Conversions
Operators and expressions
Comments
Statements
The if conditional statement
The switch statement
Loops
while
do ... while
for
Logic related external exercises
Objects and Classes
Working with objects
Packages
Object methods
Encapsulation and access control
Getter and setter methods
Signatures
Method overloading
Constructors
Scopes
Static Members
A mathematical table.
Interest calculations
Lotteries revisited
The greatest common divisor and the common multiple
Project dependencies and Maven
Cancelling fractions
Building a library of mathematical functions.
Value types and reference types
Method calls, the details
Unit testing
Core Classes
Reconsidering System.out.format().
Using class Math
String exercises
Analyzing file pathnames
Arrays
java.util.Arrays helpers
Extending an array
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 toString()
final methods
Abstract methods
Geometry classes reconsidered
protected access
final classes
The instanceof operator
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
A nonsense generator
An interface based plotter
Application deployment I (8.12.)
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
Recommended external exercises
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
List of Exercises
Exercises in Getting started
Exercises in Language Fundamentals
Exercises in Statements
Exercises in Objects and Classes
Exercises in Core Classes
Exercises in Arrays
Exercises in Inheritance
Exercises in Error Handling
Exercises in Working with Numbers
Exercises in interface definitions and abstract Classes
Exercises in Application deployment I (8.12.)
Exercises in Reading character streams
Exercises in Collections
Structured Data and Applications 1
Prerequisites
Lecture related resources
Tools
JDK and IntelliJ IDEA
Oxygenxml standalone version
Mysql Database components
SQL client software
A relational recap exercise
Introduction to XML
The XML industry standard
Well formed XML documents
Beyond well- formedness
Motivation
XML Schema
Structural descriptions for documents
Element definitions
Attribute definitions
XPath and node sets
Uniqueness Constraints
Referencing constraints
Best practices
Dealing with <memo> documents
Relating schema's and SQL - DDL
The airline example revisited
Relating schema's and Java™ class descriptions.
XML schema exercises
DOM
Language independence
New document
Exercises
Parsing
Simple DOM processing
Visualizing XML document elements
Reminder to functional programming elements in Java™.
Creating HTML output
Cleaning up HTML.
Using DOM with HTML/Javascript
DOM and XPath
DOM and XSL
Namespace / elements statistics
Accessing Relational Data
Persistence in Object Oriented languages
Introduction to JDBC™
Write access, principles
Write access, coding!
JDBC™ and security
Read Access
Handling surrogate keys
Transactions
Getting started with JPA
Notes on tooling
A round trip working with objects
Mapping OO domain model to database model
Inserting objects
Retrieving objects
Updating objects
Querydsl
JPQL
Criteria queries
Querydsl
Enhancing the model
Persisting lecture instances
Exporting XML catalog data using JPA.
MongoDB
Prerequisites
Mongo Shell CRUD operations
Appendix
Examination amending projects
Marking criteria / Hints
Exporting and importing relational data
Project Docbook CMS.
Project business cards
Using Vaadin
Configuring Maven.
Properties, editors and listeners
A first GUI sketch
Input validation and error handling
Decoupling GUI and database components
User initiated connect to database.
A user authentication “strategy”
Passwords and hash values
Gui authentication: The real McCoy
Architectural security considerations
The Extensible Stylesheet Language XSL
Required knowledge
A “Hello, world” XSL example
Example: memo recipients
Some important XSL elements
A complete HTML formatting example
Transforming arbitrary XML to XHTML
XML APIs, the Simple API for XML (SAX)
Recommended reading
The principle of a SAX application
First steps
Event- and error handler registration
SAX validation
Namespaces
Print
online / print
Simple FO
Page layout
Header/footer
Important Objects
FO from XML
A catalog
List of Exercises
Exercises in Prerequisites
Exercises in Introduction to XML
Exercises in Beyond well- formedness
Exercises in The Document Object Model (DOM)
Exercises in Accessing Relational Data
Exercises in Getting started with JPA
Exercises in MongoDB
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
Past projects
List of Exercises
Exercises in Software independent considerations
Exercises in Exercises
Structured Data and Applications 2
ldap and JDBC
Getting started with LDAP
Setting up an Openldap server
Adding some sample data using Apache Directory Studio
LDIF export and import
Searching the DIT
UNIX to SQL to LDAP
Transactions in JDBC™
Account Transfer using pessimistic concurrency control
Account Transfer using optimistic concurrency control
JPA
Configuring a Maven based Eclipse Java™ project with Hibernate
Create a Maven based project in Eclipse
Adding a Mysql™ JDBC™ driver
Adding Hibernate dependencies
Creating a JPA configuration
A round trip working with objects
Persisting objects
Loading Objects by primary key
Loading objects by queries
Criteria based queries
Mapping single entities and database tables
Transient properties
Properties and NULL values
Defining keys
Composed keys
Indexes (non-unique)
Renaming tables and attributes
Changing the default type mapping
Object states and transitions
XML to JPA using JAXB
Inheritance
Single table per class hierarchy
Joined subclasses
Table per concrete class
Mapping related Components and entities
Primary keys revisited
Entity and value types
Mapping components
Caching
orphanRemoval vs. CascadeType.DELETE
REST applications based on Java™-rs
List of Exercises
Exercises in ldap and JDBC
Exercises in JPA
Software defined infrastructure
UNIX / LINUX Basics
Prerequisites
Ubuntu / Debian Package management
Prerequisites
Getting started
Accessing your virtual machine
DNS
Preliminaries
Exercises
Installing Bind
Basic configuration
Forwarders
Mail exchange record
LDAP
Recommended Preparations
Exercises
Browse an existing LDAP Server
Set up an OpenLdap server
Populating your DIT.
Testing a bind operation as non - admin user
Accessing LDAP data by a mail client
LDAP configuration
Filter based search
Extending an existing entry
Backup and recovery / restore
Replication
LDAP based user login
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
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
Systems surveillance
Working with Nagios
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
Exercises in Selected topics related to persistence in application development
Bibliographic links
Glossary
List of Figures
1. Recommended reading resources
2. Online Java™ programming tutorial
3. Unix and the terminal
4. Online programming, automated feedback
5. Java Visualizer
6. Live lecture additions
7. Intellij IDEA IDE
8. Virtualbox™ image / native (dual boot) installation
9. Alternatives using Linux
10. Exercise features
11. Using the exercises
12. Programming projects in examinations
13. Download zipped Maven project
14. Select project archive
15. Locate archive and hit »Open With Archive Manager...«
16. Extract Exam folder
17. Folder to be imported in next step
18. Start project import
19. Select previously extracted Folder
20. Select Maven project model
21. Accept “Enable Auto-import”
22. Optional: Show packages
23. Execute complete test class
24. Results yet negative
25. Set breakpoint in method.
26. Debug individual test method
27. Step through hunting for errors
28. Show overall results
29. Hit Run 'ShowReachedPoints'
30. Your results so far
31. Zip up your project into an archive
32. Choose an archive name
33. Newly created archive
34. Hit »Choose File« in ILIAS
35. Hit »Upload«
36. Archive is visible ...
37. ... but not yet saved!
38. Confirm saving / next exercise
39. Answer saved!
40. Finish your examination
41. Check your answers again!
42. Proceed finishing ...
43. Finish the test
44. The codingbat sleepIn example.
45. Cash register
46. Zuse Z3
47. Eniac
48. Microprocessor ICs
49. Zilog Z80 CPU
50. Address and data bus sizes
51. Signed 3 bit integer representation
52. Signed 8 bit integer binary representation
53. 7-bit ASCII
54. 7-bit ASCII with even parity bit
55. ISO Latin 1 encoding
56. Some Unicode UTF-8 samples
57. Handle to memory
58. Variable declaration
59. Declare and use
60. Declaration and initialization
61. Multiple variables of same type
62. Variable naming conventions
63. Constants
64. Variable names (identifier)
65. Java™ keywords.
66. Case sensitivity
67. Define before use
68. Type safety
69. Compile time analysis
70. Forcing conversions
71. Watch out!
72. C: Don't worry, be happy ...
73. ... and watch the outcome
74. From the report
75. Maximum and minimum values
76. Dynamic typing in PERL
77. Using final
78. Two categories of variables
79. Reference type examples
80. float and double
81. Four ways representing 35
82. Know your limits!
83. Literal examples
84. int literals
85. int literals explained
86. Java™ literals
87. Just kidding ...
88. Strange things
89. Overflow
90. Limited precision
91. FloatConverter
92. Widening from byte to short
93. Narrowing from int to char
94. The binary plus operator
95. Binary operator output type
96. Arithmetic overflow pitfalls
97. Detecting arithmetic overflow (Java 8+)
98. Dividing by zero
99. Operator type behaviour
100. Binary operator type examples
101. Operator examples
102. Two comment flavors
103. “Inline” comments
104. Purposes of statements
105. General Syntax
106. Example: Declaring and assigning variables
107. Expression vs. statement
108. Multiple statements per line
109. Debugging multiple statements per line
110. Blocks
111. if block execution selection
112. if execution syntax
113. if ... else block execution selection
114. if ... else execution syntax
115. Best practices comparing for equality
116. Single statement branches
117. Corporate network security
118. Online banking
119. IP Spoofing
120. SSL Certificate error
121. The Apple “goto fail” SSL bug
122. Static code analysis
123. Nested if ... else
124. if ... else if ... else
125. if ... else if ... else syntax
126. User input recipe
127. Using a Scanner class collecting user input.
128. Converting numbers to day's names
129. Implementing day's number to name
130. Better: Using switch
131. switch Syntax
132. Switching on strings
133. Why loops?
134. Hard to parameterize
135. A while loop
136. Combining increment and termination condition
137. while syntax
138. Empty while body
139. A do ... while loop
140. do ... while syntax
141. Frequent usage of while
142. Replacing while by for
143. for syntax
144. for variable scope
145. for variable scope equivalence
146. for vs. while relationship
147. Nested loops
148. Calculating values
149. Instances of a Class
150. General class structure
151. What's a class anyway?
152. Rectangle objects
153. A class describing rectangles
154. Rectangle class and instances
155. Generated diagrams
156. Creating rectangle instances
157. Syntax creating instances
158. Assigning attribute values
159. Memory representation
160. References and null
161. References and null
162. Packages
163. Rules and conventions
164. Qualified name vs. import
165. Don't be too lazy!
166. Classes from java.lang
167. Class, package and file system
168. Source hierarchy view
169. Object methods
170. Scaling a rectangle
171. Scaling implementation
172. Using scale(...)
173. Method definition syntax
174. A rectangle's perimeter
175. Get perimeter implementation
176. Using Rectangle.getPerimeter()
177. Access control: Overall objectives
178. Example: Implementing time and date
179. Access violation
180. Access rules
181. “Tips on Choosing an Access Level”
182. Direct access vs. setter method
183. Why adding setter methods?
184. Implementation by minutes only
185. Package hierarchy of the employee example
186. Type signatures
187. Defining type signatures
188. A method signature
189. What is overloading?
190. Overloading, alternate names
191. No such concept in C
192. What about return type?
193. Method signatures rationale
194. Method signatures rationale
195. Example: System.out.print(...)
196. Creating and initializing rectangles
197. Defining a constructor
198. Constructor syntax
199. Constructors
200. Multiple constructors by overloading
201. Constructor calls within constructor
202. Instances by overloaded constructors
203. No constructor vs. default constructor
204. Absent default constructor
205. Circle and variable scopes
206. Documenting class and methods
207. Generated Javadoc
208. Refactoring »r« ⇒ »radius«
209. Scope assignment problem
210. this overriding method scope
211. Club membership objectives
212. Implementing membership numbers.
213. Showing membership numbers.
214. Access to the club's overall member count?
215. Accessing the club's member count
216. Do we require an instance?
217. Favour class method over instance method
218. Syntax accessing class members
219. Newton's letter to Robert Hooke
220. Project »lottery« depending on »helper«
221. Providing project »helper«
222. Install project »Helper«
223. helper-0.9.jar archive content
224. Consuming project »Lottery«
225. External libraries view
226. Using Helper.factorial(...)
227. Maven repositories
228. Defining a dependency to another Maven artifact.
229. Pascal's triangle representing binomial coefficients.
230. An implementation sketch for the exponential
231. Comparing exponential and approximation
232. Comparing sin(x) and its approximation.
233. Value vs. reference types
234. Example
235. Value variable Details
236. Reference variable Details
237. Only »call-by-value« in Java™
238. »call-by-value« details
239. »call-by-reference« for objects?
240. »call-by-reference« details
241. No »call-by-reference« in Java™
242. No »call-by-reference« details
243. C++ offers “true” »call-by-reference«
244. C++ »call-by-reference« details
245. Method calling
246. Three variable scopes
247. Scope lifetimes
248. Two runtime memory categories
249. Stack: Four operations
250. Example: Storing integer values
251. Method calling
252. Call stack trace
253. IDE debugger
254. Recommended reading
255. Test categories
256. Example: Prime numbers
257. Test driven development
258. Junit
259. Steps in Unit Testing
260. Step 1 + 2: Specify method, write skeleton
261. Execution yet flawed
262. Sample test data
263. Step 3: Junit based specification test
264. Junit skeleton test result
265. Junit skeleton test result
266. Step 3: More prime tests
267. Step 3: Prime mass testing
268. Step 4: Implement skeleton
269. Step 5: Testing our first implementation
270. Implementation observation
271. Changing the implementation
272. Regression test
273. Correcting the implementation
274. 2-nd regression test
275. Available comparison methods
276. Caution comparing float / double
277. Weird arithmetics?
278. Limited representation precision
279. Solving the issue
280. Superclass Object
281. String literals
282. OpenJDK String implementation
283. String copy constructor
284. Copy constructor and heap
285. Operator == and equals()
286. Hashing principle
287. Rectangle equals(...) and hashCode()
288. Rectangle hash values
289. Rectangle equals(...) and hashCode()
290. Contract equals(...) and hashCode()
291. Motivating Arrays
292. Per member repeating tasks
293. Example: int array of primes
294. Loop prime values
295. Mind the limit!
296. Safer: Using length
297. Safer: Use “for-each” style loop
298. Mind the limit, part two
299. One step initialization
300. Array
301. Two syntax variants
302. Array instances are special!
303. Array creation details
304. Array parameter passing
305. Parameter passing details
306. Value and reference types
307. Arrays.toString(...) and Arrays.sort(...)
308. Arrays.binarySearch(...)
309. Arrays.fill(...)
310. Arrays.copyOfRange(...)
311. Arrays.equals(...)
312. Extension problem
313. Extending an array
314. Extension result
315. Using Arrays.copyOf()
316. public static void main(String[] args)
317. Intellij IDEA run configuration
318. Intellij IDEA run configuration
319. Creating executable jar
320. Multidimensional arrays
321. Behind the scenes
322. Memory allocation
323. Two Tic-tac-toe players fighting each other.
324. Two Tic-tac-toe players fighting each other.
325. Guess who's inheriting the money
326. Biology and inheritance
327. Duplicate code
328. Idea: Centralize common code
329. Common and specific properties
330. Basic shape inheritance
331. Inheritance
332. Implementing Shape hierarchy
333. Creating instances
334. Shape constructor
335. Shape log info
336. Overwriting toString()
337. Shape extending Object
338. Creating Rectangle instances
339. Rectangle constructor
340. Logging Rectangle instances
341. Override toString() again.
342. Rectangle extending Shape´
343. Implementing Circle
344. Shape and toString()
345. Moving Shape instances
346. Implementing Shape movements
347. Fools are everywhere!
348. Solution: final prevents overriding
349. Calculating a shape's area
350. Desired: Polymorphic getArea() call
351. Problems:
352. abstract method getArea()
353. abstract method getArea()
354. What's a “shape” anyway?
355. No instances of abstract classes.
356. Mandatory getArea() implementation.
357. Facts about abstract fields, methods and classes.
358. Moving shapes
359. protected access
360. final classes
361. final classes, rationale
362. “Defeating” polymorphism
363. Defining equals(...) of Shape instances
364. Comparing center coordinates
365. Implementing Rectangle.equals()
366. Implementing Circle.equals()
367. Testing equality of Shape objects
368. Compile- and runtime errors
369. NullPointerException (NPE for short)
370. NullPointerException is a class
371. Throwing an exception
372. Catching an exception by try {...} catch {...}
373. try {...} catch {...} syntax
374. Checked and unchecked exceptions
375. Checked and unchecked exceptions
376. Expected exceptions in Junit
377. Just finally
378. try-with-resources (Java™ 7)
379. Method printStackTrace()
380. Ascending inheritance ordering
381. Descending inheritance ordering
382. Implementing convert
383. Problem: “Silent” errors
384. Step 1: Find exception base class
385. Step 2: Derive CardinalException
386. Step 3: Throwing CardinalException
387. Step 4: Unit test throwing CardinalException
388. Stack of integer values
389. Java™ collection features
390. Behind the scenes
391. Boxing and unboxing
392. Boxing syntax comparison
393. Parsing Integer user input
394. Parsing binary representation
395. Standard parse methods
396. Excerpt from java.util.Locale
397. Locale properties
398. Get a NumberFormat instance
399. Create a custom formatter
400. Polymorphic number parsing
401. Limited float precision
402. Limited double precision
403. Using BigDecimal
404. BigDecimal features
405. Using static double random​()
406. Seeding a pseudo random generator
407. Interface examples
408. Observations
409. Writing strings to file
410. Using Text2File
411. Possible Text2File errors:
412. Employ “try-with-resources”
413. interface syntax
414. The AutoCloseable promise
415. abstract class replacement
416. interface vs. abstract class
417. interface MyAutoCloseable
418. Extending MyAutoCloseable
419. Using MyFlushable
420. Inheritance hierarchy
421. Upcoming topics
422. What's the use of hashing anyway?
423. Account hierarchy
424. Students and lecturers
425. An array of strings
426. An associative array describing month lengths
427. Grouping towns by country names
428. Unit tests in examinations
429. Example interface definition
430. Corresponding test
431. Unit tests strategy in examinations
432. Bonus points
433. Collaborative efforts
434. Project rules
435. Internal code documentation
436. Internal code documentation hints
437. Javadoc™ mismatches
438. (Automated) tests
439. Deployment and execution
440. Marking criteria
441. Sample forecast session
442. Sample forecast invocation
443. Underlying data provider
444. cities.list.json.gz providing cities
445. ma/Copy URL result to file
446. Parse city data
447. Parse weather data
448. Requirements
449. Logging
450. Minimalist token scanner
451. Scanner output -1.34 0.34 + sqrt
452. Adding error detection
453. Error message
454. Running the currency converter terminal application.
455. Recommended reading
456. What is XML?
457. Application domains
458. Benefits
459. Relevance (2018/02)
460. JSON catches up!
461. Rendering (X)HTML markup
462. HTML tree structure
463. MathML formula
464. MathML tree graph representation
465. HTML / MathML document similarities
466. XML files: Representing data
467. Representing CAD data
468. XML basic structure
469. Minimal XML document
470. Empty tags
471. Representing messages.
472. MI department CLI parser
473. Non-wellformed, missing </from>
474. Parsing non-wellformed
475. Improperly nested elements
476. Improperly nested elements: Result
477. Proper nesting of XML elements
478. Improperly nested elements
479. date and priority attributes.
480. Unique attribute names
481. Quotes required
482. Important well-formedness constraints
483. XML markup collision I
484. XML markup collision II
485. XML standard replacement entities
486. Using CDATA sections
487. Using replacement entities
488. Processing instruction (PI)
489. Recommended reading
490. XML and application code
491. HTML validity
492. Well-formed and valid
493. XML grammar examples
494. A <contact> record
495. <contact> business rules:
496. <contact> EBNF grammar
497. Initial organizer schema
498. Linking instance to schema
499. Centralized schema definition
500. Validating a contact
501. Uups, we fail!
502. Schema observations
503. Well-formed and valid documents
504. Terminology
505. V02: Define <email> as optional
506. V03: Multiple contacts
507. Choose <contact> as root
508. Graphical schema representation
509. Adding <birthDate>
510. Supply a <birthDate> type
511. Why <birthDate> element?
512. Using a birthDate attribute
513. Absent birthDate attribute
514. XSD attributes revisited
515. Consider <email>
516. User defined email type
517. Using new email type
518. Strange: The Ur type
519. Adding missing data types
520. Nested elements becoming invalid
521. Introducing categories
522. Category type violation
523. Ooops: Text content and attributes
524. SQL query result
525. Comparing SQL and XPath
526. Similarities and differences
527. Simple XPath queries
528. Relative file system search using find
529. find starting from absolute path
530. XPath and context nodes
531. Union
532. Union / descent
533. Recursive search for element name
534. Recursive + index search
535. Surprise!
536. Siblings
537. Following siblings
538. Disjoint XPath axis definitions.
539. Element restricted following siblings
540. Elements containing non-whitespace text
541. Elements containing text containing 'house'
542. Elements containing text of minimal length
543. Searching for attribute presence
544. Searching for attribute value
545. Introducing nicknames
546. Nickname semantics
547. <xs:unique>
548. Introducing id values
549. id semantics
550. <xs:key> vs. <xs:unique>
551. Enhancing error message understanding
552. Referencing contacts
553. Violating referential integrity
554. Enforcing referential integrity
555. Participant reference duplicates
556. Solution:New key constraint
557. Participant reference duplicates
558. Nested vs. reference
559. <memo> exercise series
560. Invoice integrity constraints
561. Relational implementation
562. XML schema's and Java™ class declarations.
563. A first schema version for book documents
564. Version 2 of book.xsd
565. Required knowledge
566. Important XML Java™ APIs
567. SAX: XML to events
568. SAX architecture
569. DOM assembly
570. SAX deficiencies
571. DOM: Language independence
572. DOM: Vendor independence
573. DOM Node CORBA 2.2 IDL
574. Defining a language binding
575. org.w3c.dom.Node Java™ binding.
576. A context node's children
577. org.w3c.dom.Node subtypes
578. DOM Java™ binding inheritance interface hierarchy
579. DOM modules.
580. Jdom vs. DOM: Advantages
581. Jdom vs. DOM: Disadvantages
582. Prerequisite: pom.xml configuration
583. Exporting data as XML
584. XML document creation from scratch.
585. XML catalog sample data
586. SAX error handler
587. Accessing an XML Tree purely by DOM methods.
588. Driver class execution entry point
589. Project sample code for import
590. DOM and Javascript
591. DOM Javascript example
592. DOM Javascript demo
593. Why using XPath ?
594. XPath and Jdom
595. HTML containing <img> tags.
596. Objective: Find contained images
597. XSL script extracting images.
598. Setting up the parser
599. Search using XPath //html:img
600. Searching for images
601. Parameterized search expressions
602. A simplified XML product catalog
603. A XSL style sheet for catalog transformation to HTML.
604. Transforming an XML document instance to HTML by a XSL style sheet.
605. A driver class for the xml2xml transformer.
606. Prerequisite knowledge
607. Persistence [Bauer2015]
608. Java™ transient instances
609. RDBMS persistent records
610. Persisting transient User instances
611. Observations
612. Networking between clients and database server
613. JDBC™ features
614. JDBC™ in a three-tier application
615. JDBC™ connecting application server and database.
616. JDBC™ connection parameter
617. Components of a JDBC™ URL
618. IETF Uniform Resource Identifier
619. URL examples
620. Sub protocol examples
621. No standard port assignments ...
622. ... but Mysql made it into Linux
623. JDBC™ architecture
624. DriverManager: Bootstrapping connections
625. Example: Mysql connection implementation
626. Driver libraries
627. Driver libraries, Maven
628. Driver unavailable
629. Connection interface
630. Statement interface
631. JDBC™ instances and relationships.
632. Important Connection methods
633. Important Statement methods
634. JDBC™ and threading.
635. JDBC™ connection pooling
636. pom.xml driver runtime scope
637. Person table
638. Objective: insert person record
639. JDBC™ backed data insert
640. Result
641. Two JDBC™ configurations
642. Figure 639, “JDBC™ backed data insert ” deficiencies
643. Why properties?
644. message.properties string externalization
645. Properties code sketch
646. Intellij IDEA settings, preconditions
647. Database related unit test phases
648. Implementing unit tests
649. Spring is your friend
650. Project layout
651. Closing connections
652. Employ AutoCloseable
653. Sniffing a JDBC™ connection by an intruder.
654. Setting up Wireshark
655. Capturing results
656. Mysql™ security
657. Mysql™ security
658. Assembling SQL
659. SQL injection principle
660. Trouble at school
661. SQL injection impact
662. SQL injection relevance, [Clarke2009]
663. Lessons learned?
664. Validating user input prior to dynamically composing SQL statements.
665. Error message being presented to the user.
666. SQL statements in Java™ applications get parsed at the database server
667. Two questions
668. Addressing performance
669. Addressing performance mitigation
670. Addressing security
671. Solution: Use java.sql.PreparedStatement
672. PreparedStatement principle.
673. Three phases using parameterized queries
674. PreparedStatement example
675. Injection attempt example
676. No dynamic table support
677. JDBC™ read and write
678. Server / client object's life cycle
679. JDBC™ record container
680. Reading data from a database server.
681. Names and birth dates of friends
682. Accessing friend's database records
683. Important ResultSet states
684. JDBC™ to Java™ type conversions
685. Java™ to JDBC™ type conversions
686. Fixed type accessors
687. Polymorphic accessors
688. Access by column name
689. Access by column index
690. Problem: null value ambiguity
691. Resolving null value ambiguity
692. Users and groups
693. Isolation level
694. JDBC™ Isolation level
695. Setting the isolation level
696. Why using JPA ?
697. What about “impedance”?
698. OR impedance mismatch
699. JPA 2.0
700. JPA 2.1
701. JPA 2.2
702. JPA overview
703. JPA components
704. Maven pom.xml
705. Right click »Add Framework Support«
706. Enable Hibernate support
707. »File« --> »Project Structure«
708. Criteria / Querydsl annotation processing
709. Class StudyCourse
710. Transient instance
711. Persistence: Business rules
712. StudyCourse entity definition
713. persistence.xml configuration
714. CreateStudyCourse using a transaction
715. Database state
716. ReadStudyCourseById retrieval by primary key
717. Retrieving all instances
718. Type conversion problems
719. Reading shortName values
720. Adding a setter
721. Update language
722. Populating the database
723. JPQL: Domain model and database
724. JPA query alternatives
725. JPQL
726. JPQL parameter
727. JPQL record retrieval
728. Criteria entity metamodel
729. Criteria query
730. No injection susceptibility
731. Querydsl entity metamodel
732. From “Querying JPA”
733. Querydsl query
734. No injection susceptibility
735. Business and surrogate keys
736. Database generation strategies
737. INSERT omitting id
738. Generated surrogate id
739. StudyCourse creation
740. Entity Student
741. Database schema
742. Providing enrollment
743. CreateUniversity
744. Editing a Docbok 5 document using the XMLMind editor.
745. A simple GUI to insert data into a database server.
746. PersistenceHandler state transitions.
747. A GUI frontend for adding personal data to a server.
748. Login credentials for database connection
749. Intended usage behaviour for insertion of data records.
750. XSL target formats
751. Motivating XSL
752. A memo document instance with an internal reference.
753. Extracting the sender's name
754. Execution and Result
755. XSL processor transforming XML using a stylesheet
756. Transformation syntax details
757. List of recipient nodes iteration.
758. Selecting node sets from memo document instances
759. XPath content/para starting from context node <memo>.
760. Exporting SQL statements.
761. A graphical representation of our <catalog>.
762. A memo with 9 recipients
763. A <book> document with two chapters
764. Visualizing arbitrary XML input data.
765. Generating HTML from a XML document and an RDBMS.
766. A XML based catalog.
767. A Relation containing price information.
768. HTML generated output.
769. Parsing a XML document creates a corresponding sequence of events.
770. SAX Principle
771. Counting XML elements.
772. A non well formed document.
773. An invalid XML document.
774. A sample catalog containing products and corresponding descriptions.
775. The most simple FO document
776. Regions being defined in a page.
777. A complete FO parameterizing of a physical page and the fo:region-body.
778. Parameterizing page- and region view port. All length dimensions are in mm.
779. Parameterizing header and footer.
780. A fo:block with a fo:inline descendant.
781. An itemized list and result.
782. Two simulated entries in a table of contents.
783. Four entries separated by equal amounts of dotted space.
784. A horizontal line separator between header and body of a page.
785. Roman style page numbers.
786. A dictionary with running page headers.
787. Two blocks mutual page referencing each other.
788. Two blocks with mutual page- and hypertext references.
789. Different target formats from common source.
790. Generating a sender's surname for printing.
791. A memo document instance.
792. Why XML based publishing?
793. XML features
794. Editors, compositors, designers ...
795. Promises in publishing
796. Publishing reality
797. Single source publishing
798. Separating Structure, content and format
799. Separating concerns
800. Content
801. Hierarchical structure
802. Hierarchical structure, XML source
803. Presentation
804. Example 1: HTML 5, pure structure
805. Example 2: TeX / LaTeX
806. Separating structure and presentation(s)
807. Sample technical document
808. Observations
809. Pros and cons of TeX / LaTeX
810. Tools of the trade
811. Inline formatting
812. Paragraphs
813. Lists
814. Tables
815. Images
816. Mathematical formulas
817. Cross references
818. Document sectioning
819. Modular document components
820. What is Docbook?
821. Authoring and publishing
822. Document representation
823. Software centric schema
824. Document targets
825. Docbook components
826. Target format overview
827. Tooling / Software
828. Different schema languages
829. Plain HTML
830. Web help
831. Eclipse help
832. Printed output
833. Paragraph
834. Itemized list
835. Ordered list
836. Glossary list
837. Nested lists
838. Reference
839. A table
840. A MathML equation
841. A TeX equation
842. Reference
843. Figure
844. Image map + calloutlist
845. Video
846. A warning
847. Reference
848. Recursive sections
849. Non-recursive sections
850. Two different link flavours
851. Choosing a top level element
852. Allowed 5.1 top level elements
853. Schematron on top of RelaxNG
854. Example: xml:id and permalink
855. Using Display #Anchors
856. Considerations author based permalink
857. Schematron permalink rule
858. HTML customization overview
859. Target specific configuration
860. Link stability
861. use.id.as.filename = 1
862. Parameter: use.id.as.filename
863. Customization parameter ulink.target
864. callout.unicode / callout.graphics
865. Links
866. Hooking into XSL
867. Categories
868. Example: videos
869. Links
870. Customize by CSS
871. Example CSS modifications
872. Styling the editor
873. Motivating modular documents
874. Monolithic document problems
875. Document decomposition
876. A monolithic document
877. Decomposing documents
878. XML grammar defining languages
879. Address list schema
880. Format conversion problem
881. XSL template rules
882. Example: Formatting <title> elements
883. Basic FO introduction
884. XMLMind Editor
885. Oxygenxml Author
886. Vendor links
887. Inverse editing
888. Document representation
889. Components
890. BibTeX
891. Makeindex example
892. Makeindex work flow
893. Extension example: MusiXTeX
894. Flavours
895. Components
896. Editors
897. Two departments billing and research populated with sample user entries
898. Optimistic concurrency control
899. Failure with optimistic transactions
900. Reasons for using Maven
901. Transitive dependencies
902. A basic persistence.xml JPA configuration file.
903. JPA persistence provider
904. Mapping hibintro.v1.model.User instances to a database.
905. A basic User class.
906. Mapping properties to attributes.
907. Annotating integrity constraints
908. Database schema mapping instances of hibintro.v1.model.User.
909. Loading a single object by a primary key value.
910. Retrieving hibintro.v1.model.User instances by HQL.
911. Business rules for projects
912. Persistence related object states
913. Introducing inheritance mapping
914. Modelling payment.
915. A single relation mapping.
916. Mapping the inheritance hierarchy.
917. Inserting payment information
918. Figure subclasses
919. Joined subclass mapping.
920. Implementing Object.equals(Object) by natural keys
921. JPA caches.
922. Basics on Jax-RS
923. An example LDAP Tree
List of Tables
1. 4 Byte Two's complement representation of int values.
2. Exercises in
3. The Person table
4. Mapping elements from book.xsd to Xhtml
5. Exercises in
6. Exercises in
7. Exercises in
8. Exercises in
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