| 0 | 421.4 KB | ||
| 1 - Part 1. Why it all matters.mp4 | 3.7 MB | ||
| 10 - Chapter 2. The many masks of importing.mp4 | 24.1 MB | ||
| 11 - Chapter 2. The hierarchy of separation in Python.mp4 | 55.3 MB | ||
| 12 - Chapter 2. Classes.mp4 | 38.5 MB | ||
| 13 - Chapter 3. Abstraction and encapsulation.mp4 | 65.6 MB | ||
| 14 - Chapter 3. Encapsulation.mp4 | 52.5 MB | ||
| 15 - Chapter 3. Programming styles are an abstraction too.mp4 | 36.5 MB | ||
| 16 - Chapter 3. Typing, inheritance, and polymorphism.mp4 | 51.7 MB | ||
| 17 - Chapter 4. Designing for high performance.mp4 | 26.3 MB | ||
| 18 - Chapter 4. Time complexity.mp4 | 49.6 MB | ||
| 19 - Chapter 4. Performance and data types.mp4 | 43.7 MB | ||
| 2 - Chapter 1. The bigger picture.mp4 | 49.7 MB | ||
| 20 - Chapter 4. Make it work, make it right, make it fast.mp4 | 58.4 MB | ||
| 21 - Chapter 4. Tools.mp4 | 48 MB | ||
| 22 - Chapter 5. Testing your software.mp4 | 35.6 MB | ||
| 23 - Chapter 5. Functional testing approaches.mp4 | 54.1 MB | ||
| 24 - Chapter 5. Integration testing.mp4 | 32.1 MB | ||
| 25 - Chapter 5. Statements of fact.mp4 | 49.1 MB | ||
| 26 - Chapter 5. Writing your first integration test with unittest.mp4 | 46.7 MB | ||
| 27 - Chapter 5. Testing with pytest.mp4 | 23.4 MB | ||
| 28 - Chapter 5. Beyond functional testing.mp4 | 40.4 MB | ||
| 29 - Part 3. Nailing down large systems.mp4 | 6 MB | ||
| 3 - Chapter 1. Design is a process.mp4 | 32.9 MB | ||
| 30 - Chapter 6. Separation of concerns in practice.mp4 | 44.4 MB | ||
| 31 - Chapter 6. An initial code structure, by concern.mp4 | 30.5 MB | ||
| 32 - Chapter 6. The persistence layer.mp4 | 50.5 MB | ||
| 33 - Chapter 6. The persistence layer.mp4 | 38 MB | ||
| 34 - Chapter 6. The business logic layer.mp4 | 46.1 MB | ||
| 35 - Chapter 6. The presentation layer.mp4 | 53.7 MB | ||
| 36 - Chapter 6. The presentation layer.mp4 | 17.8 MB | ||
| 37 - Chapter 7. Extensibility and flexibility.mp4 | 36.4 MB | ||
| 38 - Chapter 7. Modifying existing behaviors.mp4 | 36.9 MB | ||
| 39 - Chapter 7. Solutions for rigidity.mp4 | 52 MB | ||
| 4 - Chapter 1. Design enables better software.mp4 | 48.7 MB | ||
| 40 - Chapter 7. An exercise in extension.mp4 | 31.2 MB | ||
| 41 - Chapter 8. The rules (and exceptions) of inheritance.mp4 | 35.9 MB | ||
| 42 - Chapter 8. The inheritance of programming present.mp4 | 55.4 MB | ||
| 43 - Chapter 8. Inheritance in Python.mp4 | 40.2 MB | ||
| 44 - Chapter 8. Abstract base classes.mp4 | 24.6 MB | ||
| 45 - Chapter 8. Inheritance and composition in Bark.mp4 | 33.9 MB | ||
| 46 - Chapter 9. Keeping things lightweight.mp4 | 64.2 MB | ||
| 47 - Chapter 9. Breaking down complexity.mp4 | 36.3 MB | ||
| 48 - Chapter 9. Decomposing classes.mp4 | 22.9 MB | ||
| 49 - Chapter 9. Extracting classes and forwarding calls.mp4 | 43.8 MB | ||
| 5 - Chapter 1. When to invest in design.mp4 | 25.4 MB | ||
| 50 - Chapter 10. Achieving loose coupling.mp4 | 58.7 MB | ||
| 51 - Chapter 10. Recognizing coupling.mp4 | 56.1 MB | ||
| 52 - Chapter 10. Addressing coupling.mp4 | 54.8 MB | ||
| 53 - Part 4. What’s next.mp4 | 3.5 MB | ||
| 54 - Chapter 11. Onward and upward.mp4 | 56.2 MB | ||
| 55 - Chapter 11. Design patterns.mp4 | 30.3 MB | ||
| 56 - Chapter 11. Distributed systems.mp4 | 45 MB | ||
| 57 - Chapter 11. Where you’ve been.mp4 | 37.5 MB | ||
| 6 - Chapter 1. Design is democratic.mp4 | 52.3 MB | ||
| 7 - Part 2. Foundations of design.mp4 | 5 MB | ||
| 8 - Chapter 2. Modules.mp4 | 37.4 MB | ||
| 9 - Chapter 2. Separation of concerns.mp4 | 36 MB | ||
| TutsNode.com.txt | 102.4 B | ||
| [TGx]Downloaded from torrentgalaxy.to .txt | 614.4 B | ||
| 1 | 306.9 KB | ||
| 2 | 306.1 KB | ||
| 3 | 121.9 KB | ||
| 4 | 316.8 KB | ||
| 5 | 412.9 KB | ||
| 6 | 149.8 KB | ||
| 7 | 242.5 KB | ||
| 8 | 191 KB | ||
| 9 | 409.2 KB | ||
| 10 | 293.7 KB | ||
| 11 | 510.5 KB | ||
| 12 | 235.5 KB | ||
| 13 | 47.6 KB | ||
| 14 | 299.3 KB | ||
| 15 | 462.9 KB | ||
| 16 | 259 KB | ||
| 17 | 369.1 KB | ||
| 18 | 429.6 KB | ||
| 19 | 292.5 KB | ||
| 20 | 477.4 KB | ||
| 21 | 342.9 KB | ||
| 22 | 411.8 KB | ||
| 23 | 503.6 KB | ||
| 24 | 113.1 KB | ||
| 25 | 211.3 KB | ||
| 26 | 324.9 KB | ||
| 27 | 67 KB | ||
| 28 | 269 KB | ||
| 29 | 483.7 KB | ||
| 30 | 24.2 KB | ||
| 31 | 8.2 KB | ||
| 32 | 67.2 KB | ||
| 33 | 125.8 KB | ||
| 34 | 15.8 KB | ||
| 35 | 120 KB | ||
| 36 | 246.2 KB | ||
| 37 | 506.2 KB | ||
| 38 | 152 KB | ||
| 39 | 389.4 KB | ||
| 40 | 57.8 KB | ||
| 41 | 74.2 KB | ||
| 42 | 452.8 KB | ||
| 43 | 301.3 KB | ||
| 44 | 510.9 KB | ||
| 45 | 229.5 KB | ||
| 46 | 243.8 KB | ||
| 47 | 134.2 KB | ||
| 48 | 359.3 KB | ||
| 49 | 422.8 KB | ||
| 50 | 74.5 KB | ||
| 51 | 90.7 KB | ||
| 52 | 153.9 KB | ||
| 53 | 15.2 KB | ||
| 54 | 480 KB | ||
| 55 | 259.7 KB | ||
| ▲ 115 total files | |||
Description
A wealth of information on general software architecture and truths that are applicable to any language.
David T. Kerns, Rincon Research Corporation
Professional developers know the many benefits of writing application code that’s clean, well-organized, and easy to maintain. By learning and following established patterns and best practices, you can take your code and your career to a new level.
With Practices of the Python Pro, you’ll learn to design professional-level, clean, easily maintainable software at scale using the incredibly popular programming language, Python. You’ll find easy-to-grok examples that use pseudocode and Python to introduce software development best practices, along with dozens of instantly useful techniques that will help you code like a pro.
about the technology
Professional-quality code does more than just run without bugs. It’s clean, readable, and easy to maintain. To step up from a capable Python coder to a professional developer, you need to learn industry standards for coding style, application design, and development process. That’s where this book is indispensable.
about the book
Practices of the Python Pro teaches you to design and write professional-quality software that’s understandable, maintainable, and extensible. Dane Hillard is a Python pro who has helped many dozens of developers make this step, and he knows what it takes. With helpful examples and exercises, he teaches you when, why, and how to modularize your code, how to improve quality by reducing complexity, and much more. Embrace these core principles, and your code will become easier for you and others to read, maintain, and reuse.
Released January 2020
| torrent name | size | uploader | age | seed | leech |
|---|---|---|---|---|---|
|
Udemy - Best Practices Of The Research Process - Guide For Beginners Posted by
freecoursewb in Other
|
1.7 GB | freecoursewb | 2 years | 0 | 0 |
| 1.8 GB | freecoursewb | 3 years | 0 | 0 | |
|
Udemy - Stakeholder Engagement Best Practices of Fortune 500 Leaders Posted by
freecoursewb in Other
|
1 GB | freecoursewb | 3 years | 0 | 0 |
| 385.9 MB | freecoursewb | 3 years | 0 | 1 | |
| 2.9 GB | freecoursewb | 4 years | 0 | 0 |
All Comments