Índice

Introdução: 02

Use as ferramentas certas 03

Fique longe do rato! 06

Código limpo 08

Princípios sólidos 10

Codificação, a maneira Delphi 11

Próximos passos 13

Marco Geuze é co-proprietário da GDK Software e Embarcadero Delphi

MVP. Ele começou a desenvolver na era do DOS, escrevendo aplicações
com Turbo Pascal. Desde então, ele sempre escreveu código, passando de
Object Pascal para Delphi. Publica regularmente blogs, oferece webinars e
tem uma lista de discussão para a qual muitos desenvolvedores Delphi
estão inscritos. Sua empresa GDK Software é uma autoridade na
programação linguagem Delphi (e Mendix, mas isso está fora do escopo
deste guia) e tem ajudado centenas de empresas com desenvolvimento
Delphi, manutenção e atualizações do Delphi. Confira
www.gdksoftware.com/knowledgebase para vários conteúdos
relacionados ao Delphi, e vá para www.gdksoftware.com/delphi-hero para
assinar o GDK Delphi lista de correio.
Introdução

Delphi (ou melhor, Pascal) é uma linguagem fácil de aprender. Há boas

razões para que muitas escolas ensinassem Pascal aos alunos. A estrutura
clara, sintaxe simples e velocidade de desenvolvimento tornam uma
linguagem popular para estudantes e professores.
Também entrei em contato com o Pascal dessa forma, começando pelo
Turbo Pascal.
Esta implementação do Pascal foi comercializada pela Borland e era na
época muito bem-sucedido, principalmente porque o Borland Pascal era
muito barato. Aqui na Holanda, você pode comprar o ambiente de
desenvolvimento por apenas 100 Guilders (cerca de 50 euros).
A grande vantagem do Pascal é que é muito fácil começar. Especialmente
quando o Delphi foi amplamente utilizado, e o RAD (Rapid Application
Development) tornou-se popular, muitos aplicativos foram desenvolvidos.
Infelizmente, há uma desvantagem a esta velocidade: também é fácil
escrever código de tal forma que se torne uma bagunça de funções,
procedimentos e dependências entrelaçados.
Com esta lista de verificação de programação Delphi, espero dar a você
algumas ferramentas para escrever código mais rápido, melhor e acima de
tudo, mais estruturado. Os temas variam muito de ferramentas e plugins a
métodos técnicos e técnicas de programação. Mas todos eles visam tornar
sua vida mais fácil. Apreciar!
Use as ferramentas certas

O Delphi é, pronto para uso, uma ótima ferramenta para desenvolvimento

extremamente rápido. No entanto, se você tiver projetos grandes, pode
fazer sentido instalar alguns plugins externos. Isso não apenas permite que
você navegue pelo código mais rapidamente, mas também pode ajudá-lo a
estruturar seus aplicativos. Na GDK Software, geralmente usamos os
seguintes plugins:

GEXPERTS
GExperts adiciona alguns recursos muito úteis ao Delphi, como GrepSearch
Alt + Shift + S, Lista de procedimentos Ctrl + G, RenameComponents e
outros atalhos muito úteis.
Chegaremos a esses atalhos no Capítulo Dois. Dê uma olhada nas
ferramentas Componentes ao Código e Lista de Procedimentos também.

Download: https://blog.dummzeuch.de/experimental-gexperts-version/
DDEVEXTENSIONS
Adoramos DDevExtensions para a caixa de diálogo de substituição Find
Unit/Use Unit (Alt + F11).
A caixa de diálogo padrão do Delphi Use-Unit mostra apenas os arquivos do
grupo de projetos.
DDevExtensions substitui a caixa de diálogo por uma que não mostra
apenas o grupo de projetos mas também todos os arquivos que o
compilador pode ver. Nunca mais navegue para os usos seção e insira uma
unidade manualmente - basta pressionar Alt-F11.

Download: https://github.com/DelphiPraxis/DDevExtensions

SPRING FRAMEWORK
O framework Spring é uma biblioteca de código aberto com um conjunto
muito útil de classes de coleção baseadas em interface, por exemplo, o IList
de interface genérica, dicionários, etc. Ele também contém um ótimo
framework de injeção de dependência e várias bibliotecas de criptografia.
Download: https://bitbucket.org/sglienke/spring4d/src/master/
MADEXCEPT
Esta ferramenta é usada para enviar informações e dados sobre falhas e
exceções que acontecem na produção ambiente para os desenvolvedores.
Outra ferramenta que pode ser usada para isso é o Eurekalog. Eu usei os
dois e não tenho uma clara preferência. Mas pelo menos: use um deles, ele
irá ajudá-lo a encontrar a fonte de bugs.

http://madshi.net/
https://www.youtube.com/watch?v=chtkIdU1avA&ab_channel=T2Ti

OUTROS QUE MERECEM

MMX: https://www.mmx-delphi.de/

CN Pack: https://www.cnpack.org/index.php?lang=en

Testinsight: https://bitbucket.org/sglienke/testinsight/wiki/Home
Fique longe do rato!
Atalhos IDE são a maneira mais fácil de acelerar o desenvolvimento. Sem
dúvida, a maioria de nós conhecemos os atalhos mais importantes em
Delphi, mas vamos compartilhar quais eu uso regularmente.

Bookmarks
Salve os pontos no código onde você quer voltar. Navegue facilmente pelo
código. Defina um marcador com Ctrl + Shift + <Number> e use-o com Ctrl
+ <Number>.
Salte entre a interface de métodos e a implementação com Ctrl + Shift +
seta para cima ou Ctrl + Shift + seta para baixo. Instale e use o Grep Search
de GExperts, pesquisando mais rápido e representando os resultados em
uma visão melhor do que o Delphi IDEvia Alt + Shift + S. (GExperts) Pesquise
e vá para um método com Ctrl + G.
Use Alt + F11 para adicionar uma unidade ao seu código (use com
DDevExtensions).
Use um gerenciador de área de transferência para copiar várias coisas sem
trocar continuamente entre copiar/colar, copiar/colar, etc. Preferimos CLCL
(https://www.nakka.com/soft/clcl/index_eng.html) para o histórico da
área de transferência. Você pode usá-lo facilmente pressionando Alt + C.
Apesar de não ser um sugestão específica do Delphi, acho que será de
grande ajuda.
OUTROS ATALHOS POPULARES SÃO

Os óbvios
Salvar: Ctrl + S e salvar tudo: Ctrl + Shift + S
Execute: F9, compile: Ctrl + F9 e construa: Shift + F9
Parar de executar/depurar: Ctrl + F2
Adicione um arquivo ao projeto: Shift + F11
Complete uma classe: Ctrl + Shift + C (ou seja, crie os métodos no seção de
implementação).
Declare uma variável: Ctrl + Shift + V
Declare uma variável de classe: Ctrl + Shift + D (o mesmo que V, mas em
vez de a variável local, você terminará com uma variável de classe).
Renomear uma variável: Ctrl + Shift + E
Vá para a unidade: Ctrl + Enter (quando o cursor estiver no nome de uma
unidade). Mais rápido do que Ctrl + clique, mas só funciona se o Delphi
puder localizar a unidade.
Alinhe suas linhas de código com Ctrl + Alt + Z (GExperts).
Sincronize os parâmetros do procedimento ou da função: Ctrl + Alt + Shift
+P

Atalhos completo
https://docwiki.embarcadero.com/RADStudio/Alexandria/en/Default_Key
board_Shortcuts
Código limpo
É impossível exagerar a importância do Código Limpo. Escrever código
limpo faz seu código mais legível, mais fácil de manter e mais fácil de
entender. Se você não leu o livro 'Clean Code' de Robert C. Martin, eu o
encorajo a fazer assim. Isso realmente ajuda você a escrever um código
melhor. A definição mais popular de código limpo é o código que é fácil de
entender e fácil de mudar. Embora isso possa parecer simples, é bastante
difícil de executar. Manter seu código simples, você deve reduzir a
complexidade o máximo possível. Isso significa que mais simples é sempre
melhor. No entanto, você nunca deve sacrificar a legibilidade ou
manutenção para tornar seu código mais simples. Existem algumas lições
gerais a serem aprendidas se você quiser escrever um código limpo. Como
um desenvolvedor delphi você provavelmente trabalha com código novo e
legado. Especificamente para legado código, a regra do escoteiro se aplica:
deixe o acampamento mais limpo do que você o encontrou. Certifique-se
de melhorar o código quando estiver refatorando. Dividir funções maciças
em Menores; dê nomes sensatos às variáveis; e tornar o código legível.
Afinal, você gasta muito do seu tempo lendo código, não escrevendo!
Então, por que não ajudar a si mesmo e outros para facilitar a parte da
leitura?
A verdade só pode ser encontrada em um lugar: o código Robert C.Martin
Para manter seus procedimentos e funções limpos, tente mantê-los o
menor possível, e deixá-los fazer apenas uma coisa. Se sua função está
fazendo mais de “uma coisa”, é um momento perfeito para extrair isso para
outra função. Essa é uma das razões pelas quais fazemos não misture regras
de negócios com código GUI. Não misturamos consultas SQL com
comunicação protocolos. Mantemos o código que é alterado por diferentes
motivos separados para que alterações em uma parte não quebram outras
partes. Em Delphi isso significa que você não escreva sua lógica de negócios
por trás do clique de um botão, mas também que você não use um módulo
de dados para recuperar dados de um banco de dados e gerar relatórios.
Os procedimentos e funções também devem ter o menor número possível
de parâmetros. Zero seria ser o melhor, um ou dois está bem, três e acima,
não. Porque se uma função ou procedimento requer mais de 3 parâmetros,
é provável que alguns desses parâmetros possam ser envolto em uma
classe.
Use nomes facilmente pronunciados para variáveis e funções e
procedimentos, e não usar abreviaturas. Talvez você economize um
segundo para digitar a função AddCmt, mas parece horrível, e não é fácil
lembrar ou procurar.

Escolha também um nome para mostrar sua intenção. O objetivo da

variável deve ser compreensível para alguém lendo esse nome. Escreva o
nome como você falaria.

Ser consistente. Use uma palavra para funções semelhantes. Não use “get”
em uma classe e “buscar” em outro. Comentários são difíceis de manter e
não dizem a verdade sobre o código, então tente Evite-os. Eles estão quase
sempre desatualizados ou redundantes. Com a ajuda das dicas já foi
mostrado, seu código deve se explicar.
Além disso, não comente o código não utilizado, apenas exclua-o. Você tem
um sistema de controle de origem de qualquer maneira (você tem um,
certo?). A única razão para usar comentários é para expressar a importância
de alguns pontos no código.
Nomes de uma única letra representam um problema particular, pois não
são fáceis de localizar muito texto. Nomes de uma única letra só podem ser
usados como variáveis locais dentro de procedimentos. O comprimento de
um nome de variável deve corresponder ao tamanho de seu escopo. E por
último, evite codificações como colocar L na frente de variáveis locais. Na
GDK também não use o prefixo A com parâmetros. A única exceção a esta
regra para nós é nos campos private de uma classe, onde usamos o prefixo
F.

O uso adequado dos comentários é para compensar o nosso fracasso em

nos expressamos em código. Observe que Usei a palavra “fracasso”. Eu quis
dizer isso. Comentários são sempre falhas
Princípios sólidos
Na engenharia de software, SOLID é um acrônimo para cinco princípios de
projeto destinados para tornar os projetos de software mais
compreensíveis, flexíveis e sustentáveis. Os princípios SOLID são tornados
famosos por Robert C. Martin. Embora tenha inventado a maioria dos
princípios que ele promove, o Princípio da Substituição de Liskov foi
inventado por BarbaraLiskov, enquanto o Princípio Aberto-Fechado foi
inventado por BertrandMeyer.
Os 5 principios são:
1. The Single Responsibility Principle: As classes devem ter uma única
responsabilidade e, portanto, apenas uma única razão para mudar.

2. The Open-Closed Principle: As classes e outras entidades devem ser

abertas para extensão, mas fechado para modificação.

3. The Liskov Substitution Principle: Os objetos devem ser substituíveis por seus
subtipos.

4. The Interface Segregation Principle: Os clientes não devem ser forçados

a dependerem de interfaces que eles não usam.

5. The Dependency Inversion Principle: Depende de abstrações e não de

concreções.
CODIFICAÇÃO, A MANEIRA DELPHI

Até agora, cobrimos algumas dicas gerais, alguns métodos de programação

e princípios de desenvolvimento. Embora eles sejam adaptados em torno
do Delphi, você pode aplicar estes para outras línguas também. Nesta parte,
falarei sobre alguns vários Diretrizes e dicas de codificação relacionadas ao
Delphi. Em nenhuma ordem particular: Corrija todas as dicas e avisos.
Quando você tiver feito isso em seus projetos existentes, todas as novas
dicas ou avisos chamarão sua atenção imediatamente. Trabalhei com
projetos que produziu algumas centenas de avisos e projetos sem nenhum.
Dentro no último caso, o trabalho era muito mais agradável e dá-lhe uma
sentimento positivo e confiança para fazer mudanças no código-fonte.
Se você estiver trabalhando com objetos, certifique-se de escrever
imediatamente o código para libertar os objetos. Ou, melhor ainda, fazer
uso de objetos com interface, para que você possa fazer uso do coletor de
lixo do Delphi.
Use as diretrizes de codificação Object Pascal:
https://blogs.embarcadero.com/new-delphis-object-pascal-style-guide/.
A introdução da versão original deste documento expressa isso muito bem:
“Object Pascal é uma linguagem lindamente projetada. Um das suas
grandes virtudes é a sua legibilidade. Esses padrões são projetados para
melhorar essa legibilidade do código Object Pascal. Quando os
desenvolvedores seguem as simples convenções estabelecidas neste guia,
eles estarão promovendo padrões que beneficiam todos os
desenvolvedores Delphi usando um estilo uniforme que é fácil de ler.
Esforço para impor esses padrões aumentará o valor do código-fonte de um
desenvolvedor, particularmente durante os ciclos de manutenção e
depuração.”
Faça uso dos Live Templates (ou Code Templates, como eram
anteriormente chamado). Desde o Delphi 3, esses templates estão
presentes no Delphi, mas ainda vemos que esse recurso útil está
subvalorizado. A maioria dos desenvolvedores estão familiarizados com o
preenchimento de código de if ou while, onde a estrutura da instrução é
criada automaticamente. Mas com os Live Templates você pode
automatizar muito mais. Se você quiser para ver uma lista dos modelos
dinâmicos disponíveis, você pode usar o atalho Ctrl + J

Quanto mais você automatizar, melhor. Por isso é recomendável que você
crie seus próprios modelos ao vivo para código usado com frequência em
seu programa. Este pode ser feito facilmente via Arquivo -> Novo -> Outro
-> Modelo de Código. Para maiores informações sobre a estrutura dos
templates, acesse o wiki da Embarcadero. Faça uso das enormes bibliotecas
existentes do Delphi. Quase tudo que você pode pensar foi escrito nos
últimos 27 anos de Delphi. Faça uso de listas como
https://github.com/Fr0sT-Brutal/awesome-pascal para encontrar a
ferramenta ou biblioteca certa para o trabalho.

 Corrija todas as dicas e avisos

 Verifique se você eliminou todos os vazamentos de memória
 Verifique as diretrizes do Object Pascal Coding
 Usar modelos dinâmicos
PRÓXIMOS PASSOS
Chegamos ao fim deste livro. Mas espero que este seja o começo de
sua desenvolvimento adicional no campo de Delphi. Como em muitas
coisas na vida, você sempre ser capaz de aprender mais e melhorar a
si mesmo. espero ter te ajudado um pouco com este livro. Se você
quiser ler mais, posso recomendar os seguintes livros:

Object Pascal Handbook (2021 edition) – Marco Cantú

https://lp.embarcadero.com/Object-Pascal-Handbook-2021

Coding in Delphi – Nick Hodges

https://lp.embarcadero.com/CodinginDelphi

More Coding in Delphi – Nick Hodges

https://lp.embarcadero.com/MoreCodinginDelphi

Code Faster in Delphi – Alister Christie

https://lp.embarcadero.com/CodeFasterinDelphi