O

PROGRAMADOR
CURIOSO

O GUIA DO
PROGRAMADOR
WEB 1.0
61
61 DICAS
DICAS PARA
PARA APRENDER
APRENDER A A
PROGRAMAR
PROGRAMAR E E SE
SE TORNAR
TORNAR
UM
UM DESENVOLVEDOR
DESENVOLVEDOR DE DE
SUCESSO
SUCESSO
PR
P RO
ODDU
UZZIID
DOOP
POOR
R FFL
LAAV
VIIO
OBBA
ALLB
BIIN
NOO
 índice
⦁ Introdução --------------------------------------------------------------------------- Página 1
⦁ Escolha uma linguagem de programação ----------------------------- Páginas 2 à 3
⦁ Prática gera mais resultados que teoria ------------------------------------- Página 4
⦁ A lógica de programação em primeiro lugar -------------------------------- Página 5
⦁ Procure um amigo para estudar ----------------------------------------------- Página 6
⦁ Crie um projeto seu e compartilhe com todos ----------------------- Páginas 7 à 8
⦁ Pratique pelo menos 25 minutos por dia ------------------------------------ Página 9
⦁ Estude com conteúdo estruturado ------------------------------------------- Página 10
⦁ Não tenha medo de errar ------------------------------------------------------- Página 11
⦁ Não se limite ao que é ensinado em cursos e livros --------------------- Página 12
⦁ Converse com outros programadores --------------------------------------- Página 13
⦁ Tenha um mentor ----------------------------------------------------------------- Página 14
⦁ Crie um projeto que você tenha orgulho ------------------------------------ Página 15
⦁ Não tenha medo de mudar de caminho ------------------------------------- Página 16
⦁ Seja pago para continuar aprendendo -------------------------------------- Página 17
⦁ Não dê ouvidos à programadores frustrados ------------------------------ Página 18
⦁ Não pule etapas ------------------------------------------------------------------- Página 19
⦁ Não escolha uma linguagem difícil ------------------------------------------- Página 20
⦁ Consiga livros sobre a linguagem -------------------------------------Página 21 O
PROGRAMADOR
⦁ Tenha um objetivo ---------------------------------------------------------Página 22 CURIOSO
⦁ Não se assuste -------------------------------------------------------------------- Página 23
⦁ Não tenha pressa ----------------------------------------------------------------- Página 24
⦁ Tenha uma boa lógica e um bom raciocínio ------------------------------- Página 25
⦁ Não evolua maus hábitos ------------------------------------------------------- Página 26
⦁ Relaxamento ----------------------------------------------------------------------- Página 27
⦁ Tenha bastante curiosidade ---------------------------------------------------- Página 28
⦁ Adote uma rotina de estudos -------------------------------------------------- Página 29
⦁ Tenha um bom conhecimento em Inglês ----------------------------------- Página 30
⦁ Se preocupe com o que constrói --------------------------------------------- Página 31
⦁ Pense sobre o seu trabalho ---------------------------------------------------- Página 32
⦁ Dê opções, não crie desculpas ------------------------------------------------ Página 33
⦁ Não conviva com janelas quebradas ---------------------------------------- Página 34
⦁ Seja um catalisador de mudanças ------------------------------------------- Página 35
⦁ Veja o quadro geral -------------------------------------------------------------- Página 36
⦁ Faça da qualidade um requisito ---------------------------------------------- Página 37
⦁ Invista regularmente no seu Portfolio de Conhecimento --------------- Página 38
⦁ Analise de forma crítica o que você lê ou escuta ------------------------ Página 39
⦁ Não é o que você diz, é a maneira como você diz ---------------------- Página 40
⦁ DRY - Don't Repeat Yourself (Não se repita) ----------------------------- Página 41
⦁ Faça ser fácil de reutilizar ----------------------------------------------- Página 42 O
PROGRAMADOR
⦁ Elimine os efeitos colaterais entre coisas não relacionadas --- Página 43 CURIOSO
⦁ Não existem decisões finais ---------------------------------------------------------- Página 44
⦁ Use "tracer bullets" para achar o alvo ---------------------------------------------- Página 45
⦁ Faça protótipos para aprender ------------------------------------------------------- Página 46
⦁ Programe perto do problema --------------------------------------------------------- Página 47
⦁ Estime para evitar surpresas --------------------------------------------------------- Página 48
⦁ Itere o tempo com o código ----------------------------------------------------------- Página 49
⦁ Escreva e Rabisque ------------------------------------------------------------------- --Página 50
⦁ Use um bom editor --------------------------------------------------------------------- -Página 51
⦁ Sempre use versionamento de código --------------------------------------------- Página 52
⦁ Corrija o problema, não fique culpando ---------------------------------------------Página 53
⦁ Aprenda manipulação de texto ------------------------------------------------------- Página 54
⦁ Escreva código que faça código ----------------------------------------------------- Página 55
⦁ Você não pode escrever um software perfeito ----------------------------------- Página 56
⦁ Faça o Design com contratos -------------------------------------------------------- Página 57
⦁ Quebre cedo ------------------------------------------------------------------------------ Página 58
⦁ Use assertions para previnir o impossível ----------------------------------------- Página 59
⦁ Use exceptions para problemas excepcionais ------------------------------------ Página 60
⦁ Termine o que você começou --------------------------------------------------------- Página 61
⦁ Configure, não integre ------------------------------------------------------------------ Página 62
⦁ Coloque abstrações no código, detalhes no metadata ------------------------- Página 63
⦁ Dica final -------------------------------------------------------------------------- Página 64 O
PROGRAMADOR
⦁ Observações finais ----------------------------------------------------------- Página 65 CURIOSO
 O GUIA DO Prepare-se para as 61 dicas mais

PROGRAMADOR importantes para quem está iniciando na

WEB 1.0 área da Tecnologia da Informação.

O
PROGRAMADOR
Observação: Todas as palavras destacadas em laranja são links clicáveis. 1/65 CURIOSO
 DICA 01
Escolha uma linguagem de programação
Em diversos grupos, redes sociais ou em qualquer tipo de comunidade
de estudantes/programadores, uma das maiores dúvidas de qualquer
iniciante é:
“Com qual linguagem de programação devo começar?”
Para esse tipo de pergunta, é bem comum obtermos diversas respostas,
como por exemplo, C, Java, C#, C++, Ruby, Python, PHP, JavaScript
entre diversas outras linguagens que temos atualmente.
Entretanto, quando estamos começando, a linguagem em si não importa,
pois a lógica é a mesma para todas elas.
Neste exato momento, você pode estar se perguntando:
O
PROGRAMADOR
CURIOSO
2/65
“Se a lógica é a mesma para todas, pouco importa qual linguagem eu
devo utilizar?”.
Teoricamente sim, porém, na prática, recomendo fortemente que
escolha uma linguagem que possua menos barreiras na curva de
aprendizagem.
Em outras palavras, linguagens como por exemplo o JavaScript, que
pode ser escrito em qualquer editor de texto e executado em qualquer
navegador (até mesmo o IE em versões não tão antigas), é uma ótima
escolha, pelos seguintes motivos:
-Não precisa instalar uma ferramenta específica para codificar.
-É uma linguagem de fácil aprendizagem.
Não é à toa que o pacote Full-Stack utiliza essa e várias outras
linguagens de programação em seus cursos para a aprendizagem de
seus alunos. Acesse o pacote FULL-STACK clicando aqui.
3/65

O
PROGRAMADOR
CURIOSO
 DICA 02
Prática gera mais resultados que teoria
Além da linguagem, um dos pontos principais quando estamos
aprendendo é justamente a prática. Mas como assim a prática?
Até hoje não conheci nenhum programador que só aprendeu na
teoria!
É isso mesmo, colocar a mão na massa, tentativa e erro, praticar
diversas vezes até compreender um conceito ou algo novo que viu, faz
parte do dia-a-dia de qualquer programador.
Portanto, tudo que você escutar, ler ou assistir, coloque em prática,
pois quanto mais praticamos, mais compreendemos.
Por exemplo, já aconteceu diversas vezes de eu só entender o que
realmente o meu código estava fazendo na quinta vez que o
implementei!
E confesso que foi a partir dessa sensação de “domínio do que estava
fazendo” que eu comecei a me apaixonar por programação. O
PROGRAMADOR
CURIOSO
4/65
 DICA 03
A lógica de programação em primeiro lugar
Uma das dicas mais importantes (se duvidar a mais importante de
todas) para qualquer iniciante é procurar aprender, antes de tudo,
a lógica de programação.
Mas por que a lógica de programação? Por que não orientação à
objetos, programação funcional, estrutura de dados ou qualquer outro
tópico da programação?
É justamente porque todos os outros tópicos que envolvem
programação são baseados na lógica de programação. Em outras
palavras, a lógica de programação são os ingredientes do bolo, ou
seja, programar sem lógica de programação é a mesma coisa que
tentar fazer um bolo sem ingredientes.
Com toda certeza esse bolo não vai sair como o esperado!
O
5/65 PROGRAMADOR
CURIOSO
 DICA 04
Procure um amigo para estudar
Além das dicas mencionadas, uma das melhores escolhas que você
fará na vida é procurar um amigo para estudar junto com você! Então
você pode pensar:
“Mas eu não consigo aprender sozinho?”
Sim, você consegue, porém, ter uma pessoa próxima para que você
consiga exibir suas ideias, discutir implementações ou até mesmo
compartilhar o que aprendeu em um novo curso, faz toda a diferença!
Em diversas vezes eu senti mais vontade em aprender uma nova
tecnologia, conceito ou realizar um novo curso a partir de um feedback
de amigo.
Portanto, um amigo ali do seu “lado” para que você possa
compartilhar suas experiências e ele as dele, fará com que, tanto você
quanto ele, compreendam com mais facilidade tudo que estudaram.
O
6/65 PROGRAMADOR
CURIOSO
 DICA 05
Crie um projeto seu e compartilhe com todos
Uma das melhores sensações para qualquer programador é
justamente terminar um projeto e compartilhá-lo com algum familiar,
amigo ou até mesmo com a comunidade. Portanto, durante o seu
aprendizado, coloque tudo em prática em um projeto seu e o
compartilhe!
Lembrando que não precisa ser um projeto mega complexo e com
diversas funcionalidades, é a partir de projetos como calculadoras
básicas, contas bancárias ou cadastro de vendas que damos os
nossos primeiros passos.
Além disso, uma das práticas comuns é compartilhamos nossos
projetos com a comunidade a partir de um github, por exemplo.
O
PROGRAMADOR
CURIOSO
7/65
 Dessa forma, podemos pegar um feedback de programadores mais
experientes.
Você também pode aprender a programar com o melhor e mais
completo curso de programação do Brasil, o pacote Full-Stack, com
uma sequência de cursos focada em quem está começando a
programar. E além disso, são mais de mil aulas e várias tecnologias
que você irá aprender no pacote Full-Stack, que é desenvolvido pela
Danki Code, uma das maiores plataformas de ensino tecnológico do
país.
Inscreva-se no pacote Full-Stack agora mesmo clicando aqui.

8/65

O
PROGRAMADOR
CURIOSO
 DICA 06
Pratique pelo menos 25 minutos por dia
Mesmo que você seja um mega empresário como o Flávio Augusto,
definitivamente você consegue separar 25 minutos para escrever
código todos os dias.
Pode ser antes de sair de casa para o trabalho, depois do almoço ou
antes de dormir, mas tem que ser todos os dias.
Você não irá se tornar um programador profissional escrevendo
código só nos finais de semana.
Programar precisa virar um hábito.
9/65

O
PROGRAMADOR
CURIOSO
 DICA 07
Estude com conteúdo estruturado
Pare de assistir apenas vídeos aleatórios no Youtube e achar que
algum dia vai se tornar um programador.
Além da prática diária da programação, é importante que você tenha
um bom conteúdo para acompanhar, seja um livro, curso ou faculdade.

Curso indicado: Pacote Full-Stack

10/65

O
PROGRAMADOR
CURIOSO
 DICA 08
Não tenha medo de errar
Errar faz parte do dia-a-dia do programador.
Eu sou programador há mais de 10 anos, e todos os dias cometo
erros. Só cometo erros porque estou programando, e a cada dia
aprendo algo novo com esses erros.
Se você não está errando, provavelmente não está programando.

11/65

O
PROGRAMADOR
CURIOSO
 DICA 09
Não se limite ao que é ensinado em cursos e
livros
Não seja apenas um papagaio do código.
Seguir tutoriais de cursos e livros é importante, porém, mais
importante que isso, é sair da zona de conforto e fazer alterações no
código desses tutoriais, escrevendo seu próprio código.
Essa é uma ótima maneira de saber se entendeu os conceitos e
técnicas ensinadas.

12/65

O
PROGRAMADOR
CURIOSO
 DICA 10
Converse com outros programadores

Frequente eventos e conheça outros programadores, pois é uma

forma de fazer networking e ficar por dentro do mercado.

Sempre que vou à eventos, descubro oportunidades de emprego em 3

ou 4 empresas diferentes.

13/65

O
PROGRAMADOR
CURIOSO
 DICA 11
Tenha um mentor
Ter um programador experiente para dar dicas e te ajudar nas
dificuldades é sem dúvida uma das coisas mais importantes para
programadores iniciantes.
É um grande atalho para o aprendizado de técnicas e macetes que
você não encontra em nenhum livro ou faculdade.
Eu, particularmente, tive vários mentores no início de carreira e hoje
tenho orgulho de ser mentor de várias outras pessoas.
Acesse a Danki Code e tenha o seu mentor: Clique aqui
14/65

O
PROGRAMADOR
CURIOSO
 DICA 12
Crie um projeto que você tenha orgulho
Já falei aqui sobre isso, mas vou reforçar, a melhor forma de aprender
a programar é desenvolvendo projetos.
Se não tem estágio ou emprego para desenvolver projetos para outras
empresas, comece a desenvolver seus próprios projetos.
É um ótima forma de testar técnicas e ao mesmo tempo, criar um
portfólio.
15/65

O
PROGRAMADOR
CURIOSO
 DICA 13
Não tenha medo de mudar de caminho
Algumas pessoas acham que só porque aprenderam C++ na faculdade,
elas obrigatoriamente precisam arrumar um emprego de C++, trabalhar a
vida inteira com C++ e se aposentar programando em C++.
Não é bem assim que funciona.
Você precisa estar aberto à mudanças.
Mudança de linguagem de programação, área de atuação e até
mesmo mudança de cidade ou país.

16/65

O
PROGRAMADOR
CURIOSO
 DICA 14
Seja pago para continuar aprendendo
Depois que você já está programando todos os dias e já desenvolveu
seus side projects, é importante que comece a ser pago pelos seus
trabalhos de programador, mesmo que seja um valor baixo no início,
como estagiário ou freelancer.
O que diferencia um programador profissional de um hobbysta, é estar
sendo pago para programar.
17/65

O
PROGRAMADOR
CURIOSO
 DICA 15
Não dê ouvidos à programadores frustrados
Já convivi com muitos programadores apaixonados pelo trabalho e
também com programadores frustrados, que só escolheram a
profissão para arrumar um emprego.
E veja, todos os programadores de sucesso que conheço, que
ganham excelentes salários, são exatamente os apaixonados, e não
os frustrados.
E você, já aprendeu a programar? Se ainda não aprendeu ou ainda
não se sente seguro para desenvolver projetos reais, convido você
para acessar esse link aqui e conhecer o Pacote Full-Stack. Lá você
irá receber mentoria de um programador experiente, criar seu portfólio,
desenvolver dezenas de projetos de software e ficar preparado para o
mercado de trabalho ou para criar o próprio negócio.
18/65
O
PROGRAMADOR
CURIOSO
 DICA 16
Não pule etapas
Um erro bastante comum entre programadores iniciantes é achar que
podem pular etapas do processo de aprendizagem, como não fazer
exercícios e não entender completamente os conceitos mais
importantes em cada estágio do processo.
Procure sempre se perguntar “o que preciso saber para conseguir
fazer essa tarefa?”.
E só continue o aprendizado se achar que realmente possui todos os
conhecimentos prévios para dar o próximo passo.
19/65

O
PROGRAMADOR
CURIOSO
 DICA 17
Não escolha uma linguagem difícil
Existem várias linguagens famosas, como Java e C#, e não ter
conhecimento sobre elas de primeira pode causar alguma ansiedade
nos programadores iniciantes, fazendo com que queiram aprendê-las
logo de cara. E essa não é a melhor maneira de se aprender a
programar. Outras linguagens, como Python, são especialmente
pensadas para serem simples e intuitivas.

Acesse o pacote Full-Stack e aprenda as melhores linguagens de

programação da atualidade: acesse aqui
20/65

O
PROGRAMADOR
CURIOSO
 DICA 18
Consiga livros sobre a linguagem
Cada linguagem possui uma sintaxe específica e particularidades em
seu funcionamento, estudá-las mais a fundo ajuda muito no processo
de aprendizagem.
Os livros voltados para determinadas linguagens discutem desde os
aspectos mais básicos delas até os mais avançados.
21/65

O
PROGRAMADOR
CURIOSO
 DICA 19
Tenha um objetivo
Você seguindo um objetivo para aprender a programar fica muito mais
fácil, anote em algum lugar, numa folha ou até mesmo num arquivo de
texto o seu objetivo e quando estiver desanimado, leia.
Não aprenda a programar por motivos bobos, como esse por
exemplo: "Tenho que programar para ser hacker", por que um hacker
não é o que a mídia diz ser, por isso procure saber o que é realmente
um hacker.
22/65

O
PROGRAMADOR
CURIOSO
 DICA 20
Não se assuste
Quando você vê algo novo na linguagem que você está programando,
sempre pense: isso é fácil.

Porque nem tudo é tão difícil quanto aparenta ser.

Nada é dificil quando você tem foco para aprender.

23/65

O
PROGRAMADOR
CURIOSO
 DICA 21
Não tenha pressa
Sem um professor, você mesmo deve determinar o seu tempo de
aprendizado para cada capítulo. Nunca avance sem ter aprendido o
capítulo anterior.
Caso você não esteja conseguindo aprender um capítulo, tente outra
vez, em outra hora em que sua mente esteja mais descansada.
Não se apresse, por que você será um eterno aprendiz.
24/65

O
PROGRAMADOR
CURIOSO
 DICA 22
Tenha uma boa lógica e um bom raciocínio
Com uma boa lógica e um bom raciocínio, você terá mais facilidade
em aprender a programar.
Programação não é baseada apenas em decorar os comandos como
alguns pensam e me disseram, é preciso muito mais que isso, portanto
ter uma boa lógica é fundamental.
Uma boa dica para evoluir a lógica e o raciocínio é a matemática.
25/65

O
PROGRAMADOR
CURIOSO
 DICA 23
Não evolua maus hábitos

Para não evoluir maus hábitos, é muito importante ver como uma
pessoa que programa há muito tempo se comporta.
Mas cuidado ao seguir os exemplos, dependendo do nível da pessoa
que o programou.

26/65

O
PROGRAMADOR
CURIOSO
 DICA 24
Relaxamento
Bem, agora essa dica é pessoal, não sei se vai funcionar com vocês,
entretanto funcionou comigo. Beba café quando estiver programando,
ouça uma variedade de músicas calmas, mas quando estiver cansado
(não desanimado), beba refrigerante e tome sorvete bem gelado, isso
esfria a cabeça.
27/65

O
PROGRAMADOR
CURIOSO
 DICA 25
Tenha bastante curiosidade
Hoje em dia é possível encontrar na Internet uma vasta quantidade de
informação à respeito de programação. Por isso, é válido ir atrás de tutoriais
online, artigos e também vídeos.
No entanto, é pertinente evitar procurar material aleatório sobre o tema,
pesquisando, por exemplo, um conceito simples e depois partindo logo para
um mais complexo.
É válido também pesquisar materiais impressos, tais como livros destinados
para o tema. Além disso, para quem é iniciante no assunto, é importante
começar estudando linguagens mais simples de programação, tais como a
Python.
Esteja também sempre atento às novidades que surgem na área. A
tecnologia atual avança em um ritmo bastante rápido e é interessante
conhecer o que está sendo feito de mais moderno nesse segmento.
28/65 O
PROGRAMADOR
CURIOSO
 DICA 26
Adote uma rotina de estudos
Aprender a programar é semelhante com o ato de aprender uma nova
língua. Portanto, é necessário adotar uma boa dose de disciplina por meio de
uma rotina básica de estudos.
Nesse contexto, vale reservar alguma hora específica do dia para praticar e
pesquisar, criando assim um hábito diário de estudos. Com isso, o seu grau
de aprendizado vai evoluir de maneira gradual.
Além do mais, um perfil autodidata é fundamental para o aprendizado em
programação. É óbvio que existem cursos e aulas destinados para a área,
porém, o empenho e a curiosidade em ir além do que é mostrado em aula
também conta pontos.
29/65

O
PROGRAMADOR
CURIOSO
 DICA 27
Tenha um bom conhecimento em Inglês
Se aprender a programar é também parecido com aprender um novo
idioma, não esqueça então que o inglês é muito importante para quem
estuda essa área.
Muito material de qualidade sobre o assunto é disponibilizado em
inglês.

30/65

O
PROGRAMADOR
CURIOSO
 DICA 28
Se preocupe com o que constrói

Exemplo:

"Por que gastar sua vida desenvolvendo software se você não se

preocupa com ele ser bom?"

31/65

O
PROGRAMADOR
CURIOSO
 DICA 29
Pense sobre o seu trabalho

Desligue o piloto automático e tome o controle.

Constantemente critique e avalie o seu trabalho.

32/65

O
PROGRAMADOR
CURIOSO
 DICA 30
Dê opções, não crie desculpas

Ao invés de dar desculpas, dê opções.

Não diga que não pode ser feito, explique como pode ser feito.

33/65

O
PROGRAMADOR
CURIOSO
 DICA 31
Não conviva com janelas quebradas

Corrija designs ruins, decisões erradas e código ruim quando vê-los.

34/65

O
PROGRAMADOR
CURIOSO
 DICA 32
Seja um catalisador de mudanças

Você não pode forçar as pessoas a mudarem. Mas, você pode

mostrá-las como o futuro pode ser e ajudá-las a participar na criação
disso.

35/65

O
PROGRAMADOR
CURIOSO
 DICA 33
Veja o quadro geral

Não fique tão focado só nos detalhes a ponto de esquecer de verificar

o que está acontecendo ao se redor.

36/65

O
PROGRAMADOR
CURIOSO
 DICA 34
Faça da qualidade um requisito

Envolva os usuários para determinar a real qualidade que o projeto

precisa ter e cumpra.

37/65

O
PROGRAMADOR
CURIOSO
 DICA 35
Invista regularmente no seu Portfolio de
Conhecimento
Faça do aprender um hábito.

Aprenda a programar com o melhor e mais completo curso de

programação do Brasil, o pacote Full-Stack: Acesse aqui

38/65

O
PROGRAMADOR
CURIOSO
 DICA 36
Analise de forma crítica o que você lê ou escuta

Não seja influenciado pelo hype das coisas.

Analise a informação em termos de você e seu projeto.

39/65

O
PROGRAMADOR
CURIOSO
 DICA 37
Não é o que você diz, é a maneira como você diz

Não faz sentido você ter grandes ideias se você não consegue
comunicá-las efetivamente.

40/65

O
PROGRAMADOR
CURIOSO
 DICA 38
DRY - Don't Repeat Yourself (Não se repita)

Cada pedaço de código deve ser único e o mais genérico possível.

41/65

O
PROGRAMADOR
CURIOSO
 DICA 39
Faça ser fácil de reutilizar

Se é fácil de reutilizar, pessoas vão reutilizar.

Crie um ambiente que suporte a reutilização.

42/65

O
PROGRAMADOR
CURIOSO
 DICA 40
Elimine os efeitos colaterais entre coisas não
relacionadas

Elimine os efeitos colaterais entre coisas não relacionadas.

43/65

O
PROGRAMADOR
CURIOSO
 DICA 41
Não existem decisões finais

Nenhuma decisão é escrita em pedra. Ao invés disso, pense que as

decisões são escritas em areia de praia, e se planeje para ir sempre

mudando e adaptando.

44/65

O
PROGRAMADOR
CURIOSO
 DICA 42
Use "tracer bullets" para achar o alvo

Faça as coisas e as deixe serem vistas, assim você pode ver o quão
perto elas chegam do que o seu cliente realmente deseja.

45/65

O
PROGRAMADOR
CURIOSO
 DICA 43
Faça protótipos para aprender

Prototipar é uma experiência de aprendizado.

O seu valor não está no código em que você produz, mas nas lições
que aprendeu para montar.

46/65

O
PROGRAMADOR
CURIOSO
 DICA 44
Programe perto do problema

Crie e codifique na linguagem do seu usuário, como se você fosse ele.

47/65

O
PROGRAMADOR
CURIOSO
 DICA 45
Estime para evitar surpresas

Estime antes de começar, você irá possivelmente ver problemas à

frente e conseguirá se organizar melhor.

48/65

O
PROGRAMADOR
CURIOSO
 DICA 46
Itere o tempo com o código

Use a experiência que você ganha construindo a aplicação para

refinar a escala de tempo do projeto e ter melhores estimativas.

49/65

O
PROGRAMADOR
CURIOSO
 DICA 47
Escreva e Rabisque

Textos e rabiscos nunca se tornam obsoletos, eles ajudam a melhorar

o seu trabalho e simplificar depurações e testes.

Acesse o pacote Full-Stack e torne-se um desenvolvedor web de

sucesso agora mesmo: Acesse aqui
50/65

O
PROGRAMADOR
CURIOSO
 DICA 48
Use um bom editor

O editor precisa ser uma extensão da sua mão, tenha certeza de que

seu editor é configurável, extensível e de que vocês trabalham bem

juntos.

51/65

O
PROGRAMADOR
CURIOSO
 DICA 49
Sempre use versionamento de código

Versionamento de código são como máquinas do tempo para o seu

trabalho, aqui é possível voltar atrás!

52/65

O
PROGRAMADOR
CURIOSO
 DICA 50
Corrija o problema, não fique culpando

Não importa se o bug é sua culpa ou de outro, é um problema e

precisa ser corrigido.

53/65

O
PROGRAMADOR
CURIOSO
 DICA 51
Aprenda manipulação de texto

Na sua linguagem você passa boa parte do tempo trabalhando com

textos.
Por que não deixar o computador fazer um pouco desse trabalho para
você?

54/65

O
PROGRAMADOR
CURIOSO
 DICA 52
Escreva código que faça código

Geradores de código aumentam sua produtividade e ajudam a evitar

duplicações.

Torne-se um ninja da codificação com o pacote Full-Stack:

Acesse aqui

55/65

O
PROGRAMADOR
CURIOSO
 DICA 53
Você não pode escrever um software perfeito

Softwares não podem ser perfeitos.

Proteja seu código e os usuários dos erros inevitáveis.

56/65

O
PROGRAMADOR
CURIOSO
 DICA 54
Faça o Design com contratos

Use contratos para documentar e verificar se o código faz o que se é

pedido.

57/65

O
PROGRAMADOR
CURIOSO
 DICA 55
Quebre cedo

Um programa morto normalmente dá menos problemas que um

programa deficiente.

Aprenda a fazer os seus próprios programas: Acesse aqui

58/65

O
PROGRAMADOR
CURIOSO
 DICA 56
Use assertions para previnir o impossível

Use assertions para validar suas premissas. E use também para

proteger seu código de incertezas.

59/65

O
PROGRAMADOR
CURIOSO
 DICA 57
Use exceptions para problemas excepcionais

Exceptions podem prejudicar a leitura e manutenibilidade do projeto,

criando os famosos códigos spaghetti. Reserve exceptions para coisas
de fato excepcionais.

60/65

O
PROGRAMADOR
CURIOSO
 DICA 58
Termine o que você começou

Quando possível, a rotina ou objeto responsável por alocar aquele

recurso, precisa ser responsável por desalocar também.

61/65

O
PROGRAMADOR
CURIOSO
 DICA 59
Configure, não integre

Implemente escolhas de tecnologia para uma aplicação como se

fossem opções de configuração, não somente como processo de
integração ou código agregado.

62/65

O
PROGRAMADOR
CURIOSO
 DICA 60
Coloque abstrações no código, detalhes no
metadata

Codifique para o caso geral e coloque os casos específicos de forma

separada do código base.

63/65

O
PROGRAMADOR
CURIOSO
 DICA 61 - FINAL
Faça um curso
Sem dúvidas uma das principais opções para aprender a programar é
fazer um curso, mas não qualquer curso, você tem que fazer o melhor e
mais completo.
Como eu já indiquei diversas vezes aqui, o Pacote Full-Stack é o melhor
e sempre será para quem quer realmente se tornar um programador de
sucesso.
No Pacote Full-Stack você irá aprender várias linguagens de
programação, novas tecnologias e além disso, são mais de mil aulas.
Então, esse é o curso que eu indico e que já ajudou mais de 10 mil
alunos a se tornarem desenvolvedores web de sucesso e com certeza irá
ajudar você também.
Acesse o pacote Full-Stack: Clicando aqui
64/65 O
PROGRAMADOR
CURIOSO
 Espero que tenha gostado!
Essas foram as melhores dicas para quem quer aprender a programar
e se tornar um desenvolvedor web de sucesso.

Espero que eu tenha te ajudado e que você se torne um dos melhores

programadores desse mundo.
Links úteis
Inscreva-se no meu canal do Youtube: Clique aqui

Siga-me no instagram: @oprogramadorcurioso - Acesse aqui

Acesse o pacote Full-Stack: Clique aqui

Observação: Todas as palavras destacadas em laranja são links clicáveis.

O
PROGRAMADOR
65/65 CURIOSO