Seriously Good Software Video Edition

Seriously Good Software Video Edition
Seriously Good Software Video Edition

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 10h 28m | 3.21 GB
eLearning | Skill level: All Levels

Building high-quality software is never simple, and it is always a good idea to reexamine the principles of good design and craftsmanship. In this book, you will find a fresh perspective that I hope you will enjoy as much as I did.

From the Foreword by Cay Horstmann, author of Big Java, Core Java, and many other titles

Serious developers know that code can always be improved. With each iteration, you make optimizations—small and large—that can have a huge impact on your application’s speed, size, resilience, and maintainability.

In Seriously Good Software: Code that Works, Survives, and Wins, author, teacher, and Java expert Marco Faella teaches you techniques for writing better code. You’ll start with a simple application and follow it through seven careful refactorings, each designed to explore another dimension of quality.

Great code blends the skill of a programmer with the time-tested techniques and best practices embraced by the entire development community. Although each application has its own context and character, some dimensions of quality are always important. This book concentrates on seven pillars of seriously good software: speed, memory usage, reliability, readability, thread safety, generality, and elegance. The Java-based examples demonstrate techniques that apply to any OO language.

Seriously Good Software is a handbook for any professional developer serious about improving application quality. It explores fundamental dimensions of code quality by enhancing a simple implementation into a robust, professional-quality application. Questions, exercises, and Java-based examples ensure you’ll get a firm grasp of the concepts as you go. When you finish the last version of the book’s central project, you’ll be able to confidently choose the right optimizations for your code.

What’s inside

  • Evaluating software qualities
  • Assessing trade-offs and interactions
  • Fulfilling different objectives in a single task
  • Java-based exercises you can apply in any OO language
+ Table of Contents

01 Preliminaries
02 Software qualities and a problem to solve
03 Mostly external software qualities
04 Mostly internal software qualities
05 Interactions between software qualities
06 The recurring example A system of water containers
07 Data model and representations
08 Storing connections
09 Hello containers!
10 Method connectTo
11 Reference implementation
12 Memory layout diagrams
13 Memory requirements
14 Time complexity
15 Applying what you learned
16 Software Qualities
17 Need for speed Time efficiency
18 Adding connections in constant time
19 Delaying the updates
20 The best balance Union-find algorithms
21 Connecting trees of containers
22 Amortized time complexity
23 Amortized analysis of resizable arrays
24 Comparing implementations
25 And now for something completely different
26 Real-world use cases
27 Summary
29 Space and time complexity
30 Plain arrays
31 Forgoing objects
32 Creating containers with a factory method
33 Connecting containers by ID
34 The black hole
35 Space-time trade-offs
36 Real-world use cases
37 Applying what you learned
38 Exercise
39 Self-conscious code Reliability through monitoring
40 Invariants
41 Checking contracts
42 Designing containers by contract
43 Containers that check their contracts
44 Checking the contract of connectTo
45 Containers that check their invariants
46 And now for something completely different
47 Real-world use cases
48 Exercise 2
49 Exercise 3
50 Lie to me Reliability through testing
51 JUnit
52 Testing containers
53 Testing addWater
54 Input coverage criteria
55 Testing connectTo
56 Testability
57 And now for something completely different
58 A test suite
59 Real-world use cases
60 Applying what you learned
61 Exercise
62 Coding aloud Readability
63 Structural readability features
64 Exterior readability features
65 Readable containers
66 Final thoughts on readability
67 Real-world use cases
68 Many cooks in the kitchen Thread safety
69 Dealing with deadlocks
70 Thread-safe containers
71 Immutability
72 The implementation
73 And now for something completely different
74 Applying what you learned
75 Please recycle Reusability
76 The general framework
77 Mutable collectors
78 A generic container implementation
79 Recovering water containers
80 And now for something completely different
81 Real-world use cases
82 Exercises and further reading
83 Appendix A. Code golf Succinctness
84 Appendix B. The ultimate water container class