Software Engineering Made Easy
Software Engineering Made Easy
About the Book
"Any fool can write code a computer can understand. Good programmers wirte code humans can understand" - Martin Fowler
There is an infinite amount of possibilities how you can write code with a certain output. But which is the best one? The one you understand most easily. This book covers everything that I could think of. From naming to classes, comments, and even some small chapters on software architecture or requirements engineering.
Currently the book is about version 0.8. It is very well readable and has been mostly corrected using an AI tool, but it still has a few comments about things left to do. I would be very pleased with any feedback you could send to me.
About the Author
Table of Contents
- 1. Introduction to Software Engineering
- Getting started
- 2.
- 3. One sentence summary
- 4. The short story behind this book
- Thanks to
- 5. Preface
- Who this book is for
- Writing this book
- A word about Copilot
- 6. Software Engineering
- The Life of a Software Engineer
- Writing correct code
- Cleaning up code
- Writing code for a purpose
- The five rules of software engineering
- 7. Good code: a list of rules
- The Zen of Python
- 8. Understandable code
- How Humans Think
- Spaghetti code
- Examples
- Copilot
- 9. Single Responsibility Principle
- Do not Repeat Yourself
- Advantages of the SRP
- Drawbacks of the SRP
- 10. Levels of abstraction
- Real world example
- Programming Example
- The Abstraction Layers
- Summary
- 11. Interfaces
- Real-world Interfaces
- Code Interfaces
- APIs
- Orthogonality
- Copilot
- 12. Naming
- The importance of Names
- How to name things
- Naming Antipatterns
- Copilot
- 13. Functions
- Do one thing only
- Temporal Coupling
- Number of Arguments
- Output arguments
- Return Values
- Summary
- Copilot
- 14. Classes
- Data Classes and Structs
- Private or Public
- Different Kinds of Classes
- Functions vs. Methods
- Constructors and Destructors
- Getter and Setter Methods
- Coupling and Cohesion
- Static Expression
- Drawbacks of Classes
- Conclusions
- Copilot
- 15. Inheritance
- Two Types of Inheritance
- Drawbacks of Inheritance
- Advantages of Inheritance
- Inheritance and Composition
- Conclusions
- 16. Data Types
- Lists
- Enums
- Booleans
- Strings
- Dictionaries
- Trees
- Pointers
- 17. Properties of Variables
- Compile-time constant
- Runtime Constant
- Mutable Variables
- Member Variables
- Static Variables
- Global Variables
- Comparison of Variable Properties
- 18. Introduction to Testing
- A short story about tests
- Test Example
- General Thoughts about Tests
- Number of test cases
- Stages of a Test
- Problematic Tests
- The Beyoncé Rule
- Exceptions and Tests
- Not Automatable Tests
- 19. Types of Tests
- Unit Tests
- Functional Tests
- Other Kinds of Tests
- When to run Tests
- Who should write Tests?
- The Testing Pyramid
- 20. Writing Better Code with Tests
- Unit Tests
- Integration and Functional Tests
- Testing Existing Code
- Assertions
- Test Driven Development
- Stubs, Fakes, and Mocks
- Summary
- Copilot
- 21. SOLID principles
- Single Responsibility Principle
- Open Closed Principle
- Liskov Substitution Principle
- Interface Segregation Principle
- Dependency Inversion Principle
- Summary
- 22. Software Engineering Principles
- Divide and Conquer
- Increase Cohesion
- Reduce coupling
- Increase abstraction
- Increase Reusability
- Design for flexibility
- Anticipate Obsolescence
- Design for Testability
- Pay Now or Pay More Later
- 23. Programming Paradigms
- Object-Oriented Programming
- Procedural programming
- Functional Programming
- Conclusions
- Copilot
- 24. Programming Languages
- Java and C++
- Existing Programming Languages
- Code Examples
- Python
- C++
- Copilot
- 25. Physical Laws of Code
- Entropy
- Correlation
- Quality
- 26. Bugs, Errors, Exceptions
- Syntax Errors
- Bugs
- Exceptions
- 27. Complexity
- Complexity of Code
- Estimating complexity
- Single line complexity
- Black magic code
- 28. Dependencies
- The Early Days
- The dependency graph
- Breaking up Dependencies
- Circular Dependencies
- 29. Decoupling
- 30. Software Architecture
- The end of Architecture
- Designing Interfaces
- Separate Libraries
- 31. Design Patterns
- Factory
- 32. Domain Driven Design
- Ubiquitous Language
- The Domain Model
- Domain Specific Language
- Domain Boundaries
- Building Blocks of DDD
- 33. 3rd party software
- 34. Refactoring Fundamentals
- There will be change
- Don’t Let Your Code Rot
- Levels of Refactoring
- When to Refactor
- What to Refactor
- Refactoring Process
- 35. Refactoring Techniques
- Where to start
- Breaking classes
- Renaming
- Scratch refactoring [WELC p. 212]
- Extract function
- Dependency Injector
- Copilot
- 36. Refactoring Legacy Code
- No Useful Interfaces
- No Tests
- Extremely Long Functions
- Seams
- Sketches
- How do I get the Code under Test?
- Sprout Method
- 37. Performance Optimization
- No Optimization Needed
- Optimization Maybe Needed
- Optimizing Certainly Needed
- 38. Comments
- Bad comments
- Useful comments
- Commenting magic numbers
- Summary
- Copilot
- 39. Logging
- 40. Data files
- CSV
- JSON
- XML
- HDF5
- Databases
- Custom file format
- 41. Setting up a project
- Project Folder
- 42. Tools
- Version control software
- Command line
- IDE
- Continuous Integration
- Debugger
- Profiler
- Formatter
- Code quality checker
- Pip, cmake
- Ticketing system
- Wiki
- Docstring
- 43. Working in teams
- Team structure
- Developers work
- Communication
- Working with customers
- 44. Code review
- Drawbacks
- Conclusions
- 45. Agile
- Problems of Waterfall
- Agile was born
- Work planning
- Quality Assurance
- The Iron Cross
- Sprints
- Becoming agile
- 46. Requirements Engineering
- Stakeholders
- Goals, Context and Scope
- Use-Case Model
- 47. Planning
- Planning code
- 48. DevOps
- The early 2000s
- Benefits of DevOps
- 49. Mental health
- 50. Hiring and getting hired
- Hiring
- Getting hired
- 51. Examples
- Apple pie
- Paint
- 52. About Copilot
- Copilot and this book
- Issues
- Copilot and the future
- 53. Further reading
- 54. Outlook
- 55. Frequently used Abbreviations
- 1. Introduction to Software Engineering
The Leanpub 60 Day 100% Happiness Guarantee
Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.
Now, this is technically risky for us, since you'll have the book or course files either way. But we're so confident in our products and services, and in our authors and readers, that we're happy to offer a full money back guarantee for everything we sell.
You can only find out how good something is by trying it, and because of our 100% money back guarantee there's literally no risk to do so!
So, there's no reason not to click the Add to Cart button, is there?
See full terms...
80% Royalties. Earn $16 on a $20 book.
We pay 80% royalties. That's not a typo: you earn $16 on a $20 sale. If we sell 5000 non-refunded copies of your book or course for $20, you'll earn $80,000.
(Yes, some authors have already earned much more than that on Leanpub.)
In fact, authors have earnedover $13 millionwriting, publishing and selling on Leanpub.
Learn more about writing on Leanpub
Free Updates. DRM Free.
If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).
Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.
Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.
Learn more about Leanpub's ebook formats and where to read them
