Desenvolvimento eficaz com código legado

O código legado se faz presente na vida de todo engenheiro de software. Saber como lidar com ele é um grande ganho para o negócio, aprenda formas de como manipula-lo e por fim vencê-lo.

Transcript

1. Desenvolvimento eficaz com código legado Gabriel Brasileiro
2. Apresentação Gabriel Brasileiro - Staff Software Engineer na Porto; - Bacharel em Sistemas de Informação; - Idealizador de libs open source; - Entusiasta e estudioso do mercado de capitais; - Projetos e Start-ups.
3. Motivação
4. A mecânica das alterações
5. A mecânica das alterações Estrutura Nova funcionalidade Funcionalidade Uso de recursos Inclusão de recurso Correções Refatoração Otimização
6. Propagação de efeitos
7. 1. Consumo do retorno de um método Propagação de efeitos
8. Propagação de efeitos public CustomData getData() { return customData; } public String getState() { return "custom"; }
9. 2. Objetos passados no construtor Propagação de efeitos
10. Propagação de efeitos /** * O estado e as variáveis internas * desse objeto podem estar sendo alteradas! * * E essas alterações podem se propagar no * consumo do objeto. */ private CustomData customData; public Effect(CustomData customData) { this.customData = customData; }
11. 3. Modificação de dados estáticos Propagação de efeitos
12. Propagação de efeitos /** * O controle aberto de um estado estático * representa um alto risco de volatilidade * no consumidor da variável. */ public static CustomData customData = new CustomData("start"); public void changeState() { customData = new CustomData("execute"); }
13. Por que o código se torna difícil de manipular?
15. 1. Ausência de testes Por que o código se torna difícil de manipular?
16. 2. Acoplamento excessivo Por que o código se torna difícil de manipular?
17. 3. Variáveis globais Por que o código se torna difícil de manipular?
18. 4. Variáveis estáticas Por que o código se torna difícil de manipular?
19. 5. Ausência de arquitetura Por que o código se torna difícil de manipular?
20. E o que podemos fazer? Como ter segurança ao alterar?
21. Testes, testes, testes…
22. Given, When, Then…
23. Pontos de intercepção e fixação
24. Pontos de intercepção de fixação 1. A estratégia da exploração
25. Pontos de intercepção de fixação 2. Componentes conectados
26. Pontos de intercepção de fixação 3. Contexto aplicação versus contexto global versus contexto local
27. Pontos de intercepção de fixação 4. Ponto de teste
28. Pontos de intercepção de fixação class Bank { withdraw(value: number) { const balance = this.getBalance() if (value <= balance) { console.log("Sucesso no saque") } else { console.log("Erro no saque") } } private getBalance() { // Mundo externo que chama uma API para retorno do saldo. return 1000.0 } } const bank= new Bank() bank.withdraw(500)
29. Pontos de intercepção de fixação fixação intercepção intercepção fixação
30. Pontos de intercepção de fixação 5. Se simples, realize o teste; altere; modifique.
31. Pontos de intercepção de fixação Senão…
32. eXtreme Engineering – Realizando o teste do que se diz intestável
33. Os elos da herança e do polimorfismo
34. Os elos da herança e do polimorfismo 1. Em casos de métodos privados ou final, transforme-os em métodos de pacote e permita o controle da herança e do polimorfismo
35. Puxe da criatividade a sua tática: Os elos da herança e do polimorfismo
36. Os elos da herança e do polimorfismo
37. Transformação Os elos da herança e do polimorfismo
38. public class MessageDispatcherLegacy { private static final String colon = ":"; private final String key = "identifier"; final public void processMessage(String contentMessage) { String allMessage = getKey() + colon + contentMessage; String transformed = allMessage.toUpperCase(); dispatchMessage(transformed); } protected void dispatchMessage(final String message) { System.out.println(message); // Local que realiza conexão com o mundo exterior. } protected String getKey() { return key; } // Estruturas que podem existir em classes monstruosas. } Os elos da herança e do polimorfismo
39. public class MessageDispatcherFake extends MessageDispatcherLegacy { private final String customKey; private String lastMessage; public MessageDispatcherFake(String customKey) { this.customKey = customKey; } @Override final protected void dispatchMessage(String message) { this.lastMessage = message; } @Override final protected String getKey() { return customKey; } protected String getLastMessage() { return lastMessage; } } Os elos da herança e do polimorfismo
40. class MessageDispatcherLegacy { private static readonly colon = ":"; private readonly key = "identifier"; public processMessage(contentMessage: string): void { const allMessage = this.getKey() + MessageDispatcherLegacy.colon + contentMessage const transformed = allMessage.toUpperCase(); this.dispatchMessage(transformed); } protected dispatchMessage(message: string): void { console.log(message); // Local de conexão com o mundo exterior. } protected getKey(): string { return this.key } } Os elos da herança e do polimorfismo
41. class MessageDispatcherFake extends MessageDispatcherLegacy { private readonly customKey: string private lastMessage: string | undefined constructor(customKey: string) { super(); this.customKey = customKey } protected dispatchMessage(message: string): void { this.lastMessage = message } protected getKey(): string { this.customKey } public getLastMessage(): string | undefined { return this.lastMessage } } Os elos da herança e do polimorfismo
42. 2. Realize o teste na parte específica da mudança Os elos da herança e do polimorfismo
43. public static void main(String[] args) { // Given String message = "Atualizar as bases"; String key = "teste"; String expectedMessage = "TESTE:ATUALIZAR AS BASES"; MessageDispatcherFake fakeDispatcher = new MessageDispatcherFake(key); // When fakeDispatcher.processMessage(message); // Then String lastMessage = fakeDispatcher.getLastMessage(); boolean isEquals = lastMessage.equals(expectedMessage); System.out.println("Resultado: " + isEquals); } Os elos da herança e do polimorfismo
44. function main(): void { // Given const message = "Atualizar as bases"; const key = "teste"; const expectedMessage = "TESTE:ATUALIZAR AS BASES"; const fakeDispatcher = new MessageDispatcherFake(key); // When fakeDispatcher.processMessage(message); // Then const lastMessage: string | undefined = fakeDispatcher.getLastMessage(); const isEquals: boolean = lastMessage === expectedMessage; console.log("Resultado: " + isEquals); } Os elos da herança e do polimorfismo
45. 3. Verifique se os efeitos não se propagam além do seu mapeamento Os elos da herança e do polimorfismo
46. 4. Realize a mudança. Com polimorfismo ou criando novas abstrações! Os elos da herança e do polimorfismo
47. 5. Revise! Os elos da herança e do polimorfismo
48. Os elos da herança e do polimorfismo Revisão direta
49. Mas todo poder vem com uma responsabilidade! Os elos da herança e do polimorfismo
50. Princípio de Substituição de Liskov
51. Princípio de Substituição de Liskov O caso do quadrado retângulo
52. Princípio de Substituição de Liskov public class Rectangle { public Rectangle(int x, int y, int width, int height) { ... } public void setWidth(int width) { ... } public void setHeight(int height) { ... } public int getArea() { ... } } public class Square extends Rectangle { public Square(int x, int y, int width) { ... } } public static void main(String[] args) { Rectangle rectangle = new Square(...); rectangle.setHeight(3); rectangle.setHeight(4); }
53. Princípio de Substituição de Liskov Observe se precisa de um cast para acessar um método ou propriedade
54. Princípio de Substituição de Liskov public static void main(String[] args) { Vehicle vehicle = new Car(); Car car = (Car) vehicle; car.drive(); }
55. Os perigos do duck typing O polimorfismo no nível máximo!
56. class IntCalculator { constructor() { this.tax = 10 } getTotal(value) { return value * this.tax } } class FloatCalculator { constructor() { this.tax = 10.0 } getTotal(value) { const total = value * this.tax return `${total}` } } Os perigos do duck typing function calculate(calculator) { const total = calculator.getTotal(10) const addOne = total + 1 console.log(addOne) } const intCalculator = new IntCalculator() const floatCalculator = new FloatCalculator() calculate(intCalculator) calculate(floatCalculator)
57. Saída intCalculator = 101 floatCalculator = 1001 Os perigos do duck typing
58. class Dog: def speak(self): print("O cachorro fala Woof!") class Cat: def speak(self): print("O gato fala Meow!") def make_animal_speak(animal): animal.speak() dog = Dog() cat = Cat() make_animal_speak(dog) # Saída: O cachorro fala Woof! make_animal_speak(cat) # Saída: O gato fala Meow! Os perigos do duck typing
59. Mutações em runtime Isole as mutações, são elas que ocasionam os problemas mais severos.
60. Concorrência e paralelismo Assim como as mutações são perigosas isole os pontos se sessão crítica do seu projeto.
61. ReactiveX
62. Soluções orientadas a interfaces “Independente da arquitetura o SOLID deve fazer-se presente” - Gabriel Brasileiro
63. Strategy Externalizando e extraindo o comportamento para novos códigos
64. Strategy fun main() { val hardWork = HardWorkClazz() val processInfo = ProcessInfo() processInfo.startNewScope(hardWork.getStrategy()) } class ProcessInfo { fun startNewScope( legacyStrategy: LegacyStrategy ) { val immutableData = legacyStrategy.getData() println(immutableData.name) } } data class NewInfo( val name: String ) fun interface LegacyStrategy { fun getData(): NewInfo } class HardWorkClazz { private var legacyName = "" fun getStrategy(): LegacyStrategy { return LegacyStrategy { NewInfo(legacyName) } } /** * Conjunto de funções de * manipulação com alto risco. * ... */ }
65. class ProcessInfo { startNewScope(legacyStrategy: LegacyStrategy) { const name = legacyStrategy.getName(); console.log(name); } } const hardWork = new HardWorkClazz(); const processInfo = new ProcessInfo(); processInfo.startNewScope(hardWork.getStrategy()); Strategy class NewInfo { constructor(readonly name: String) {} } interface LegacyStrategy { getName(): NewInfo; } class HardWorkClazz { private legacyName = 'legacy'; getStrategy(): LegacyStrategy { return { getName: () => { return new NewInfo(this.legacyName) } } } }
66. Strategy - Teste data class NewInfo( val name: String ) fun interface LegacyStrategy { fun getData(): NewInfo } interface FinishExecution { fun terminate(message: String) } class FakeFinish : FinishExecution { private var lastMessage = String() override fun terminate(message: String) { lastMessage = message } fun getLastMessage(): String = lastMessage } class ProcessInfo( private val finishExecution: FinishExecution ) { fun startNewScope( legacyStrategy: LegacyStrategy ) { val immutableData = legacyStrategy.getData() val name = immutableData.name finishExecution.terminate(name) } }
67. Strategy - Teste fun main() { val expected = "Mário" val testStrategy = LegacyStrategy { NewInfo(name = "Mário") } val fakeFinishExecution = FakeFinish() val processInfo = ProcessInfo(fakeFinishExecution) processInfo.startNewScope(testStrategy) val result = fakeFinishExecution.getLastMessage() println(result == expected) // Saída: True }
68. Strategy - Dicas Durante a fase de desenvolvimento também é possível usar lambdas para a criação dos blocos de estratégia.
69. Functional Replacement Transformando o fluxo de controle para estruturas imutáveis em tempo de execução
70. data class NewContext( val param: String ) class LegacyContext { var state = "runtime" /** Estrutura não compreensível */ } // Interface de recepção interface TerminateState { fun sendMessage(message: String) } // Interface de controle interface ProcessState { fun createState() } // Interface de isolamento interface ExecutionScope { // Criação do contexto funcional fun onScope(block: (NewContext) -> Unit) } Functional Replacement
71. class TerminateEnvironment : TerminateState { override fun sendMessage(message: String) { println("Processo terminado: $message") } } class TransformEnvironment : ExecutionScope { // Contexto não interpretável isolado private val legacyContext = LegacyContext() // Contexto transformado e emitido override fun onScope(block: (NewContext) -> Unit) { val state = legacyContext.state val newContext = NewContext(state) block(newContext) } } class ProcessStateEnvironment( private val executionScope: ExecutionScope, private val terminateState: TerminateState ) : ProcessState { override fun createState() { executionScope.onScope { newContext: NewContext -> // Condicionais e novas estruturas terminateState.sendMessage(newContext.param.uppercase()) } } } Functional Replacement
72. fun main() { val transformEnvironment: ExecutionScope = TransformEnvironment() val terminateEnvironment: TerminateState = TerminateEnvironment() val processState: ProcessState = ProcessStateEnvironment(transformEnvironment, terminateEnvironment) processState.createState() // Saída: Processo terminado: RUNTIME } Functional Replacement
73. class TransformEnvironmentFake( private val newContext: NewContext ) : ExecutionScope { override fun onScope(block: (NewContext) -> Unit) { block(newContext) } } class TerminateEnvironmentFake : TerminateState { private var lastMessage = String() override fun sendMessage(message: String) { lastMessage = message } fun getLastMessage(): String = lastMessage } Functional Replacement - Teste
74. fun main() { val expected = "GIVA" val newContext = NewContext("Giva") val fakeEnvironment = TransformEnvironmentFake(newContext) val terminateEnvironmentFake = TerminateEnvironmentFake() val processState: ProcessState = ProcessStateEnvironment(fakeEnvironment, terminateEnvironmentFake) processState.createState() val result = terminateEnvironmentFake.getLastMessage() println(expected == result) // Saída: True } Functional Replacement - Teste
75. Humble Object Isole em totalidade o objeto impossível
76. Humble Object
77. data class ImpossibleData( var status: String, var state: String ) class ImpossibleObject { private var impossibleData = ImpossibleData( state = "execution", status = "good" ) fun getCurrentState(): ImpossibleData { return impossibleData } // Operações extras e "impossíveis de entender". } Humble Object
78. data class Consumer( val state: String ) interface AdapterConsumer { fun requireConsumer(): Consumer } class AdapterScopeConsumer( private val impossibleObject: ImpossibleObject ): AdapterConsumer { override fun requireConsumer(): Consumer { val impossibleData =impossibleObject.getCurrentState() return Consumer(impossibleData.state) } } Humble Object
79. fun main() { val impossibleObject = ImpossibleObject() val adapterConsumer: AdapterConsumer = AdapterScopeConsumer(impossibleObject) newFlowOperation(adapterConsumer) } fun newFlowOperation(adapterConsumer: AdapterConsumer) { val consumer = adapterConsumer.requireConsumer() val state = consumer.state println("Estado imutável recuperado: $state") // Saída: Excecution } Humble Object
80. Switch de execução Escolha o seu contrato de retorno; Defina uma classe base ou interface para extração dos dados; Retorne, valide e destrua o código legado!
81. Switch de execução class ContextLegacy { private var name = "mário" private var age = 58 fun getData(): ContextData { return ContextData(name, age) } /** Objeto monstruoso com dados diversos */ } class ContextNew { fun getData(): ContextData { return ContextData("gabriel", 24) } } class ContextToggle { fun isEnabled(): Boolean = true } interface ContextDecider { fun getData(): ContextData } class ContextScopeDecider( private val contextLegacy: ContextLegacy, private val contextNew: ContextNew, private val contextToggle: ContextToggle ) : ContextDecider { override fun getData(): ContextData { return if (contextToggle.isEnabled()) { contextNew.getData() } else { contextLegacy.getData() } } }
82. O uso de interfaces no retorno do switch assim como o Strategy são bem-vindas! Switch de execução
83. Use seu framework de testes Após orientar seu código a interfaces a estrutura do seu teste fica simples!
84. O desacoplamento é a chave para a progressão eficaz
85. Cada pequena mudança e melhoria é um investimento para o futuro no médio e no longo prazo do projeto
86. O design vem pra ajudar, mas a criatividade é fundamental!
87. A arte de programar consiste em organizar e dominar a complexidade Edsger Djikstra
88. Fontes - Trabalho eficaz com código legado - Michael C. Feathers; - Arquitetura Limpa - Robert C. Martin; - Dive Into Design Patterns - Alexander Shvets; - Functional Programming: https://en.wikipedia.org/wiki/Functional_programming - Pure Functions: https://en.wikipedia.org/wiki/Pure_function - Liskov Substitution Principle: https://en.wikipedia.org/wiki/Liskov_substitution_principle - Given, when, then: https://martinfowler.com/bliki/GivenWhenThen.html - Humble Object: https://martinfowler.com/bliki/HumbleObject.html - SOLID: https://en.wikipedia.org/wiki/SOLID - GWT: https://martinfowler.com/bliki/GivenWhenThen.html - Patterns: https://refactoring.guru/design-patterns
89. Github Medium LinkedIn Perguntas? gabrielbrasileiro GabrielBrasileiro @gabriel.brasileiro