É possível ter Zero Bugs em seu projeto? Nessa apresentação vocês terão acesso as técnicas efetivas de programação para chegar a esse objetivo, são boas práticas que farão uma diferença gigantesca em seu projeto!
O documento fornece uma introdução sobre automação de testes de software com Selenium e BDD, focando no front-end. Ele discute conceitos como ágil, TDD, BDD, frameworks para teste end-to-end, HTML, CSS, XPath, e dá instruções sobre como configurar o ambiente de desenvolvimento com Node.js, TypeScript, Git e navegadores.
Este documento fornece várias estratégias para implementar soluções improvisadas de forma permanente, conhecidas como "Programação Orientada a Gambiarras" (POG). Algumas dessas estratégias incluem: comentar código para "resolver problemas", usar exceções para controle de fluxo, e ignorar boas práticas de programação como testes e versionamento. O objetivo é fazer com que sistemas "funcionem" da maneira mais rápida possível, mesmo que isso gere problemas a longo prazo.
Este documento fornece técnicas e dicas para desenvolvimento em PHP sem o uso de "Programação Orientada a Gambiarras" (POG). Ele discute o que é POG, exemplos comuns, causas e ferramentas para evitá-la, incluindo técnicas de programação inspiradas por Chuck Norris.
1) O documento apresenta dicas para se tornar um programador pragmático, focando em princípios como simplicidade, reutilização de código, manutenibilidade e adaptabilidade.
2) É destacada a importância de ter um portfólio de conhecimento atualizado com novas linguagens, livros e cursos para se manter relevante no mercado.
3) Ferramentas básicas como controle de versão, editores de texto e debuggers são apresentadas como essenciais para o trabalho do programador pragmático.
Este documento discute os princípios de código limpo e boas práticas de programação. Ele explica que código limpo é código bem escrito, legível e fácil de manter. Também discute como identificar código sujo, a importância de nomes significativos, comentários úteis, classes e métodos pequenos, e testes de unidade. O objetivo é produzir software de qualidade e manutenível a longo prazo.
Pequena apresentação sobre Coding Dojo, para o primeiro Coding Dojo Sankhya.
Essa apresentação é um resumo de muitas outras, dentre as quais:
http://pt.slideshare.net/serge_rehem/coding-dojo-em-5-minutos
http://pt.slideshare.net/alextercete/coding-dojo-e-tdd
http://pt.slideshare.net/marloncarvalho/coding-dojo-5328510
http://pt.slideshare.net/williansdepaula/coding-dojo-10208494
Ela foi usada para uma apresentação de 10 min.
O documento discute Behavior Driven Development (BDD) e automação de testes com RSpec e Cucumber. Ele explica o que é BDD, como ele evoluiu de TDD, e como as ferramentas RSpec e Cucumber permitem escrever especificações e testes de aceitação em linguagem natural.
Design for change: Fatores que influenciam na longevidade de um Software PHPPablo Dall'Oglio
Nesta palestra, são abordados diversos aspectos da Engenharia de Software, desde BPMN, UML e uso de padrões de projeto, que influenciam diretamente na longevidade de um Software, ou seja, em sua Qualidade e Manutenibilidade. Para tal, são abordadas as contribuições que cada uma das áreas da Engenharia de Software pode dar à um projeto, com foco em Análise, Projeto e Arquitetura da solução, sempre com exemplos em PHP.
O documento fornece uma introdução sobre automação de testes de software com Selenium e BDD, focando no front-end. Ele discute conceitos como ágil, TDD, BDD, frameworks para teste end-to-end, HTML, CSS, XPath, e dá instruções sobre como configurar o ambiente de desenvolvimento com Node.js, TypeScript, Git e navegadores.
Este documento fornece várias estratégias para implementar soluções improvisadas de forma permanente, conhecidas como "Programação Orientada a Gambiarras" (POG). Algumas dessas estratégias incluem: comentar código para "resolver problemas", usar exceções para controle de fluxo, e ignorar boas práticas de programação como testes e versionamento. O objetivo é fazer com que sistemas "funcionem" da maneira mais rápida possível, mesmo que isso gere problemas a longo prazo.
Este documento fornece técnicas e dicas para desenvolvimento em PHP sem o uso de "Programação Orientada a Gambiarras" (POG). Ele discute o que é POG, exemplos comuns, causas e ferramentas para evitá-la, incluindo técnicas de programação inspiradas por Chuck Norris.
1) O documento apresenta dicas para se tornar um programador pragmático, focando em princípios como simplicidade, reutilização de código, manutenibilidade e adaptabilidade.
2) É destacada a importância de ter um portfólio de conhecimento atualizado com novas linguagens, livros e cursos para se manter relevante no mercado.
3) Ferramentas básicas como controle de versão, editores de texto e debuggers são apresentadas como essenciais para o trabalho do programador pragmático.
Este documento discute os princípios de código limpo e boas práticas de programação. Ele explica que código limpo é código bem escrito, legível e fácil de manter. Também discute como identificar código sujo, a importância de nomes significativos, comentários úteis, classes e métodos pequenos, e testes de unidade. O objetivo é produzir software de qualidade e manutenível a longo prazo.
Pequena apresentação sobre Coding Dojo, para o primeiro Coding Dojo Sankhya.
Essa apresentação é um resumo de muitas outras, dentre as quais:
http://pt.slideshare.net/serge_rehem/coding-dojo-em-5-minutos
http://pt.slideshare.net/alextercete/coding-dojo-e-tdd
http://pt.slideshare.net/marloncarvalho/coding-dojo-5328510
http://pt.slideshare.net/williansdepaula/coding-dojo-10208494
Ela foi usada para uma apresentação de 10 min.
O documento discute Behavior Driven Development (BDD) e automação de testes com RSpec e Cucumber. Ele explica o que é BDD, como ele evoluiu de TDD, e como as ferramentas RSpec e Cucumber permitem escrever especificações e testes de aceitação em linguagem natural.
Design for change: Fatores que influenciam na longevidade de um Software PHPPablo Dall'Oglio
Nesta palestra, são abordados diversos aspectos da Engenharia de Software, desde BPMN, UML e uso de padrões de projeto, que influenciam diretamente na longevidade de um Software, ou seja, em sua Qualidade e Manutenibilidade. Para tal, são abordadas as contribuições que cada uma das áreas da Engenharia de Software pode dar à um projeto, com foco em Análise, Projeto e Arquitetura da solução, sempre com exemplos em PHP.
O documento discute os benefícios de adotar frameworks para desenvolvimento de software. O autor argumenta que frameworks aumentam a produtividade, facilitam a manutenção do código e promovem boas práticas de programação orientada a objetos. Ele também fornece dicas para iniciar o uso de frameworks e menciona algumas opções populares como Laravel e Django.
O documento apresenta uma agenda para um treinamento sobre Test-Driven Development (TDD). A agenda inclui introduções, um exercício de coding dojo, explicações sobre as três leis e o ciclo de TDD, refatoração, princípios SOLID e a Lei de Demeter, além de uma sessão sobre ferramentas e frameworks.
O documento introduz os padrões de projetos GoF e Core J2EE, definindo o que são padrões de projeto e como surgem, e descrevendo alguns padrões específicos como Abstract Factory, Singleton, Template Method, Front Controller, Business Delegate e Domain Store. A conclusão questiona se alguns padrões ainda se aplicam com novas tecnologias.
Este documento descreve a jornada profissional de Pablo Dall'Oglio na programação, desde Clipper e Delphi até PHP, onde se especializou. Também apresenta conceitos básicos de padrões de projeto como Singleton, Adapter, Facade e Template View, além de exemplos de implementação em PHP.
A apresentação introduz o Behavior-Driven Development (BDD) utilizando a ferramenta JBehave. O palestrante explica os conceitos por trás do BDD, como se relaciona com TDD e DDD, e demonstra um exemplo prático utilizando JBehave em português.
Construindo ERP's com PHP: Desafios em design, manutenção segurança e perf...Pablo Dall'Oglio
O documento discute os desafios de construir ERPs com PHP, abordando tópicos como modelagem, construção, desempenho e segurança. O autor descreve sua experiência com diferentes tecnologias ao longo dos anos e apresenta dicas sobre concepção, modelagem orientada a domínio, simplificação do ORM e manutenção de baixo acoplamento entre módulos.
O documento descreve o framework Adianti, apresentando sua arquitetura, estrutura e funcionalidades. Em suas seções, aborda tópicos como o histórico do framework desde sua criação, sua instalação e uso, além de detalhar recursos como persistência de dados, formulários, grids e componentes visuais. O objetivo principal do framework é fornecer padronização e produtividade para o desenvolvimento de sistemas de negócios.
O Programador Pragmático se concentra no processo fundamental do desenvolvimento de software:
a partir de um requisito, produzir código funcional e de fácil manutenção que agrade aos usuários.
Sem se ater a uma tecnologia específica, esta obra aborda tópicos que vão do desenvolvimento da carreira a técnicas de projeto para manter seu código flexível e fácil de adaptar
Do Clipper e Delphi ao Ruby e PHP: Antes e depois dos frameworksPablo Dall'Oglio
O documento descreve as tecnologias de desenvolvimento de software utilizadas antes e depois da popularização dos frameworks, mencionando Clipper, Delphi, PHP e os frameworks Ruby on Rails e Adianti. Também discute conceitos como modelo-visão-controlador (MVC) e padrões de projeto.
O documento resume as principais dicas e conceitos apresentados no livro "O Programador Pragmático" de Andrew Hunt e David Thomas. Apresenta 70 dicas para programação pragmática, como evitar duplicação de código, estimar corretamente tarefas, testar continuamente e projetar para flexibilidade e reuso.
Fernando Chucre é um desenvolvedor PHP certificado pela Zend desde 2008. A certificação Zend Certified Engineer (ZCE) comprova conhecimentos avançados em PHP, incluindo orientação a objetos, ambientes web, bancos de dados e padrões de projeto. Para obter a certificação, candidatos precisam acertar pelo menos 80% das questões em um exame de múltipla escolha com 70 perguntas e duração de 90 minutos.
1) O documento discute o Domain-Driven Design (DDD), uma abordagem focada no domínio e na lógica de negócios.
2) As duas principais premissas do DDD são desenvolver um modelo que reflita o domínio e usar uma linguagem ubíqua compartilhada entre os especialistas de negócios e a equipe de desenvolvimento.
3) O DDD enfatiza a separação de camadas com base no domínio, utilizando conceitos como entidades, valores, agregações, serviços, fábricas e repositó
Padrões de projeto (design patterns) foram criados originalmente para engenharia civil e foram aplicados à engenharia de software para melhorar a qualidade e reduzir custos de manutenção. O livro "Design Patterns" classificou padrões em criação, estruturais e comportamentais. A aplicação de padrões traz benefícios como confiabilidade, redução de custos e legibilidade, apesar de potencial complexidade inicial.
O documento discute Design Patterns, estruturas de projeto reutilizáveis em programação orientada a objetos. Apresenta o que são Design Patterns, incluindo sua popularização após o livro "Design Patterns" de 1994, e lista 23 padrões comuns. Exemplos de Factory Method, Adapter e Observer são explicados detalhadamente ilustrando suas características e aplicações.
Eduardo Bregaida apresenta seu perfil profissional como desenvolvedor Java e Scrum Master e seu objetivo de se tornar um piloto comercial de avião. Ele oferece ajuda a James para desenvolver um sistema para a loja de aeronaves herdada por James. Eles discutem os requisitos do domínio, incluindo diferentes tipos de aeronaves e suas características, e como modelar e implementar o sistema usando Domain-Driven Design (DDD), Behavior-Driven Development (BDD) e Test-Driven Development (TDD).
O documento discute as vantagens e desvantagens de duas tecnologias populares para desenvolvimento web Java: Java EE e Spring Framework. Defensores de ambos os lados fazem argumentos sobre qual tecnologia é melhor ou mais apropriada para diferentes casos de uso. A discussão também aborda preocupações sobre a direção futura e manutenção de cada tecnologia.
O documento discute os princípios de código limpo, incluindo: (1) código limpo deve ser eficiente e ter lógica direta para minimizar bugs, (2) deve ter poucas dependências, e (3) deve ser legível para facilitar manutenção. Ele também fornece dicas como usar nomes significativos e formatar código claramente.
Nessa palestra relato minha experiência não como um desenvolvedor de software altamente sinistro com duzentos anos de experiência e mil livros publicados - mas sim como um "mero mortal", um desenvolvedor "de verdade", do "mundo real" aplicando a teoria que aprendeu do TDD.
Clean Code: Por um mundo com códigos melhores - SETI 2017Thiago Barradas
O documento apresenta os principais pontos para se escrever código limpo de forma concisa e eficiente, incluindo nomenclatura, classes, métodos, condições, objetos, abstração, comentários, formatação, exceções e testes. O objetivo é promover um mundo com códigos melhores e de mais fácil manutenção.
5 técnicas para acelerar o desenvolvimento e reduzir Bugs em aplicações WEBRafael Chinelato Del Nero
O documento discute técnicas para acelerar o desenvolvimento e reduzir bugs em aplicações web Java, incluindo: 1) manipulação efetiva das fases do JSF; 2) uso efetivo de Ajax; 3) uso efetivo de escopos do JSF; 4) reuso de componentes prontos; e 5) uso do Facelets. Ele também discute as vantagens e desvantagens do JSF e exemplos de implementações e extensões populares.
O documento apresenta uma introdução ao framework Spring Boot para desenvolvimento de aplicações Java. Apresenta os principais conceitos como criação de projetos, configuração automática de dependências, execução de aplicações e deploy em produção. Também mostra exemplos práticos de integração com Spring Data para banco MongoDB e exposição de serviços RESTful.
O documento discute os benefícios de adotar frameworks para desenvolvimento de software. O autor argumenta que frameworks aumentam a produtividade, facilitam a manutenção do código e promovem boas práticas de programação orientada a objetos. Ele também fornece dicas para iniciar o uso de frameworks e menciona algumas opções populares como Laravel e Django.
O documento apresenta uma agenda para um treinamento sobre Test-Driven Development (TDD). A agenda inclui introduções, um exercício de coding dojo, explicações sobre as três leis e o ciclo de TDD, refatoração, princípios SOLID e a Lei de Demeter, além de uma sessão sobre ferramentas e frameworks.
O documento introduz os padrões de projetos GoF e Core J2EE, definindo o que são padrões de projeto e como surgem, e descrevendo alguns padrões específicos como Abstract Factory, Singleton, Template Method, Front Controller, Business Delegate e Domain Store. A conclusão questiona se alguns padrões ainda se aplicam com novas tecnologias.
Este documento descreve a jornada profissional de Pablo Dall'Oglio na programação, desde Clipper e Delphi até PHP, onde se especializou. Também apresenta conceitos básicos de padrões de projeto como Singleton, Adapter, Facade e Template View, além de exemplos de implementação em PHP.
A apresentação introduz o Behavior-Driven Development (BDD) utilizando a ferramenta JBehave. O palestrante explica os conceitos por trás do BDD, como se relaciona com TDD e DDD, e demonstra um exemplo prático utilizando JBehave em português.
Construindo ERP's com PHP: Desafios em design, manutenção segurança e perf...Pablo Dall'Oglio
O documento discute os desafios de construir ERPs com PHP, abordando tópicos como modelagem, construção, desempenho e segurança. O autor descreve sua experiência com diferentes tecnologias ao longo dos anos e apresenta dicas sobre concepção, modelagem orientada a domínio, simplificação do ORM e manutenção de baixo acoplamento entre módulos.
O documento descreve o framework Adianti, apresentando sua arquitetura, estrutura e funcionalidades. Em suas seções, aborda tópicos como o histórico do framework desde sua criação, sua instalação e uso, além de detalhar recursos como persistência de dados, formulários, grids e componentes visuais. O objetivo principal do framework é fornecer padronização e produtividade para o desenvolvimento de sistemas de negócios.
O Programador Pragmático se concentra no processo fundamental do desenvolvimento de software:
a partir de um requisito, produzir código funcional e de fácil manutenção que agrade aos usuários.
Sem se ater a uma tecnologia específica, esta obra aborda tópicos que vão do desenvolvimento da carreira a técnicas de projeto para manter seu código flexível e fácil de adaptar
Do Clipper e Delphi ao Ruby e PHP: Antes e depois dos frameworksPablo Dall'Oglio
O documento descreve as tecnologias de desenvolvimento de software utilizadas antes e depois da popularização dos frameworks, mencionando Clipper, Delphi, PHP e os frameworks Ruby on Rails e Adianti. Também discute conceitos como modelo-visão-controlador (MVC) e padrões de projeto.
O documento resume as principais dicas e conceitos apresentados no livro "O Programador Pragmático" de Andrew Hunt e David Thomas. Apresenta 70 dicas para programação pragmática, como evitar duplicação de código, estimar corretamente tarefas, testar continuamente e projetar para flexibilidade e reuso.
Fernando Chucre é um desenvolvedor PHP certificado pela Zend desde 2008. A certificação Zend Certified Engineer (ZCE) comprova conhecimentos avançados em PHP, incluindo orientação a objetos, ambientes web, bancos de dados e padrões de projeto. Para obter a certificação, candidatos precisam acertar pelo menos 80% das questões em um exame de múltipla escolha com 70 perguntas e duração de 90 minutos.
1) O documento discute o Domain-Driven Design (DDD), uma abordagem focada no domínio e na lógica de negócios.
2) As duas principais premissas do DDD são desenvolver um modelo que reflita o domínio e usar uma linguagem ubíqua compartilhada entre os especialistas de negócios e a equipe de desenvolvimento.
3) O DDD enfatiza a separação de camadas com base no domínio, utilizando conceitos como entidades, valores, agregações, serviços, fábricas e repositó
Padrões de projeto (design patterns) foram criados originalmente para engenharia civil e foram aplicados à engenharia de software para melhorar a qualidade e reduzir custos de manutenção. O livro "Design Patterns" classificou padrões em criação, estruturais e comportamentais. A aplicação de padrões traz benefícios como confiabilidade, redução de custos e legibilidade, apesar de potencial complexidade inicial.
O documento discute Design Patterns, estruturas de projeto reutilizáveis em programação orientada a objetos. Apresenta o que são Design Patterns, incluindo sua popularização após o livro "Design Patterns" de 1994, e lista 23 padrões comuns. Exemplos de Factory Method, Adapter e Observer são explicados detalhadamente ilustrando suas características e aplicações.
Eduardo Bregaida apresenta seu perfil profissional como desenvolvedor Java e Scrum Master e seu objetivo de se tornar um piloto comercial de avião. Ele oferece ajuda a James para desenvolver um sistema para a loja de aeronaves herdada por James. Eles discutem os requisitos do domínio, incluindo diferentes tipos de aeronaves e suas características, e como modelar e implementar o sistema usando Domain-Driven Design (DDD), Behavior-Driven Development (BDD) e Test-Driven Development (TDD).
O documento discute as vantagens e desvantagens de duas tecnologias populares para desenvolvimento web Java: Java EE e Spring Framework. Defensores de ambos os lados fazem argumentos sobre qual tecnologia é melhor ou mais apropriada para diferentes casos de uso. A discussão também aborda preocupações sobre a direção futura e manutenção de cada tecnologia.
O documento discute os princípios de código limpo, incluindo: (1) código limpo deve ser eficiente e ter lógica direta para minimizar bugs, (2) deve ter poucas dependências, e (3) deve ser legível para facilitar manutenção. Ele também fornece dicas como usar nomes significativos e formatar código claramente.
Nessa palestra relato minha experiência não como um desenvolvedor de software altamente sinistro com duzentos anos de experiência e mil livros publicados - mas sim como um "mero mortal", um desenvolvedor "de verdade", do "mundo real" aplicando a teoria que aprendeu do TDD.
Clean Code: Por um mundo com códigos melhores - SETI 2017Thiago Barradas
O documento apresenta os principais pontos para se escrever código limpo de forma concisa e eficiente, incluindo nomenclatura, classes, métodos, condições, objetos, abstração, comentários, formatação, exceções e testes. O objetivo é promover um mundo com códigos melhores e de mais fácil manutenção.
5 técnicas para acelerar o desenvolvimento e reduzir Bugs em aplicações WEBRafael Chinelato Del Nero
O documento discute técnicas para acelerar o desenvolvimento e reduzir bugs em aplicações web Java, incluindo: 1) manipulação efetiva das fases do JSF; 2) uso efetivo de Ajax; 3) uso efetivo de escopos do JSF; 4) reuso de componentes prontos; e 5) uso do Facelets. Ele também discute as vantagens e desvantagens do JSF e exemplos de implementações e extensões populares.
O documento apresenta uma introdução ao framework Spring Boot para desenvolvimento de aplicações Java. Apresenta os principais conceitos como criação de projetos, configuração automática de dependências, execução de aplicações e deploy em produção. Também mostra exemplos práticos de integração com Spring Data para banco MongoDB e exposição de serviços RESTful.
Fernando Boaglio apresenta sobre internacionalização e localização de sistemas Linux e desktops para o português brasileiro. Ele discute sua experiência com tradução e comunidades open source e fornece uma breve introdução sobre o Linux Documentation Project.
Análise de qualidade de código com Sonar - Fernando Boaglio Fernando Boaglio
O documento descreve como instalar e usar o SonarQube para analisar a qualidade de código. Explica que o SonarQube é um agregador de métricas que destaca problemas e sugere melhorias no código, e pode ser instalado via Docker ou tradicionalmente em um servidor. Também mostra como integrar projetos Java e outros frameworks no SonarQube para análise.
O documento apresenta Fernando Boaglio e discute MongoDB e OpenShift. Ele explica o que é MongoDB, como surgiu, quem usa e como funciona. Também mostra como implementar um sistema de votação em filmes usando MongoDB no OpenShift e testar o desempenho na nuvem.
Mais um comparativo MongoDB - Fernando Boaglio - abril.2014Fernando Boaglio
O documento apresenta Fernando Boaglio, um desenvolvedor e escritor que fala sobre MongoDB. Resume alguns fatos sobre o banco de dados MongoDB, como ser livre, baseado em documentos e sem esquemas, e mostra comparações de desempenho com MySQL e SQL Server, indicando que MongoDB pode ser de 1,3 a 2 vezes mais rápido. Também mostra gráficos sobre o crescimento do MongoDB em popularidade comparado ao Oracle.
O documento discute como implementar logs e tracing em ambientes de microsserviços usando Spring Cloud Sleuth. Ele define termos como APP name, SpanId, TraceId e explica como o Zipkin permite visualizar o fluxo de chamadas entre serviços, identificar gargalos e filtrar traces por data, duração, serviço e endpoint. O autor oferece uma demonstração dessas funcionalidades.
A apresentação discute a utilização do Spring Cloud com Netflix OSS para configuração distribuída, discovery de serviços e gateway com Config Server, Eureka e Zuul. O palestrante também contribui com projetos open source e discutirá tópicos como Ribbon, Feign, Hystrix e segurança.
Lógica e Matemática Computacional - Aula 02thomasdacosta
O documento apresenta os conceitos fundamentais da lógica proposicional, incluindo: proposições, conectivos lógicos, tabelas verdade e precedência dos operadores. O professor Thomás da Costa explica que a lógica é usada para resolver problemas de forma racional e que na computação é essencial, apresentando exemplos de como é aplicada.
Apresentação sobre temas abordado no livro Clean Code de Robert C. Martim.
Os benefícios sobre manter seu código limpo. Quais prejuízos um código sujo pode trazer para sua empresa.
Como se expressar no seu código dispensando o uso de inúmeros comentários que poluem o código.
Aqui são apresentados as técnicas de Desenvolvimento Ágil: eXtreme Programming. Simples e prático.
/**Depois que entrei no mundo Java, começei a procurar por conteúdo na internet para estudar, então me deparei com um ótimo site, http://www.argonavis.com.br, de um grande cara chamado Helder Rocha, que disponibiliza este mesmo conteúdo em seu site também. Obrigado pela ajuda a comunidade.*/
O documento discute os princípios de código limpo, incluindo os custos de ter um código confuso, definições de código limpo de acordo com especialistas, e princípios como nomes significativos, métodos pequenos, tratamento de erros, testes unitários, classes coesas e design emergente.
Clean Code: Por um mundo com códigos melhores - The Developers Conference - P...Thiago Barradas
A apresentação discute os princípios do Clean Code, incluindo nomenclatura, classes, métodos, condições, objetos e estruturas de dados, abstração, comentários, formatação de código, exceções e testes. O objetivo é promover práticas que resultem em códigos melhores, mais limpos e de fácil manutenção.
Este documento fornece instruções sobre como escrever código Java de forma limpa e de fácil manutenção. Ele discute a importância de usar nomes significativos para variáveis e funções, escrever funções pequenas com uma única responsabilidade, e o uso apropriado de comentários.
O documento apresenta princípios básicos de programação e design de software, incluindo maus cheiros de código, código limpo e os cinco princípios SOLID (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation e Dependency Inversion). O objetivo é ajudar desenvolvedores a escreverem código de melhor qualidade e mais fácil de manter.
Teste sua aplicação antes que ela teste vocêTiago Link
O documento discute a importância de testes no desenvolvimento de software. Ele explica que testes garantem que o código funcione como esperado e ajudem a evitar bugs. Além disso, testes ajudam no design do sistema e inspiram mais confiança no código. O documento também apresenta diferentes técnicas de testes como TDD, BDD, testes unitários e de integração.
O documento discute os princípios do clean code, incluindo a importância de nomes significativos, métodos pequenos que fazem uma coisa só, e comentários mínimos. Também cobre formatação consistente, tratamento de exceções, testes automatizados, e manter sistemas pequenos e focados.
Objects calisthenics - Os 10 mandamentos do rei do códigoBonoBee
O documento apresenta 10 mandamentos do Object Calisthenics, uma abordagem para melhorar a qualidade do código orientado a objetos através de exercícios simples. Os mandamentos incluem: somente um nível de indentação por método, não usar a palavra-chave "else", encapsular tipos primitivos e strings, somente um ponto por linha, não abreviar nomes, manter classes pequenas, limitar variáveis de instância, usar coleções de primeiro nível, usar métodos getter/setter de forma adequada e documentar o código. A aplicação desses princípi
O documento apresenta um treinamento sobre desenvolvimento de software limpo e qualidade de código. Ele discute princípios como clean code, boas práticas de programação, ferramentas para teste e controle de versão que auxiliam na manutenção de código limpo e de qualidade.
Go é uma linguagem de programação open source que faz com que seja fácil construir software simples, confiável e eficiente. A linguagem foi projetada para lidar com grandes sistemas de software, melhorando a produtividade e permitindo a manutenção de código em larga escala. Go não possui herança como em outras linguagens, mas sim composição, onde tipos estruturados podem incorporar campos de outros tipos.
Projeto de API - TDC 2014 - Floripa - Trilha Arquitetura - 18/05/2014Gilmar PSL
O documento discute projeto de APIs, abordando conceitos como aprendizado, programação, integração e boas práticas de projeto. É destacado que APIs devem ser intuitivas, focadas no usuário e ter testes para garantir a qualidade. O desenvolvimento deve seguir TDD, começando com casos de uso e testes para guiar o design.
O documento discute projeto de APIs, abordando conceitos como aprendizado, programação, integração e boas práticas de projeto. A seção de programação destaca a importância de iniciar cedo com casos de uso e TDD, além de testar código que utiliza a API.
Refatoração refere-se à reestruturação do código-fonte de um software sem alterar seu comportamento externo, visando melhorar aspectos como legibilidade, manutenibilidade e design. O documento descreve os princípios e origens da refatoração, exemplos de técnicas como renomear variáveis e extrair métodos, além de discutir vantagens como redução de duplicação e aumento da simplicidade do código.
qualidade de código: boas práticas, princípios e padrõesedgarddavidson.com
O documento discute boas práticas de qualidade de código, incluindo princípios como baixo acoplamento e alta coesão. Também aborda padrões de projeto orientado a objetos e códigos cheirosos, além de técnicas como teste unitário e refatoração para melhorar a qualidade do código.
Apresentação do Coderage Brasil 2018 sobre TDD com Código Legado com Delphi usando Spring.Testing e TestInsight.
Dicas de Refactory, como identificar Code Smell e Antipatterns e Hands on do refactory do exemplo GettingStarted do FireDAC.
"Apresentação atualizada, pois o SlideShare não permite re-upload."
Vídeo da primeira parte - Apresentação
https://youtu.be/ZWQO0bLB8gU
O documento discute princípios de Clean Code e boas práticas de programação, destacando a importância de:
1) Dar nomes significativos às variáveis, métodos e classes;
2) Manter métodos pequenos e focados em uma única tarefa;
3) Escrever código de forma limpa e legível através da formatação e organização;
4) Criar objetos e classes coesas seguindo princípios como SRP.
Apresentação do Coderage Brasil 2018 sobre TDD com Código Legado com Delphi usando Spring.Testing e TestInsight.
Dicas de Refactory, como identificar Code Smell e Antipatterns e Hands on do refactory do exemplo GettingStarted do FireDAC
Boas práticas técnica para um código limpo (Clean Code)Rodrigo Kono
Este documento discute boas práticas para criar códigos limpos e de alta qualidade, focando em tópicos como nomes significativos, funções pequenas que fazem uma coisa só, comentários úteis, formatação consistente e tratamento de erros usando exceções. O objetivo é produzir códigos eficientes, de fácil manutenção e entendimento.
O documento discute padrões de projeto no Rails, incluindo: (1) os problemas iniciais com plugins que abusavam de monkey patch; (2) a discussão sobre colocar código no modelo ou controlador; e (3) como padrões como POROs, dependency injection e break out method object podem melhorar a manutenibilidade do código.
Semelhante a ZeroBugsProject - Técnicas de programação efetivas (20)
ZeroBugsProject - Técnicas de programação efetivas
1. Projeto Java com Zero Bugs!
Vamos discutir sobre como
trabalharmos em um projeto mais
agradável e a ter menos estresse e
por consequência teremos mais
tempo para a família e projetos
pessoais.
1
2. Problemas graves com bugs
Acho que a maioria ou todos aqui já teve
problemas gravíssimos com bugs, vamos
falar um pouco sobre isso!
2
4. É possível ter Zero Bugs?
Com técnicas efetivas de
programação e boas práticas, se não
tivermos um projeto com Zero Bugs,
chegaremos muito perto, e ainda pra
achá-los ficará absurdamente mais
fácil!
4
5. Tem mais benefícios?
O software está em constante mudança,
imagine se o desenvolvedor codificou para
funcionar, imagina a beleza que vai ser para
adicionar uma nova funcionalidade.
Então SIM, com técnicas efetivas temos
também esse ganho gigantesco!
5
6. Uma técnica muito conhecida
Clean Code! Usando-a
efetivamente já conseguimos um
resultado excelente!
6
7. Por que Clean Code?
• Todos ganham mais tempo
• A empresa gera mais lucro
• Tornamos o projeto muito mais agradável
• É recompensador ver o código bem escrito
• Todos ganham!!!
7
8. Então porque escrevemos código ruim?
• Cronograma apertado
• Visão ultrapassada de números
• Também é nossa culpa como desenvolvedor aceitar esse
cenário
• O cliente não sabe o que quer, até que mostramos a ele
8
9. Frase de Martin Fowler
Frase clássica do Martin Fowler
Any fool can write code that a computer can
understand. Good programmers write code that
humans can understand.
9
10. Frase do Bjarne Stroustrup, inventor do C++
I like my code to be elegant and efficient. The logic should be
straightforward to make it hard for bugs to hide, the dependencies
minimal to ease maintenance, error handling complete according to an
articulated strategy, and performance close to optimal so as not to
tempt people to make the code messy with unprincipled optimizations.
Clean code does one thing well.
10
11. Como saber se o código está ruim?
• Código confuso, difícil de entender
• Baixa coesão, classes ou métodos
possuem muitas responsabilidades
• Dependência excessiva de classes
• Depende de comentários
11
12. Como saber se o código está ruim?
12
• Programação estruturada
• Repetição excessiva de código
• Não usar padrão de arquitetura do sistema
• Não usar orientação a objetos de forma efetiva
• Não usar recursos que a API disponibiliza
• Atribuir qualquer nome de classe/método ou variável
• Usar números mágicos
• Programar pra funcionar
13. É difícil escrever clean code
13
• É preciso colocar mais esforço para ter código limpo
mas com o tempo de prática, isso vai ficando mais fácil.
Talvez a parte mais difícil é começar.
• É muito mais recompensador ver seu código bem
escrito e de fácil manutenção.
• Os resultados são impressionantes, você terá muito
mais tempo para sua família, e fica muito mais
agradável de trabalhar!
14. Nomes significativos
14
Parar e pensar nos nomes as funcionalidades é uma boa prática. Um algoritmo com
nomes ambíguos é muito difícil de decifrar.
Mal exemplo:
int dias; // tempo gasto em dias
Bom exemplo:
int tempoGastoEmDias;
É melhor um nome extenso e significativo do que um nome curto e confuso
15. Use nomes pronunciáveis
15
Mal exemplo:
String endrcoEntr;
String nmCli;
String nmProd;
Bom exemplo:
String enderecoDeEntrega;
String nomeDoCliente;
String nomeDoProduto;
16. Separe os pacotes do sistema por regra de negócio
16
Separar as regras de negócio core do sistema em pacotes ajuda muito o
desenvolvedor a localizar e entender tanto as próprias regras quanto até o
modelo de dados.
Parar um tempo e pensar com calma a estrutura de pacote do sistema também
é muito útil, isso é essencial para termos código de qualidade.
É muito fácil encontrar as classes de negócio quando estão separadas por
cada pacote.
17. Use os padrões do projeto
17
• Por exemplo para fazer uma busca, use sempre buscaAlgo e não pesquisaAlgo ou
getAlgo.
• Se seu projeto não tiver padrões, talvez seja uma boa ideia criá-los.
• Se não concordar com algum padrão no seu projeto, questione o arquiteto, forneça
sugestões
• Convencionar o código são técnicas que vem sendo muito usadas até por
frameworks.
18. Use verbos para métodos
e substantivos para classes e atributos
18
class Produto{ // Substantivo
private double preco; // Substantivo
public void aumentaPreco(double valor) { // Verbo/ação
this.preco += valor;
}
}
19. Classes
19
• Devem ser coesas, devem fazer uma coisa muito bem
• Não devem conhecer muito outras classes
• De preferência use dependências por interfaces
• Use composição
• Use herança com muito cuidado
• Devem ter nomes claros e específicos, fáceis para serem localizados
• Não devem ter nomes ambíguos, Ex: Historico, HistoricoDoCliente
• Deve usar encapsulamento
20. Métodos
20
• Não deve ter muitas linhas, se tiver alguma coisa deve estar errada
• Deve ter alta coesão ou seja, deve fazer apenas uma coisa
• Não deve ter estrutura de controle aninhada
• Não deve ter muitos argumentos, se tiver mais que 3 já é demais
• Deve ser elaborado de uma forma que tenha baixo acoplamento, ou seja, não conheça tanto outras
classes.
• É interessante usar um bom comentário, principalmente em API.
• Deve ser possível testar unitariamente com Junit de forma facilitada, caso contrário o método
provavelmente não foi implementado da melhor forma.
21. Métodos
21
• Isso deve ser evitado, 4 parâmetros ou mais é muita coisa:
void criaHistoricoDoCliente(String nomeDoCliente, int idadeDoCliente,
double valorPago,
double valorDoImposto, String usuarioLogado, String
comentarioDeAlteracao)
• É melhor usarmos um objeto com toda essa informação:
void criaHistoricoDoCliente(FiltroParaHistoricoDoCliente
filtroHistoricoCliente);
• Sem efeitos colaterais:
Métodos devem ter apenas uma responsabilidade
22. Métodos
22
Método orquestrador, (Facade, Service...)
Mal exemplo, muitas regras que deviam estar externalizadas, estão jogadas pelo código:
public void geraHistoricoDoCliente(ClienteDTO clienteDTO) throws BusinessException {
Cliente cliente = new Cliente();
cliente.setNome(clienteDTO.getNome());
cliente.setValorFatura(clienteDTO.getValorFatura());
Contrato contrato = cliente.getContrato();
contrato.setNomeContrato(clienteDTO.getNomeContrato());
// Vários outros setters ....
try {
Contrato contrato = dao.findById(Contrato.class, clienteDTO.getIdContrato);
cliente.setContrato(contrato);
dao.salva(cliente);
} catch (DataNotFoundException dataNotFoundException) {
thow new BusinessException(dataNotFoundException);
} catch(InconsistentDataException inconsistentDataException) {
thow new BusinessException(inconsistentDataException);
}
}
23. Métodos
23
Método orquestrador, (Facade, Service...)
Aqui fica diferente, as regras ficam encapsuladas em seus devidos lugares.
Codifique como se tivesse contando uma história:
Bom exemplo:
public void geraHistoricoDoCliente(ClienteDTO clienteDTO) throws BusinessException {
Cliente cliente = ConversorCliente.paraEntidade(clienteDTO);
Contrato contrato = contratoDAO.buscaContratoPor(clienteDTO.getIdContrato);
historicoClienteDAO.salva(cliente, contrato);
}
24. Tratamento de erros
24
• Prefira lançar Exceptions ao invés de retornar vários códigos de erros
• Escolha Exceptions específicas para seu negócio, nunca use Exception diretamente
• Saiba quando usar checked e unchecked Exceptions
• Não trate RuntimeExceptions, evite-as com tratamentos! A não ser que seja uma caso muito
específico
• Não coloque log em todos os lugares da Exception, coloque o log somente onde a Exception vai ser
pega
• Dê nomes significativos as Exceptions, facilitará quando for encontrar o erro
25. Não repita código
25
• Seu código deve ser elaborado de forma que não haja
repetição.
• Encapsulamento ajuda muito nisso.
• O padrão copiar e colar nunca deve ser usado.
26. Comentários
26
Não comente um código mal escrito, reescreva-o.
Se na sua empresa, usa-se PMD, Checkstyle, use um breve comentário
Se o código é legível você não precisa comentá-lo:
Isso é ruim
// Checa se o funcionário é elegível para receber desconto
if (funcionario.getValorFatura() > 200 && funcionario.getDiaDaCompra() == BLACKFRIDAY_DAY)
Isso é bom:
if (funcionario.isElegivelParaReceberDesconto ())
27. Comentários
27
• Use comentários bem detalhados para sua API, inclua informação de
negócio e crie um nome bem legível, pois provavelmente será
compartilhado com outras equipes.
• Não precisa colocar o comentário novamente dizendo que retorna o
customer, basta dizer que o método retorna o Customer na marca
@return.
/**
* Return a customer based on id
* @param int $id
* @return Customer
*/
Public function getCustomerById($id)
28. Comentários
28
• Evitem usar comentários no meio dos métodos, isso só piora a
legibilidade, deixa confuso, ao invés disso, crie um método separado e
diga o que vai fazer.
Exemplo:
Em vez disso:
public void salvaHistoricoDoCliente(ClienteDTO clienteDTO) {
// verifica se cliente foi alterado
if (!clienteDTO.isInformacaoEditada) {
throw new DadoInconsistenteException();
}
}
Crie isso:
public void salvaHistoricoDoCliente(ClienteDTO clienteDTO) {
verificaSeClienteFoiAlterado(clienteDTO);
}
29. Comentários
29
Comentários redundantes são ruins:
/** O dia do mês. */
private int diaDoMes;
Nesse caso é melhor não usarmos comentários, se for pra comentar, a
informação deve ser mais concisa.
30. Use enums
30
• Prefira enums ao invés de números mágicos.
• Evite fazer parse de DML do banco de dados para enums.
• Números mágicos não significam nada.
• Evite números mágicos em queries.
31. Códigos desnecessários comentados
31
Códigos comentados pelo sistema. Receio de apagá-lo.
É muito comum vermos um código comentado
por muito tempo e dificilmente apagam.
Geralmente são muitas linhas de código.
Não precisamos mais disso, hoje temos
versionadores, ou seja, o código não vai ser
perdido.
32. Espaçamento e formatação do código
32
• Use a formatação automática da sua IDE, no Eclipse por exemplo, use o atalho control + shift + f
e não se esqueça de configurar os caracteres máximos por linha para 120.
Nunca faça isso:
System.out.println(I + “Texto para preencher mais de 120 caracteres, Texto para preencher mais de 120……..............
Sempre deixe seu código bem indentado, às vezes a auto-formatação da IDE
vai prejudicar a indentação, nesses casos faça a indentação manualmente.
33. Espaçamento e formatação do código
33
Espaçamento entre funcionalidades:
void metodoComBomEspacamento() {
int numero1 = 0;
int numero2 = 0;
int numero3 = 0;
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
int x = 0;
while(x < 5) {
x++;
}
System.out.println(x);
}
Sem espaçamento entre funcionalidades:
void metodoComMalEspacamento() {
int numero1 = 0;
int numero2 = 0;
int numero3 = 0;
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
int x = 0;
while(x < 5){
x++;
}
System.out.println(x);
}
34. Conheça bem a API da linguagem
34
• Conhecer os recursos da API é fundamental para termos código de
qualidade.
• A API da linguagem é muito rica, possui muitos recursos úteis que
usamos no dia-a-dia. Usando-a efetivamente não corremos o risco de
reinventar a roda.
• Conheça também a API dos frameworks, EXTREMAMENTE IMPORTANTE,
ao menos o básico
• Keep it simple
35. Não recriar a roda com frameworks internos
35
• Ainda existem empresas
que insistem que vão
conseguir desenvolver
um framework interno
melhor que outros que já
estão no mercado por
muito tempo, maduros e
estáveis, onde pessoas
do mundo inteiro estão
continuamente
melhorando-o.
36. Use orientação a objetos!
36
• Encapsulamento
• Polimorfismo
• Composição
• Herança com muita
cautela
• Inversão de controle
• Sobrecarga
• Design Patterns
• Princípios SOLID
37. Encapsulamento
37
• Se você sabe como uma classe se comporta por fora
dela, você não está usando encapsulamento.
• Programe para interface, saiba o que a classe
faz e não como ela funciona.
38. Alta coesão
38
Classes e métodos devem ser responsáveis por apenas
uma tarefa.
Métodos com muitas linhas são questionáveis, e
precisam de refatoração.
Se seus métodos possuem uma regra muito
complexa, uma boa ideia é encapsular cada regra
em métodos privados.
39. Baixo acoplamento
39
Classes muito acopladas deixam a manutenção muito difícil.
Herança por exemplo gera um acoplamento muito alto,
quando não é necessário, é preferível usarmos composição
ao invés de herança.
Uma mudança pequena na super classe e todo seu código
pode quebrar.
Código desacoplado gera manutenção flexível.
40. Use Testes Unitários
40
• Seu código deve ser fácil de testar
• Se está difícil de testar, provavelmente seu código está
muito responsável, com alto acoplamento
• Se perceber que precisa criar mil mocks para seu teste e
tem muitos fluxos, algo também está errado, repense em
seu método
• Não adianta gerar números com testes unitários, deve-se
testar efetivamente a regra de negócio
41. SOLID
41
Os padrões SOLID são considerados uma
boa prática de programação orientada a
objetos que visam diminuir o
acoplamento entre classes e separar
responsabilidades como forma de
melhorar o código da aplicação
desenvolvida.
42. Princípios SOLID
42
· Single Responsibility Principle: princípio da responsabilidade única;
· Open Closed Principle: princípio do aberto/fechado;
· Liskov Substitution Principle: princípio da substituição de Liskov;
·Interface Segregation Principle: princípio da segregação de Interfaces;
· Dependency Inversion Principle: princípio da inversão de dependência.
43. Design Patterns
43
São soluções elegantes elaboradas para problemas recorrentes de
programação. Está completamente relacionado a Clean Code, pois
com Design Patterns é possível desenvolver código flexível,
escalável, coeso e com baixo acoplamento.
O problema é saber onde aplicar o Pattern, seu uso indevido pode
deixar o código mais complicado que deveria.
45. Bibliografia
45
Livro Clean Code – Uncle Bob
Palestra sobre SOLID e orientação a objetos com Uncle Bob
https://www.youtube.com/watch?v=QHnLmvDxGTY&list=PL0t9k9FlHnTki4D06nfKTfO9aw0xaEIwx
CodingDojo Blog
http://www.codingdojo.com/blog/clean-code-techniques/
Geeks Blog
https://geeks.uniplaces.com/clean-code-101-meaningful-names-and-functions-3d37fb12182f#.fcino5f80