Quotes About Software

The rules of software are the same today as they were in 1946, when Alan Turing wrote the very first code that would execute in an electronic computer.

This is the world of the software development team. It's a world in which dates are frozen and requirements are continuously changing. And somehow in that context, the development team must drive the project to a good outcome.

Duplication and expressiveness take me a very long way into what I consider clean code, and improving dirty code with just these two things in mind can make a huge difference. There is, however, one other thing that I'm aware of doing, which is a bit harder to explain.

The architecture of a system is defined by a set of software components and the boundaries that separate them.

To write clean code, you must first write dirty code and then clean it.

The fact that the task to write perfect software is virtually impossible does not mean you aren't responsible for the imperfection.

Implementation Patterns.

We in this industry sorely need to increase our professionalism. We fail too often. We ship too much crap. We accept too many defects. We make terrible trade-offs. Too often, we behave like unruly teenagers with a new credit card. Martin, Robert C.. Clean Agile (Robert C. Martin Series) . Pearson Education. Kindle Edition.

Am I suggesting 100% test coverage? No, I'm not suggesting it. I'm demanding it. Every single line of code that you write should be tested. Period.

Software is a compound word. The word "ware" means "product." The word "soft" means easy to change. Therefore, software is a product that is easy to change. Software was invented because we wanted a way to quickly and easily change the behavior of our machines. Had we wanted that behavior to be hard to change, we would have called it hardware.

In fact, component dependency diagrams have very little do to with describing the function of the application. Instead, they are a map to the buildability and maintainability of the application.

You should be able to run all the unit tests with just one command.

If a component contains software that should be reused, it should not also contain software that is not designed for reuse. Either all the classes in a component are reusable, or none of them are.

The tests fit the production code like an antibody fits an antigen.

CRP says that classes that are not tightly bound to each other with class relationships should not be in the same component.

the fact that oo languages provide safe and convenient polymorphism means that any source code dependency, no matter where it is, can be inverted

It is the perversity of software that a module that you have designed to be easy to change can be made difficult to change by someone else simply hanging a dependency upon it.

refactored)    /**

THE STABLE ABSTRACTIONS PRINCIPLE A component should be as abstract as it is stable.

Duplication may be the root of all evil in software. Many principles and practices have been created for the purpose of controlling or eliminating it.

OCP: The Open-Closed Principle Bertrand Meyer made this principle famous in the 1980s. The gist is that for software systems to be easy to change, they must be designed to allow the behavior of those systems to be changed by adding new code, rather than changing existing code.

The SOLID principles tell us how to arrange our functions and data structures into classes, and how those classes should be interconnected. The use of the word "class" does not imply that these principles are applicable only to object-oriented software. A class is simply a coupled grouping of functions and data. Every software system has such groupings, whether they are called classes or not. The SOLID principles apply to those groupings.

Components are the units of deployment. They are the smallest entities that can be deployed as part of a system.

The goal of the principles is the creation of mid-level software structures that: • Tolerate change, • Are easy to understand, and • Are the basis of components that can be used in many software systems.