So, I'm taking the opportunity to talk about it now. Both DRY (Don't Repeat Yourself) and KISS (Keep it Stupidly Simple) are software design principles. When followed they can lead to better designed and easier maintained code.
Most people are quite happy remaining dry during a kiss. Your tongue should never be long, wet and limp; this person's face should never have a wet upper lip, wet lower lip, wet cheek or wet chin. If he or she has to pull away and wipe of his or her face, it's definitely not hot.
An Example
For example, writing a function that contains a specific logic and then calling it multiple times in our code is a form of applying the DRY principle. We can see that, after applying DRY, the logic that converts Fahrenheit to Celsius appears only once in our code.
Don't Repeat Yourself(DRY) is a software development principle, the main aim of which is to reduce repetition of code. Write Every Time(WET) is a cheeky abbreviation to mean the opposite i.e. code that doesn't adhere to DRY principle. It is quite obvious which one of the two should all developers be aiming for.
DRY stands for Don't Repeat Yourself and the principle is that there should only ever be one copy of any important piece of information. The reason for this principle is that one copy is much easier to maintain than multiple copies; if the information needs to be changed, there is only one place to change it.
The DRY (don't repeat yourself) principle is a best practice in software development that recommends software engineers to do something once, and only once.
Don't Repeat Yourself (DRY)
The DRY principle is stated as "Every piece of knowledge must have a single, unambiguous, authoritative representation within a system". The way to achieve DRY is by creating functions and classes to make sure that any logic should be written in only one place.
DRY code is a software principle that stands for Don't Repeat Yourself (DRY), where the goal is to reduce the repetition of code. Write Everything Twice (WET) is a cheeky abbreviation to mean the opposite i.e. code that doesn't adhere to DRY principle.
Andy Hunt and Dave Thomas formally defined this principle in 1999 in their book The Pragmatic Programmer. It's one of the few ideas that apply through all phases and levels of software development and even in other domains of knowledge work.
DRY, which stands for 'don't repeat yourself,' is a principle of software development that aims at reducing the repetition of patterns and code duplication in favor of abstractions and avoiding redundancy.
The KISS principle (or Keep It Simple, Stupid) states that most systems work best if they are kept simple rather than made overly complicated. When building a product, designing a website, creating an app, or engineering a block of code, strive for simplicity.
Keep it simple, stupid (KISS) is a design principle which states that designs and/or systems should be as simple as possible. Wherever possible, complexity should be avoided in a system—as simplicity guarantees the greatest levels of user acceptance and interaction.
WET. There's another concept that people have referred to as WET programming which stands for "Write Everything Twice." That's similarly dogmatic and over prescriptive. Conlin Durbin has defined this as: You can ask yourself "Haven't I written this before?" two times, but never three.
Do guys like wet or dry kisses? Men in general seem to like wet kisses with more "tongue action," said anthropologist Helen Fisher of Rutgers University. This could be because modern males are instinctually using kisses to pick up traces of estrogen in a woman's saliva and thus gauge her fertility.
Kissing is a natural instinct that likely serves a number of evolutionary purposes, said Fisher, one of the leading experts in the biology of love and attraction. Men's preference for sloppy kisses with lots of tongue may help them over come their poor sense of smell and taste.
The DRY principle is a programming concept that emphasizes the importance of reducing repetition in code. The idea is that code should be written in such a way that it is easy to understand and maintain, and that duplicated code should be avoided as much as possible.
In software engineering, DRY is a technique for reducing repetition in code. Coders streamline coding using a single, reusable source, aka "snippet," whenever appropriate. Hence, the name, don't repeat yourself. As well as saving time, writing the same thing multiple times means that there is less room for human error.
The DRY principle:
The “Don't Repeat Yourself” (or “Duplication Is Evil”) principle tells us that every software engineer should aim to reduce repetition of information or methods within their work in order to avoid redundancy. Therefore, it's recommended to segregate the entire system of consideration into fragments.
The opposite of wet is 'Dry.
Opposite of not hard or firm to touch. hard. rigid. solid.
The word 'miserable' from the passage means wretchedly unhappy and so it is the opposite of 'happy'.
It states that two instances of similar code do not require refactoring, but when similar code is used three times, it should be extracted into a new procedure. The rule was popularised by Martin Fowler in Refactoring and attributed to Don Roberts.
You have to ask "If I were to make a change in one place, would I necessarily need to make an equivalent change somewhere else?". If the answer is "yes", then the code is violating DRY.
KISS (Keep it simple, stupid) is one of the oldest principles of clean code. It was being used by the US military as early as the 1960s. KISS encourages programmers to write their code as simply as possible. You should avoid making your code unnecessarily complex.