Vamos fazer 10 perguntas e 10 respostas sobre programação?
15 pontos por curioe 2024-09-10 | 46 comentários | Compartilhar no WhatsApp
  1. Você usa tabulação (indentação) com tab ou com espaços? Quantos espaços usa?
  2. Você inicia as chaves em uma nova linha ou continua na mesma linha?
  3. Quantos caracteres por linha você permite?
  4. Qual estilo você prefere ao nomear variáveis ou funções? (ex.: camelCase, snake_case)
  5. Qual é o seu editor preferido?
  6. Qual fonte você usa para programar? E o tamanho?
  7. Quando vai criar algo, qual é a primeira linguagem de programação à qual você recorre?
  8. Você tem alguma regra ou ordem para importar módulos ou bibliotecas?
  9. Você faz testes unitários? De que forma?
  10. Escreva o que quiser: algo que queira dizer, opinião, orgulho, divulgação ou qualquer coisa.

Leituras relacionadas

46 comentários

 
aer0700 2024-11-17
  1. 4 espaços
  2. Estilo K&R na mesma linha
  3. Em vez de definir um número fixo de caracteres, vou variando conforme o contexto.
    Coisas como tratamento de erro eu tento resolver em uma linha sempre que possível,
    mas o restante da lógica eu separo.
  4. Pessoalmente, prefiro snake_case, mas sigo o padrão do time.
  5. VS Code
  6. Fonte padrão do VS Code
  7. C
  8. Incluo a biblioteca padrão primeiro. Depois, as bibliotecas externas e, em seguida, as bibliotecas internas da empresa.
  9. Na hora de fazer o build, executo os testes unitários. Se der fail nos testes unitários, corrijo e faço o build de novo... até passar.
  10. Cuidado com o resfriado. Cuidado com os pulsos. Bebam com moderação. Vamos fazer dieta.
 
bobcat 2024-10-14
  1. 2 ou 4 espaços
  2. Newline
  3. 79-80 / 119-120
  4. Se houver uma convenção como a PEP8, siga-a; caso contrário, CC.
  5. VSCode
  6. Consolas, 9pt
  7. C
  8. Stdlibs (stdlib) > bibliotecas de plataforma (Windows, unistd...) > biblioteca essencial (para todo o projeto) > biblioteca auxiliar (focada no módulo)
  9. Teste unitário
  10. Está frio
 
jwh926 2024-10-04
  1. Projeto pessoal: tab de 4 espaços; no trabalho: 4 espaços
  2. Hoje em dia estou usando na linha seguinte
  3. 100
  4. snake_case
  5. VSCode
  6. Iosevka 22px
  7. Python
  8. Prioridade nº 1 para a palavra-chave from, depois a biblioteca built-in
  9. Não faço
  10. Quero ir pra casa
 
tobesimple7 2024-09-20
  1. 4 espaços
  2. Na mesma linha
  3. 100 caracteres, incluindo espaços
  4. Uso camel e snake_case juntos
  5. JetBrain
  6. d2code, dracula 12 ~ 13
  7. SQL
  8. Não tenho um específico
  9. Ordem, por funcionalidade
  10. É divertido
 
nutella 2024-09-19
  1. Tab
  2. Na mesma linha
  3. 100
  4. Usar de acordo com a linguagem
  5. VS Code!
  6. Droid Sans Mono, 14pt
  7. Python!
  8. lint
  9. Faço testes por funcionalidade
  10. Estou conhecendo muitas fontes boas :)
 
erickim27 2024-09-18
  1. Em todas as linguagens, uso só tabs.
  2. Ao declarar funções, quebro para uma nova linha; em if ou for, uso espaço.
  3. Aproximadamente 50 caracteres.
  4. Em minúsculas, substituindo espaços por _.
  5. Principalmente VS Code; quando estou com pressa, uso vim.
  6. mesloLGS NF, 16pt
  7. Se for algo simples, começo pensando em Python.
  8. Quase não tenho. Quando é em C, costumo usar primeiro a biblioteca padrão.
  9. Não faço.
  10. Estudar kernel Linux/low level é divertido, então todo mundo deveria experimentar pelo menos uma vez.
 
overthinker 2024-09-17
  1. em C++, 4 espaços; em JS, 2 espaços; em Go, tab
  2. Em C++, nova linha; no restante, na mesma linha, mas prefiro o lint de cada linguagem.
  3. 80 caracteres
  4. Varia conforme a linguagem, mas em JS: camel_case; em C++: snake_case
  5. vscode
  6. Hack Nerd Font / tamanho 12 / peso 450
  7. JS
  8. lint ou em ordem alfabética
  9. Faço testes unitários em unidades curtas de funcionalidade.
  10. Força para todo mundo.
 
siscof 2024-09-17
  1. 2 espaços
  2. Na mesma linha
  3. 80 caracteres (para conseguir deixar dois editores lado a lado)
  4. Depende da linguagem, mas prefiro CamelCase
  5. neovim (AstroNVim) + tmux / IDEA Ultimate
  6. D2Coding / Hack Fira Code Nerd Font
  7. bash shell > js > kotlin
  8. Regras padrão do Intellij (crio e uso com editorconfig)
  9. Escrevo código de teste com base na lógica de negócio, e a UI eu testo manualmente...
  10. Antigamente era trabalhoso adicionar plugins em vimscript e ficar ajustando tudo do meu jeito, mas hoje em dia existem opções como o AstroNVim, que já vem com a configuração pronta, e também há bastante suporte a simuladores de vim em cada IDE, então todo mundo pode experimentar de leve hehe
 
jjpark78 2024-09-16
  1. 2 espaços.
  2. Mesma linha
  3. 100 caracteres
  4. camelCase
  5. doom emacs para neovim e magit
  6. FiraCode
  7. nodejs
  8. Tirando o recurso de formatação suportado pela LSP, não tenho nenhuma regra específica.
  9. Uso vitest, mas em vez do uso ideal de criar antes de programar, primeiro codifico e depois crio testes unitários para evitar efeitos colaterais. Depois disso, uso mais pela tranquilidade mental de saber que uma funcionalidade já criada não será afetada por novidades ou novas alterações.
  10. Que o GeekNews prospere.
 
goinwater 2024-09-12
  1. Espaçamento de 2 espaços (escrevo com tab e converto automaticamente para espaços)
  2. Como desenvolvedor de TS, na mesma linha (no caso da família C, na linha seguinte)
  3. 100 caracteres
  4. camelCase
  5. Cursor IDE
  6. Fira Code Nerd Font
  7. TypeScript
  8. Bibliotecas no topo, módulos internos depois
  9. Principalmente módulos compartilhados
  10. Quero usar bem o vim, mas não consigo me acostumar
 
regentag 2024-09-12
  1. 3 espaços (Ada), 4 espaços (as demais linguagens)
  2. Ada não tem chaves, mas begin vai na linha seguinte. No PowerShell, vai na mesma linha.
  3. 130 caracteres
  4. SNAKE_CASE em maiúsculas
  5. Understand, Notepad++
  6. D2Coding
  7. PowerShell
  8. Se não houver nenhum problema especial, em ordem alfabética.
  9. Não faço.
  10. Força!
 
roxie 2024-09-22

Você ainda usa Ada? Uau..
 
mhcoma 2024-09-12
  1. Tab com 4 espaços
  2. Estilo K&R
  3. 120
  4. snake_case
  5. VS Code
  6. D2Coding 12pt
  7. Python, C
  8. Biblioteca padrão -> biblioteca externa -> interna, em ordem alfabética
  9. Não...
  10. O caractere de tab é deus.
 
codufdl 2024-09-11
  1. Estou usando space 2.
  2. Continuo na mesma linha, e o fechamento escrevo separado. Depois de fechar, o que vem em seguida fica na mesma linha...
  3. Uso de acordo com o tamanho da tela de quem está usando a maior fonte no time; agora está em 200.
  4. Prefiro camelCase.
  5. No momento, o vscode é mais confortável.
  6. Estou usando D2Coding / 12.
  7. A ordem é ecmascript > java > python.
  8. A ordem é standard > third-party > internal.
  9. Fora quando modularizo, uso printf, haha
  10. Pessoal, força aí!
 
hwhang0917 2024-09-11
  1. space4
  2. mesma linha
  3. 80
  4. camelCase
  5. neovim
  6. FiraCode Nerd Font 18
  7. Go, TypeScript
  8. standard, third-party, internal
  9. Sobre utilitários ou módulos compartilhados
  10. Espero que todos passem este ano em segurança.
 
iyeti 2024-09-11
  1. space4
  2. mesma linha
  3. 120c
  4. camel
  5. VSCode
  6. Consolas 10
  7. Java, C++, Python
  8. ordenação automática em ordem alfabética
  9. tratamento de exceções com cuidado, no mínimo necessário
  10. Cuidado com COVID e influenza... depois que você pega uma vez e a energia cai, a recuperação realmente fica lenta...
 
semjei 2024-09-11
  1. Espaços: 4
  2. Classes e interfaces na linha seguinte, o resto na mesma linha
  3. Sem limite; por enquanto, 220
  4. Nomes de classes e funções globais em camelCase; funções internas e variáveis em snake_case
  5. VS Code
  6. D2Coding
  7. C++, PHP
  8. Se possível, em ordem alfabética por funcionalidade
  9. Só os módulos comuns; o resto, como achar melhor
  10. Que o resto deste ano também siga sem problemas
 
nabitang 2024-09-11
  1. 4 spaces
  2. na mesma linha
  3. 120 caracteres
  4. camelCase
  5. vscode
  6. Fira code
  7. javascript (typescript)
  8. third party, packages -> domain, entity -> use case -> services, adapters -> componentes de UI
  9. Jest, testar apenas os casos de uso quando necessário, e se possível manter isso no mínimo
  10. Espero que todos vocês cuidem bem da saúde :)
 
crazeidea 2024-09-11
  1. Tab / 4 espaços
  2. Na mesma linha
  3. 140
  4. camelCase
  5. VSCode
  6. Ubuntu
  7. Typescript
  8. Nada em particular, mas às vezes ordeno em ordem alfabética
  9. Módulos com alta complexidade passam por testes
  10. Força para todo mundo
 
n1ghtc4t 2024-09-11
  1. Eu era do time do tab, mas dependendo do caso priorizo 4 espaços; em HTML, 2 espaços; ultimamente penso mais no estilo “tanto faz, de um jeito ou de outro”
  2. Coloco na mesma linha, mas tento ao máximo seguir a convenção do código existente
  3. Quando era mais novo era 120, mas com a vista cansando foi caindo até 80.
  4. Para nomes de classes ou módulos, prefiro camel; para variáveis, snake
  5. Usei VSCode, mas recentemente estou tentando migrar para o Zed
  6. Ultimamente, CaskaydiaCove Nerd Font Mono
  7. No trabalho, Python; em projetos pessoais, Elixir; o que quero experimentar é Rust
  8. Não ligo muito para isso
  9. Em fase inicial ou em desenvolvimento solo, evito ao máximo testes unitários; quando a equipe do projeto cresce e entram desenvolvedores juniores, escrevo testes unitários nas partes essenciais do código... e depois acabo deixando de lado
  10. Quero ganhar dinheiro logo para andar de iate à vela e ficar só curtindo programar como hobby.
 
toaonly 2024-09-11
  1. Espaço, usar 2 espaços
  2. Na mesma linha
  3. 80
  4. camelCase
  5. VSCode
  6. Consolas
  7. JavaScript, Rust
  8. Ordem alfabética e depois caminho local
  9. Para módulos do tipo util, faço quase 100%, e para lógica de negócio só avanço com o que for tipo "se isso não funcionar, vai dar um problema muito sério" (por questão de tempo, não dá para testar tudo...)
  10. Força a todos os desenvolvedores e engenheiros que acompanham o GeekNews!
 
hhan8 2024-09-11
  1. Espaços, seguindo a convenção. Em projetos pessoais, prefiro 2.
  2. Escrevo na mesma linha.
  3. Acho que fica por volta de 100.
  4. camelCase
  5. VSCode > Neovim > IntelliJ (no trabalho da empresa, quando é da linha JVM, acabo tendo que usar)
  6. Fonte padrão das configurações, 13~16pt
  7. Javascript
  8. Não me preocupo particularmente com isso.
  9. Costumo implementar no estilo BDD, testando com foco nos casos que quero implementar e, no final, preenchendo a cobertura de testes.
  10. Queria muito saber usar bem o NEOVIM, mas acabo recorrendo ao cursor o tempo todo. Respeito quem usa bem.
 
iolothebard 2024-09-11
  1. espaço 4
  2. mesma linha
  3. 120
  4. camelCase
  5. vim
  6. monoplex
  7. nodejs
  8. built-in, 3rd-party, meu em ordem alfabética
  9. com certeza. É só fazer!
  10. Ho eyo he hum!
 
wedding 2024-09-11
  1. Depende do formatador. Espaços 4/2
  2. Depende do formatador. Prefiro inline
  3. Não vinculante. 80
  4. Não vinculante. Segue a convenção
  5. vs pro
  6. d2+nerd
  7. html
  8. Depende do formatador
  9. Não sou bom em deixar testes unitários bonitos, então no máximo valido com dados dummy..
 
dbs0829 2024-09-11
  1. 4 espaços
  2. Na mesma linha
  3. 79
  4. Seguindo a convenção
  5. neovim
  6. nerd hack font, tamanho padrão do editor
  7. python ou c#
  8. Seguindo a convenção
  9. Só crio código de teste separado quando as especificações são claramente definidas. Fora isso, vou testando por conta própria enquanto desenvolvo.
 
a12341234 2024-09-11
  1. 2 espaços
  2. Na mesma linha
  3. 1000+
  4. camelCase
  5. VSCode
  6. Fonte padrão ou D2 Coding
  7. Dart
  8. Sigo o formatter padrão
  9. Sem mocking; sempre que possível, testo conectado ao servidor e ao banco de dados de desenvolvimento. Parece que há mais problemas relacionados ao servidor...
 
iknowca 2024-09-11
  1. Tab com 4 espaços
  2. Na mesma linha
  3. Não me importo.
  4. camelCase
  5. vscode
  6. 14p, d2 coding
  7. python
  8. Nada em particular.
  9. Quase não consigo...
  10. Gosto desse tipo de conteúdo participativo
 
savvykang 2024-09-10
  1. 2 espaços em TSX, 4 espaços no restante
  2. Na mesma linha
  3. 80/120
  4. O estilo recomendado pela linguagem
  5. VSCode, STS apenas para Java
  6. Monaco, Menlo, Consolas
  7. Python
  8. Biblioteca padrão, biblioteca de terceiros, mesmo projeto
  9. Só faço testes unitários no que pode ser executado apenas com o sistema de arquivos e objetos de entrada/saída, sem precisar de sistemas externos
  10. A pergunta 4 não tem utilidade tão alta, tem?
 
xguru 2024-09-10
  1. 2 espaços
  2. Na mesma linha
  3. Como não escrevo muito largo, acho que quebro por volta de no máximo 80 caracteres.
  4. camelCase
  5. VS Code: uso isso não só para desenvolver, mas também para organizar as notícias que posto no GeekNews. Simplesmente é confortável.
  6. O monitor é o mesmo em casa e no trabalho, mas uso fontes diferentes.
  • Win: JetBrains Mono, 14p
  • Mac: Menlo, 12p
  1. Antigamente eu preferia apps desktop, então usava Delphi (nossa, faz quanto tempo isso), e rabiscava páginas web pequenas em PHP.
    Mas, pensando bem, hoje em dia eu acabo procurando primeiro um framework base dependendo do que vou fazer e, se tiver algum que se encaixe, simplesmente desenvolvo naquela linguagem.
    Também desenvolvo com scripts no Google Docs, às vezes resolvo como plugin no WordPress, e se houver algum módulo adequado em Node/Python, pego e uso, então varia bastante.
  2. Se ficar muito, eu organizo para ficar mais bonito de ver; fora isso, nem me preocupo. (O formatter vai dar conta.)
  3. Quase não faço. snif
  4. Mandem muitas perguntas boas no Ask! Vamos movimentar o Ask hahaha
 
jic5760 2024-09-10
  1. espaço. 4.
  2. na mesma linha
  3. no ponto em que não gere rolagem horizontal
  4. varia conforme a linguagem (kotlin/go/java/typescript usam camelCase, c/c++ usam snake_case)
  5. Jetbrains
  6. fonte padrão da Jetbrains
  7. go ou kotlin
  8. no go, imports externos/internos são diferenciados. Dentro de cada grupo, a ordenação é feita automaticamente.
  9. principalmente unit test + quando várias rotinas andam juntas, testo separadamente
  10. obrigado pela ótima pergunta :)
 
autumnal 2024-09-10
  1. Usar tab, 4 espaços
  2. Seguir o estilo de código de cada projeto.
  3. Algo fácil de entender de relance (até 150 caracteres)
  4. Seguir o estilo de código de cada projeto.
  5. vscode é o melhor
  6. Consolas
  7. C++
  8. A menos que seja uma biblioteca que precise ser definida especificamente, importar na ordem padrão - dependente do framework - personalizado
  9. Fazer testes unitários por funcionalidade
  10. Quero programar mais e melhor. Queria ter mais tempo!
 
cjinzy 2024-09-10
  1. 4 espaços
  2. Se for curto, deixo na mesma linha; se parecer que vai ficar longo, coloco em uma nova linha.
  3. Costumo ir até 150 caracteres. Estou tentando reduzir ainda mais...
  4. Eu usava camelCase, mas recentemente estou migrando para snake_case
  5. Uso bastante VS Code e Vim.
  6. Hack, Nerd Font; o tamanho da fonte... costumo ir ajustando dependendo do cansaço dos olhos
  7. No fim das contas, acabo usando mais Python
  8. Estou fazendo na ordem: módulos embutidos, módulos que podem ser instalados por pacote e módulos feitos por mim.
  9. Faço só o que é mais importante... desaba...
  10. Tenha um ótimo dia :)
 
alstjr7375 2024-09-10
  1. space, 2 espaços
  2. Prefiro nova linha, mas por causa dos formatadores muitas vezes acabo escrevendo na mesma linha
  3. No máximo 80, se ficar longo 120 colunas
  4. Minha preferência é kebab-case, mas por limites de parsing ou várias convenções acabo usando camelCase T_T
  5. Emacs ou, mais recentemente, tenho usado bastante o Visual Studio Code por causa dos plugins. Para coisas simples, uso o Kate.
  6. Hack + D2Coding (fallback para coreano)
  7. Typescript
  8. std, biblioteca, módulo interno, diretório atual
  9. Gosto de testes In-Source Test, feitos no mesmo arquivo da implementação.
  10. Vou publicar um texto de apresentação em breve, haha
    Estou criando um CSS in JS para combinar Semantic CSS e Atomic CSS.
    https://github.com/mincho-js/mincho

Quem faz parte do "time menta com chocolate" ficaria agradecido se pudesse deixar uma estrela...?
 
goinwater 2024-09-12

Parece ser baseado em Vanilla Extract.
 
qyurila 2024-09-10
  1. Tab com 3 espaços (na prática, só dá em projeto pessoal..)
  2. Se for mais próximo de JS, na mesma linha; se for mais próximo de Java, em uma nova linha
  3. Se for mais próximo de JS, 90; se for mais próximo de Java, 120
  4. Usar de acordo com a convenção
  5. VSCode (+ dependendo da situação, Zed e micro)
  6. JetBrains Mono + Gooroom Sans Code, 14
  7. Na maioria das vezes, faço na linguagem que eu estava querendo muito aprender naquela época. Senão, TS
  8. Em geral, quanto mais próximo de built-in, mais cedo eu importo
  9. A partir do próximo projeto, com certeza..
  10. Respeito muito todo mundo que já trabalha na área
 
alstjr7375 2024-09-10

Então 3 espaços é definitivamente um gosto mais de nicho, né(?).
Tem algum motivo para você preferir assim?
 
qyurila 2024-09-11

Pelo que sei, em algumas linguagens (especialmente HTML e JSX), o motivo de tabulação de 4 espaços não ser o padrão é que, quando a indentação fica profunda, ela ocupa largura demais de forma desnecessária — e eu também sinto isso na prática.
Pessoalmente, porém, quando uso indentação de 2 espaços, a separação parece fraca demais e fica muito difícil entender a hierarquia. Senti isso desde quando comecei a aprender, e continuo achando a mesma coisa até hoje.

Conheci a indentação de 3 espaços pela primeira vez numa convenção de código que usei quando precisei trabalhar com Lua no passado.
Depois que me acostumei um pouco... comecei a pensar: será que isso não é o ponto ideal entre 2 e 4 espaços? Então passei a aplicar também em outras linguagens, e senti que, na maioria das linguagens em que 2 ou 4 espaços são o padrão, a legibilidade fica melhor com 3 espaços — por isso continuo usando sempre que possível haha

Se você procurar no Google, até dá para encontrar pouquíssimos (!) textos defendendo a indentação de 3 espaços; por diversão, que tal ler este aqui? 😄
 
alstjr7375 2024-09-11

De tanto ver isso, parece até que o cérebro vai se acostumando kkkkk
 
curioe 2024-09-11

Oh, que interessante. Da próxima vez que eu fizer algo simples, acho que vou tentar usar 3 espaços. Obrigado.
 
neodasida 2024-09-10
  1. tab, 2 espaços
  2. mesma linha
  3. 320
  4. camelCase
  5. IntelliJ / vim
  6. Source Code Pro for powerline 14pt
  7. java / kotlin > javascript
  8. Auto Import do IntelliJ ^^; no caso de linguagens de script, faço a distinção entre módulos internos e externos.
  9. Seria bom poder fazer testes E2E do sistema inteiro, mas costumo definir o escopo até um nível em que as regras de negócio importantes sejam validadas.
 
jaehong21 2024-09-10
  1. Tab
  2. Na mesma linha ~
  3. Geralmente sigo as configurações padrão do linter e do formatter (ou então, até onde cabe em uma tela)
  4. Sigo a convenção padrão da linguagem, geralmente prefiro camelCase
  5. Neovim
  6. NerdFont
  7. Golang
  8. import na ordem std, bibliotecas externas e módulos internos, e dentro disso ordenado alfabeticamente
  9. Só quando a lógica é complexa eu coloco parcialmente primeiro.... (Queria colocar em tudo, mas...)
 
bemong1 2024-09-10
  1. 4 espaços, tab
  2. Nova linha
  3. Depende da situação
  4. em c++ é camelCase, no restante é snake_case
  5. vim, vs, vscode
  6. Naver d2
  7. Para protótipos rápidos, Python; no restante, depende da natureza do projeto
  8. Primeiro as bibliotecas de nível system e os; quanto mais baixo o nível, mais abaixo
  9. Uso gtest e pytest. Testo com frequência
  10. Também tenho curiosidade sobre como outras pessoas escrevem documentação de desenvolvimento e qual é o estilo delas....
 
ganadist 2024-09-10
  1. Shell com 2 espaços, Makefile com tab, o resto com 4 espaços
  2. Depende da convenção da linguagem; de preferência, na mesma linha
  3. Ao usar linguagens antigas, 80 caracteres; ao usar linguagens modernas (?), 100 caracteres
  4. Segue a convenção da linguagem
  5. neovim, Android Studio, IntelliJ, às vezes vscode
  6. De preferência, a fonte monoespaçada padrão do SO
  7. Reescrevo do zero na ordem shell -> Python -> Kotlin
  8. Hoje em dia o formatter e o linter resolvem isso sozinhos... (olhando para longe)
  9. Escrevo um pouco e depois deixo de lado.. (desabando...)
  10. Não existe nada fácil neste mundo. Buá buá..
 
baeba 2024-09-10
  1. Tab, 4 espaços
  2. Começar em uma nova linha
  3. caso a caso (cerca de 100 caracteres)
  4. Misturo snake_case e camelCase
  5. Notepad++ > Ultraedit (versão 2001) > VS Code
  6. D2 Coding
  7. C/C++ > Java > JavaScript/CSS
  8. caso a caso
  9. Coloco no código um módulo que registra logs e salvo em arquivo. Faço isso junto enquanto desenvolvo.
  10. Quando vou me aposentar?
 
yshrust 2024-09-10
  1. 2 espaços
  2. Na mesma linha
  3. O suficiente para ficar agradável de ver
  4. Acho que normalmente as pessoas seguem o que muita gente usa em cada linguagem.
  5. Visual Studio
  6. Cascadia Code
  7. C#
  8. Acho que basicamente agrupo pelo que uso / o que eu criei / e coisas assim.
  9. Eu fico pensando que preciso fazer, que preciso fazer..., mas acabo não fazendo muito.
  10. Ganhar na loteria só uma vez ..
 
curioe 2024-09-10
  1. Quatro espaços. Minha visão não é muito boa, então gosto de coisas maiores.
  2. { na mesma linha
    }
  3. Não limito exatamente por contagem, mas se não cabe em meia tela, costumo dividir.
  4. Acho que varia conforme a linguagem, mas em geral uso camelCase.
  5. VS Code
  6. Menlo, 16, mas a resolução é 1920. haha
  7. Hoje em dia acho que não tem nenhum em especial. Vai mudando conforme o momento. Há uns 10 anos era Java, mas hoje em dia nem olho mais para isso haha
  8. Importo na ordem em que preciso, mas costumo agrupar os que têm a mesma função ou camada.
  9. Só rodo testes do que é importante para a lógica de negócio, só para acalmar minha ansiedade. Preciso refletir sobre isso...
  10. Quero ter um negócio de estilo de vida (um negócio que gere dinheiro o suficiente para manter a vida que a própria pessoa quer viver).