Existem muitos artigos sobre o tema DRY, recomendo a leitura da fonte original “The Pragmatist Programmer” de Andy Hunt e Dave Thomas. No entanto, ainda vejo quantos desenvolvedores têm dúvidas sobre esse princípio no desenvolvimento de software.
O princípio DRY afirma que não devemos nos repetir, isso se aplica tanto ao código quanto aos processos que realizamos como programadores. Código de exemplo que viola DRY:
class Client {
public let name: String
private var messages: [String] = []
init(name: String) {
self.name = name
}
func receive(_ message: String) {
messages.append(message)
}
}
class ClientController {
func greet(client: Client?) {
guard let client else {
debugPrint("No client!")
return
}
client.receive("Hello \(client.name)!")
}
func goodbye(client: Client?) {
guard let client else {
debugPrint("No client!!")
return
}
client.receive("Bye \(client.name)!")
}
}
Como você pode ver nos métodos greet e adeus, uma instância opcional da classe Client é passada, que então precisa ser verificada quanto a zero, e então você pode começar a trabalhar com ela. Para cumprir o método DRY, você precisa remover a verificação nula duplicada da instância da classe. Isto pode ser implementado de várias maneiras; uma opção é passar a instância para o construtor da classe, após o que não haverá necessidade de verificações.
Mantemos o DRY especializando o ClientController em uma única instância do Client:
class Client {
public let name: String
private var messages: [String] = []
init(name: String) {
self.name = name
}
func receive(_ message: String) {
messages.append(message)
}
}
class ClientController {
private let client: Client
init(client: Client) {
self.client = client
}
func greet() {
client.receive("Hello \(client.name)!")
}
func goodbye() {
client.receive("Bye \(client.name)!")
}
}
DRY também diz respeito a processos que ocorrem durante o desenvolvimento de software. Vamos imaginar uma situação em que uma equipe de desenvolvimento tenha que carregar uma versão no mercado por conta própria, distraindo-a do desenvolvimento de software; isso também é uma violação do DRY; Essa situação é resolvida conectando-se um pipeline de CI/CD, no qual o release é liberado automaticamente, sujeito a determinadas condições atendidas pelos desenvolvedores.
Em geral, DRY trata da ausência de repetições tanto nos processos quanto no código, isso também é importante pela presença do fator humano: código que contém código menos repetitivo e barulhento é mais fácil de verificar se há erros; Os processos automatizados impossibilitam que as pessoas cometam erros ao executá-los, porque não há nenhum ser humano envolvido.
Steve Jobs tinha um ditado: “Uma linha de código que você nunca precisou escrever é uma linha de código que você nunca precisou depurar”.
Fontes
https://pragprog.com/titles/tpp20/the-pragmatic-programmer-20th-anniversary-edition/
https://youtu.be/-msIEOGvTYM
