
What you would learn in Seriously Good Software video edition course?
Creating high-quality Software is never easy, so reviewing the fundamentals for good design and artistry is always beneficial. With this publication, you'll get a new view which I hope you are as impressed as I did with the introduction by Cay Horstmann, the author of Big Java, Core Java, and many other books.
The most experienced developers understand that the code is constantly improving. Each time you update your code, you implement small and large optimizations that can make a massive difference to the speed of your application, size, resilience, and maintainability.
In Excellent Software, The Code That Works and Survives, the author, teacher instructor, and Java specialist Marco Faella show methods for writing better code. The book starts with a simple application and then goes through seven meticulous refactorings, each designed to help you discover a new quality dimension.
concerning the technology
An excellent code blends the expertise of programmers with tried and true techniques and best practices, which are accepted by the entire development community. Even though every program has its unique context and personality, specific quality dimensions are essential. This book focuses on the seven fundamentals of excellent Software: speed, reliability, memory usage and readability, thread security, generality, and elegance. The Java-based examples illustrate methods that can be applied to all OO languages.
About the book
Good Software is a guide for professional developers interested in improving the quality of applications. It will help you understand the fundamental aspects of code quality, transforming an existing application into an efficient, professional-grade application. Questions, along with exercises and Java-based exercises, ensure that you can grasp the fundamentals as you work. Once you've completed the latest draft of this book's core project, you can confidently select the best optimizations in your application.
What's the inside
- Evaluating software qualities
- Analyzing trade-offs, interactions, and interplays
- Achieving different goals within a single mission
- Java-based exercises are available to any OO language
Course Content:
- Part 1. Preliminaries
- Chapter 1. Software qualities and a problem to solve
- Chapter 1. Mostly external software qualities
- Chapter 1. Mostly internal software qualities
- Chapter 1. Interactions between software qualities
- Chapter 1. The recurring example: A system of water containers
- Chapter 1. Data model and representations
- Chapter 1. Storing connections
- Chapter 1. Hello, containers!
- Chapter 1. Method connectTo
- Chapter 2. Reference implementation
- Chapter 2. Memory layout diagrams
- Chapter 2. Memory requirements
- Chapter 2. Time complexity
- Chapter 2. Applying what you learned
- Part 2. Software Qualities
- Chapter 3. Need for speed: Time efficiency
- Chapter 3. Adding connections in constant time
- Chapter 3. Delaying the updates
- Chapter 3. The best balance: Union-find algorithms
- Chapter 3. Connecting trees of containers
- Chapter 3. Amortized time complexity
- Chapter 3. Amortized analysis of resizable arrays
- Chapter 3. Comparing implementations
- Chapter 3. And now for something completely different
- Chapter 3. Real-world use cases
- Chapter 3. Summary
- Chapter 4. Precious memory: Space efficiency
- Chapter 4. Space and time complexity
- Chapter 4. Plain arrays
- Chapter 4. Forgoing objects
- Chapter 4. Creating containers with a factory method
- Chapter 4. Connecting containers by ID
- Chapter 4. The black hole
- Chapter 4. Space-time trade-offs
- Chapter 4. Real-world use cases
- Chapter 4. Applying what you learned
- Chapter 4. Exercise
- Chapter 5. Self-conscious code: Reliability through monitoring
- Chapter 5. Invariants
- Chapter 5. Checking contracts
- Chapter 5. Designing containers by contract
- Chapter 5. Containers that check their contracts
- Chapter 5. Checking the contract of connectTo
- Chapter 5. Containers that check their invariants
- Chapter 5. And now for something completely different
- Chapter 5. Real-world use cases
- Chapter 5. Exercise 2
- Chapter 5. Exercise 3
- Chapter 6. Lie to me: Reliability through testing
- Chapter 6. JUnit
- Chapter 6. Testing containers
- Chapter 6. Testing addWater
- Chapter 6. Input coverage criteria
- Chapter 6. Testing connectTo
- Chapter 6. Testability
- Chapter 6. And now for something completely different
- Chapter 6. A test suite
- Chapter 6. Real-world use cases
- Chapter 6. Applying what you learned
- Chapter 6. Exercise
- Chapter 7. Coding aloud: Readability
- Chapter 7. Structural readability features
- Chapter 7. Exterior readability features
- Chapter 7. Readable containers
- Chapter 7. Final thoughts on readability
- Chapter 7. Real-world use cases
- Chapter 8. Many cooks in the kitchen: Thread safety
- Chapter 8. Dealing with deadlocks
- Chapter 8. Thread-safe containers
- Chapter 8. Immutability
- Chapter 8. The implementation
- Chapter 8. And now for something completely different
- Chapter 8. Applying what you learned
- Chapter 9. Please recycle: Reusability
- Chapter 9. The general framework
- Chapter 9. Mutable collectors
- Chapter 9. A generic container implementation
- Chapter 9. Recovering water containers
- Chapter 9. And now for something completely different
- Chapter 9. Real-world use cases
- Chapter 9. Exercises and further reading
- Appendix A. Code golf: Succinctness
- Appendix B. The ultimate water container class
Download Seriously Good Software video edition from below links NOW!
You are replying to :
Access Permission Error
You do not have access to this product!
Dear User!
To download this file(s) you need to purchase this product or subscribe to one of our VIP plans.
Note
Download speed is limited, for download with higher speed (2X) please register on the site and for download with MAXIMUM speed please join to our VIP plans.