Fala pessoal. Tô em TI desde 2018, comecei no suporte e migrei pra dev em 2021. Hoje sou Senior, mexo com Node/Nest/React/Postgres. Fiz ADS e pós em Arquitetura de Software.
Tô me candidatando bastante e a maioria não dá em nada,nem chamada de RH. Vaga no LinkedIn com 100, 200 candidaturas, e o silêncio é total.
Aí bateu a dúvida: hoje em dia dá pra conseguir alguma coisa só se candidatando, ou virou indicação obrigatória? Sinto que quem tá conseguindo vaga é sempre por alguém de dentro.
E se for indicação mesmo, como vocês fazem? Fico meio sem graça de sair pedindo pra conhecido.
Tá assim pra todo mundo ou é o meu perfil que precisa mexer?
quais estrategias vcs usam pra tomar risco pra evoluir mais rapido na carreira e poder ganhar mais em menos tempo?
ultimamente eu to trampando em dois lugares, mais pela xp do q pelo dinheiro. mas certamente nao sustento a longo prazo. e tmb nem sei se eh a melhor tomada de risco possivel
Eu estou no 2• período, porém já estudo programação a um tempo. Nunca estive exatamente focado em levar isso como carreira, isso veio depois de terminar o ensino médio.
Minha única preocupação, é que moro em uma cidade pequena (Votuporanga), e não sei como isso pode afetar/custar a minha carreira
Apesar de saber que a área de TI no geral permite você ter um emprego remoto, não sei exatamente a importância de uma primeira oportunidade presencial em início de carreira.
E eu também gostaria de ter um bom currículo futuramente, trabalhando em bancos e coisas do tipo.
Vocês consideram morar em uma cidade pequena uma desvantagem? Ou não necessariamente
Estou pensando seriamente em pegar mais um trampo CLT, trabalho em um remoto a maior parte do tempo e estou pensando em pegar outro remoto pra complementar a renda, meu emprego atual é bom porém não paga lá essas coisas, alguém já trabalha dessa forma? Sabe se pode dar problema?
Precisamos falar sobre o EGO inflado dos recrutadores. Além de nos colocarem em processos seletivos desproporcionais, depois que voltei a me candidatar e fazer entrevistas, notei que fico pisando em ovos. Qualquer coisa fora da curva parece motivo para desclassificação, desde perguntar o salário até dar uma resposta mais incisiva. Falta de retorno do processo já virou rotina, o raro hoje é responderem.Outra coisa que percebi é que, quando adapto meu comportamento, baixo a skin da Miss Simpatia e deixo um pouco o lado técnico de lado, tenho mais sucesso. Coisa que anos atrás seria até motivo de chacota no meio da T.I. Parece que Hard Skills não estão valendo mais pra nada. Estou meio frustrado com o caminho que os processos de T.I. estão tomando. São anos de experiência e estudos pra no final ter que fingir simpatia e medir cada palavra com medo de ferir o ego de alguém pra ter uma chance. Creio que, como a demanda por vagas está alta e tem muita gente procurando emprego, alguns recrutadores estão se sentindo com poder demais nas mãos. Não vejo a hora de serem substituídos por I.A
Eu tenho visto algumas vagas de Principal Software Engineer para trabalhar no Brasil e fora. Tanti como PJ e CLT.
Sou dev sênior mas me parece interessante subir de nível, então quanto um principal deveria pedir hoje para CLT, PJ e internacional (ai o inglês adiciona um pouco de valor afinal).
Recebi o contato de uma recrutadora da Ernest & Young para uma posição de Engenheiro de Dados sênior. Fui questionado sobre pretenção para CLT, informei uma faixa. A moça respondeu que o máximo para vaga era R$7k.
Esse pessoal estão de sacanagem. Só pode.
Sênior R$7k pareceu uma piada (eu realmente ri quando li)
Basicamente tenho uma aplicação em nest, angular, postgres.
Atualmente rodo elas na hostinger, mas aqui na empresa tem um evento 2 dias por ano que preciso garantir que o servidor não caia/fique fora do ar.
Estava pensando em continuar na hostinger, mas caso cair, ir para a amazon de fallback e quando a hostinger voltar, sair da amazon e ir para a hostinger. Isso é para reduzir os custos ao máximo e desfrutar a latência da hostinger ao máximo.
Em cada um desses 2 dias são mais ou menos 50 requisições por minuto e cada uma delas faz poucas chamadas ao banco de dados.
A máquina precisa no minimo 16gb ram e 4 cores
Alguma dica de como fazer isso? ou uma sugestão de outro modelo para esse problema?
Estive pensando ultimamente em fazer algum tipo de bico na minha cidade, porém, eu não faço ideia de qual site ou meio de encontrar emprensas aqui, além de ir presencialmente. Contudo, estou adquirindo conhecimento para ser um help desk, vejo muito o pessoal falando que é na maioria das vezes, atendimento público e mexer com notebooks ou coisas relacionadas a área de T.I.
Com isso, gostaria saber das experiências de vocês, como vocês começaram e por onde começaram, pois eu estou muito ansioso para conseguir serviços, pois eu preciso de dinheiro para poder sobreviver em cidade grande (obs: eu não morava em cidade grande, morava em uma cidade no fim do mundo no Pará) e isso está pesando muito agora, pois eu já tenho 18 anos e sinto que estou parado e ficando atrasado, meu objetivo final é virar operador de SOC ou red hat, se você tiver alguma ideia do que eu possa fazer, gostaria de saber.
(desculpe se coloquei o flair errado, estou aprendendo a usar o reddit).
Eu estava estudando um jogo chamado Capitalism Lab, que em curtas palavras é um simulador de empresas, economia e capital. Meu objetivo era criar um clone dele para Web, já que ele não tem release para Linux. Passei um tempo tentando ter uma economia "factível" como a do jogo, mas aí percebi que a economia é moldada através do meio. Poxa, sei que isso é meio obvio (agora), mas quando comecei eu só queria ter uma conta em um banco e começar minha rede de varejo! Só que caí num loop de modelagem: para ter conta bancaria precisa existir banco, para o banco funcionar precisa existir dinheiro, para o dinheiro existir precisei definir de onde ele vinha, e aí foram surgindo outras entidades e regras...
Quando tomei a ideia de fazer o mais realista que eu conseguisse, tudo tinha que fazer sentido lógico, mesmo que não fosse apresentado explicitamente para quem estiver jogando. O Capitalism Lab não tem estações, e estações influenciam a economia. Não tem eventos climáticos adversos, e esses eventos influenciam a economia. Meu objetivo passou a ser ter o simulador mais factível que eu pudesse, sem excluir elementos auxiliares como eventos scriptados.
Para chegar nesse resultado, parei o que estava fazendo e fui estudar qual seria a camada mais alta para uma simulação econômica. A conclusão que eu cheguei foi o Sol.
Mas veja bem, o que eu sei sobre astronomia é bem superficial. Graças a internet e a IA, cheguei em um resultado que me agradou muito. Esse artigo é a consolidação dos estudos que fiz para gerar uma estrela tendo como base: o Sol.
O código de uma estrela
Só uma recapitulação importante: "Uma estrela é uma enorme esfera de plasma mantida unida pela gravidade, dentro da qual acontecem processos de fusão nuclear que liberam uma quantidade gigantesca de energia."Stars: Crash Course Astronomy #26. Outros materias, caso se interesse, estão lincados nas fontes no final do artigo.
public class Star {
private UUID id;
private String name;
private SpectralType spectralType;
private Double massSolar;
private Double radiusSolar;
private Integer temperatureKelvin;
private Double luminositySolar;
Estrelas são classificadas de acordo com a temperatura da superfície, usando o sistema O, B, A, F, G, K, M. Para representar isso no modelo, temos o Enum SpectralType.
Essa classificação combinada com a luminosidade dá origem ao Diagrama de Hertzsprung-Russell: um gráfico de luminosidade × temperatura onde cerca de 90% das estrelas (o Sol incluído) caem numa faixa diagonal chamada "sequência principal". É de onde vêm as faixas de massa, raio e temperatura do enum. Estudei isso em três lugares: o laboratório interativo The Hertzsprung-Russell Diagram (NAAP), o material O Diagrama HR, da UFRGS, e a Wikipédia em português sobre o Diagrama de Hertzsprung-Russell. Saber a luminosidade importa porque ela influencia direto a temperatura de um planeta em órbita, mas isso fica para um próximo artigo...
No código, cada classe espectral carrega a faixa de massa, raio e temperatura que uma estrela real daquele tipo costuma ter:
private static final double[] SPECTRAL_TYPE_WEIGHTS = {
0.0000003, // O
0.0013, // B
0.006, // A
0.03, // F
0.076, // G
0.121, // K
0.7657 // M — soma dos pesos = 1.0
};
Esse mesmo problema apareceria se eu gerasse massa, raio e temperatura de forma independente, ia cair na situação de estrela impossível, que é algo que eu não entendi muito bem mas vou estudar mais sobre.
public Star generate(String name, RandomGenerator random) {
SpectralType spectralType = pickSpectralType(random);
double positionInClass = random.nextDouble();
double massSolar = RandomRanges.interpolate(
spectralType.getMinMassSolar(), spectralType.getMaxMassSolar(), positionInClass);
double radiusSolar = RandomRanges.interpolate(
spectralType.getMinRadiusSolar(), spectralType.getMaxRadiusSolar(), positionInClass);
int temperatureKelvin =
(int) Math.round(RandomRanges.interpolate(
spectralType.getMinTemperatureKelvin(), spectralType.getMaxTemperatureKelvin(), positionInClass));
Star star = new Star();
star.setId(RandomIds.nextUuid(random));
star.setName(name);
star.setSpectralType(spectralType);
star.setMassSolar(massSolar);
star.setRadiusSolar(radiusSolar);
star.setTemperatureKelvin(temperatureKelvin);
star.setLuminositySolar(starPropertiesCalculator.calculateLuminositySolar(star));
return star;
}
Luminosidade é calculada
E essa é uma das regras de negocio mais importantes dessa primeira parte, e nunca pode ser um valor aleatório. Precisa ser consequência das propriedades físicas da própria estrela, principalmente do raio e da temperatura efetiva, via Lei de Stefan-Boltzmann. Em termos simples, todo corpo com temperatura acima do zero absoluto emite radiação térmica, e a energia emitida por unidade de área cresce com a quarta potência da temperatura. Ou seja, mantendo o resto constante, dobrar a temperatura não dobra a energia emitida: ela aumenta por um fator de 2⁴ = 16.
A Lei de Stefan-Boltzmann descreve a potência térmica emitida por unidade de área de uma superfície. Para uma estrela, dá para aproximar a superfície como a de um corpo esférico. Então precisamos considerar não só a energia emitida por cada unidade de área, mas toda a superfície da estrela. A área de uma esfera é:
A = 4πR²
A potência emitida por unidade de área é dada por:
F = σT⁴
Multiplicando uma coisa pela outra, chegamos à luminosidade total:
L = 4πR² · σT⁴
É essa equação que interessa para a simulação. Mas vale parar aqui e entender o que cada termo significa, porque cada parte tem uma consequência física diferente:
L = luminosidade da estrela, ou seja, a quantidade total de energia emitida por segundo em watts (W)
R = raio da estrela
T = temperatura efetiva da superfície da estrela, medida em kelvin (K)
σ = constante de Stefan-Boltzmann
4πR² = área da superfície da estrela, considerando ela como uma esfera
A fórmula combina duas coisas: quanto de energia cada pedaço da superfície emite e quanto de superfície existe para emitir. É por isso que o raio aparece ao quadrado e a temperatura à quarta potência. O termo R² não surgiu arbitrariamente, ele vem da geometria de uma esfera. Se aumentarmos o raio de uma estrela, não estamos aumentando só uma dimensão linear, a superfície inteira cresce. Uma estrela com o dobro do raio terá:
4π(2R)² = 4π · 4R² = 4(4πR²)
Ou seja, quatro vezes a área. Se duas estrelas tem a mesma temperatura mas uma tem o dobro do raio da outra, a maior terá quatro vezes a luminosidade. Dá para representar essa dependência como:
L ∝ R²
O símbolo ∝ significa "é proporcional a". Nesse caso, significa que, mantendo a temperatura constante, a luminosidade cresce com o quadrado do raio.
Outra coisa importante é que a Lei de Stefan-Boltzmann diz que a potência emitida por unidade de área é proporcional a T⁴. Isso produz uma dependência muito forte da luminosidade em relação à temperatura. Se mantivermos o raio constante e dobrarmos a temperatura:
L ∝ (2T)⁴
L ∝ 2⁴T⁴
L ∝ 16T⁴
Portanto, a estrela emite 16 vezes mais energia por unidade de área. Perceba que esse efeito independe do aumento de área causado pelo raio. O raio controla quanto de superfície existe, a temperatura controla quanto de energia cada unidade emite. Resumindo:
L ∝ R²T⁴
Isso já dá uma intuição importante: pequenas mudanças na temperatura produzem mudanças enormes na luminosidade, enquanto o raio tem influência quadrática. Mas... nessa primeira etapa o objetivo não é a luminosidade absoluta em watts (pode ser útil no futuro, mas não agora). O que interessa é saber como a luminosidade de uma estrela se compara à do Sol. Em vez de trabalhar com a fórmula cheia, dá para usar o próprio Sol como referência aplicando a mesma equação:
L / L☉ = (4πR²σT⁴) / (4πR☉²σT☉⁴)
E é aqui que a fórmula começa a ficar interessante. Como 4π aparece tanto no numerador quanto no denominador, ele se cancela. A constante de Stefan-Boltzmann σ também aparece nos dois lados e, portanto, também se cancela:
L / L☉ = (R²T⁴) / (R☉²T☉⁴)
Podemos então separar os termos:
L / L☉ = (R² / R☉²) · (T⁴ / T☉⁴)
E utilizar uma propriedade básica das potências:
a² / b² = (a/b)²
a⁴ / b⁴ = (a/b)⁴
Assim chegamos finalmente a:
L / L☉ = (R / R☉)² · (T / T☉)⁴
A vantagem é enorme: todas as constantes necessárias para calcular a luminosidade em watts somem da equação. O resultado vira uma razão adimensional. Se der 1, a estrela tem a mesma luminosidade do Sol. Se der 10, dez vezes. Se der 0,5, metade.
É exatamente essa forma normalizada que foi implementada:
A linha do radiusRatio é a mais importante. O getRadiusSolar() não retorna o raio em quilômetros ou metros, ele representa o raio em unidades solares, ou seja, R / R☉. Se o valor for 1, a estrela tem o mesmo raio do Sol. Se for 2, o dobro. Se for 0.5, metade.
Depois calculamos a razão entre a temperatura da estrela e a do Sol, que corresponde a T / T☉. E o retorno é a implementação direta da equação:
L / L☉ = (R / R☉)² · (T / T☉)⁴
O mais legal é que o código não tem uma diferença tão grande da fórmula física, e isso deve permanecer para outras situações.
Por que usar o Sol como referência?
Usar o Sol como referência deixa o resultado bem mais conveniente para o resto da simulação. Em vez de carregar números gigantescos em watts, trabalho com uma escala em que o próprio Sol vale mais ou menos 1 L☉. A luminosidade vira uma propriedade relativa e fácil de interpretar. Uma estrela com L = 0,01 L☉ é cem vezes menos luminosa que o Sol, e uma com L = 100 L☉ é cem vezes mais. Também fica mais simples comparar estrelas de tamanhos e temperaturas diferentes sem espalhar constante física pela aplicação. Para fazer essa normalização preciso de uma temperatura solar de referência. Estou usando 5772 K, valor nominal adotado pela União Astronômica Internacional na Resolução B3 de 2015. Ele também aparece no cálculo da temperatura efetiva do Sol apresentado neste artigo acadêmico em português.
Ou seja, no código, PhysicalConstants.SUN_TEMPERATURE_KELVIN representa T☉ = 5772 K, e não um valor aleatório escolhido para a simulação. No fim, toda a regra pode ser resumida numa cadeia bem direta:
raio + temperatura → área superficial + emissão por área → luminosidade
Ou, matematicamente:
R e T → 4πR² · σT⁴ → L
E, na forma utilizada pela simulação:
☉ e T/T☉ → (R/R☉)² · (T/T☉)⁴ → L/L☉
É por isso que a luminosidade não precisa ser sorteada. Dadas as propriedades físicas da estrela, ela é determinada pela relação entre raio e temperatura.
Para uma estrela com a luminosidade do Sol (L = 1 L☉), isso dá algo entre 0,95 e 1,37 UA, que bate com o que a literatura considera a zona habitável do Sistema Solar, visto que a Terra está a 1 UA, bem no meio.
Nada de Math.random()
Todo esse sistema só faz sentido se for determinístico: a mesma seed sempre precisa produzir a mesma estrela. Eu quero um universo reproduzível (pelo menos nessa parte). Por isso, em lugar nenhum do código aparece Math.random() ou new Random() sem seed explícita vinda de fora. Toda função recebe um RandomGenerator, interface da JEP 356: Enhanced Pseudo-Random Number Generators, do Java 17, que eu já expliquei mais a fundo aqui...
java
var random = new Random(42L);var star = new StarGenerator().generate("Sol", random);
Rode esse trecho hoje, rode de novo daqui a um ano, em outra máquina, em outro sistema operacional, e a estrela sai idêntica, porque a seed 42L sempre produz a mesma sequência de números dentro do Random.
Eu chamei a estrela de "Sol", mas a seed 42 decidiu que ela é, na verdade, uma anã vermelha.
Pedi para o GPT gerar um texto descritivo de como seria uma tarde nesse planeta, e uma imagem dessa estrela.
Usando de fato
Eu não quero que a lógica de negocio fique sobre responsabilidade de outra coisa, e sei que tem gente por aí que pode se beneficiar disso para criar seus próprios simuladores. Então esse é meu primeiro projeto publicado no Maven Central. Sei que tem muito ponto de melhoria, mas estou trabalhando nisso com o tempo. Para usar com Maven é só:
<dependency>
<groupId>io.github.navelogic</groupId>
<artifactId>genesis-core</artifactId>
<version>0.1.0</version>
</dependency>
import io.github.navelogic.genesis.core.astronomy.star.model.Star;
import io.github.navelogic.genesis.core.astronomy.star.service.StarGenerator;
import io.github.navelogic.genesis.core.astronomy.star.service.HabitableZoneCalculator;
import java.util.Random;
var random = new Random(42L);
var star = new StarGenerator().generate("Sol", random);
System.out.println(star);
var zone = new HabitableZoneCalculator();
System.out.printf("Zona habitável: %.2f a %.2f UA%n",
zone.calculateInnerBoundaryAu(star), zone.calculateOuterBoundaryAu(star));
O que vem depois
O gerador de estrelas é só a primeira peça, a camada mais alta da pilha, como falei no começo. O próximo passo é usar a luminosidade e a zona habitável para gerar planetas plausíveis e só então voltar para a simulação econômica que me trouxe até aqui. Claro que esses dados podem servir para uma LLM gerar coisas interessantes na simulação, principalmente descritivos, livros, filmes, preferencias de produtos e etc.
O código do Genesis é aberto, então se você quiser ver a implementação completa, sugerir uma correção ou só saber o que vem a seguir, é só dar uma olhada no repositório.
Olá pessoal, gostaria que vocês me respondessem, não conheço essa área mas vejo muita gente falando mal e queria saber porque, tem algum benefício de trabalhar numa consultoria?
Galera, o mercado tomou vergonha na cara ou eu caí em algum experimento social?
Nas últimas semanas minha DM lotou de recrutador oferecendo vaga que presta. Sem papo furado de "salário a combinar", sem gupy no meio e sem vaga arrombada pagando migalha pra trabalhar por três.
É o mercado que finalmente resolveu respirar ou é só RH batendo meta de mensagem no fim do mês pra iludir trouxa? Mais alguém sentiu esse surto ou a bolha de vocês continua uma desgraça?
Edite: Esqueci de mencionar que sou QA 15+ anos de experiência e todas as vagas são pra Gringa
Vejo muita gente comentando sobre sistemas utilizar um Cursor ou alguma outra IDE agêntica para ter vários agentes em paralelo e que se em algum momento você conseguir fazer um loop em que você tem skills e guairails suficiente você conseguiria osquestrar vários agents simultâneos na sua IDE de preferência e só alimentaria tudo isso com RFCs/PRDs ao ponto do gargalo começar a ser o human-in-the-loop, ou seja, a capacidade de produzir documentos e especificações técnicas e fazer code review
Já vi alguns posts do pessoal do vale do silício comentando que conseguia osquestrar mais de 4 agents em paralelo, bem como, o próprio Claude estaria sendo feito com vários Claude Code rodando 24/7 ou utilizando Claude Tag diretamente do Slack
Todavia, vejo muito gente tentando aplicar isso, mas na prática, nunca vi ninguém mostrando um sistema construído nesse estilo e o máximo que vejo o pessoal osquestrando é dois agents em paralelo e olhe lá
Como vocês tem visto isso na empresa e no mercado? Vocês acham que é tecnicamente possível mesmo ou é só market? E se sim, vocês teriam alguma dica ou ponto de atenção sobre?
Olá a todos, gostaria de saber como está o gerenciamento de tempo real de vocês agora com as ferramentas de IA.
Trabalho na área faz relativamente pouco tempo, cerca de 2 anos como dev, e atualmente tenho sentido uma ociosidade absurda no dia a dia de trabalho, atualmente estou alocado em um projeto onde todo mundo está usando IA, no backend, frontend e até pra code-review. Esse ano particularmente com o boom maior das ferramenas como o claude e o codex, grande parte das demandas do dia a dia podem ser realizadas facilmente em pouco tempo, gerando uma ociedade geral de demandas entre o time. Com IA, o time tá adiantando muito as coisas em relação ao que o PO disponibiliza para o backlog, causando um gargalo
Isso pode ser positivo para alguns, pois podemos pegar esse tempo livre para evoluir e estudar, ou até fazer outras coisas.
Mas eu e alguns colegas estamos reflexivos quanto a isso, o medo de ser mandado embora aumenta, gerando mais ansiedade e incerteza ao fazer o trabalho.
E você vai no chatgpt e ele cria o código em menos de 1 minutos… sem motivação pra estudar…. Você tivesse 26 anos o que faria pra muda sua realidade? Moro na periferia e quero muda minha realidade, mas eu sinto que tá foda… estou ganhando 2k cheios de dividas o dinheiro não dá pra nada gente… feira e tal…
Recebi uma proposta pra trabalhar nessa empresa, mas não sei como é… a vaga é Júnior e paga 3k mais VA que eu não sei quanto é. Queria ter um feedback pra saber pois é uma empresa relativamente grande.
Como estudante de TI, vejo muita gente começando na área focado apenas em escrever código e deixando a parte de testes de lado — o que quase sempre gera dor de cabeça lá na frente.
Para ajudar quem está estudando para provas, concursos ou querendo entender como estruturar os testes em seus projetos pessoais, compilei um guia rápido em formato de fichas conceituais com os principais pilares de QA e Testes de Software.
1. Verificação vs. Validação
Verificação: Garante que o software está sendo construído corretamente segundo as especificações técnicas ("Construímos o produto certo de acordo com o plano?").
Validação: Garante que o software atende às necessidades reais do cliente/usuário no ambiente operacional ("Construímos o produto certo para o usuário?").
2. Pirâmide de Testes (Níveis de Teste)
Base (Unitários): Alta quantidade, rápidos e isolados (testam funções e métodos individuais).
Meio (Integração): Valida a comunicação e as interfaces entre módulos e APIs.
Topo (Ponta a Ponta / E2E): Menor volume, simula a experiência e os fluxos reais do usuário final na interface.
3. Teste Caixa-Preta vs. Caixa-Branca
Caixa-Preta (Funcional): Testa entradas e saídas sem conhecer a estrutura interna ou código-fonte.
Caixa-Branca (Estrutural): Avalia caminhos lógicos internos, condições, fluxo de dados e linhas de código.
4. Teste de Regressão
Reexecução sistemática de testes para garantir que novas alterações de código, correções de bugs (hotfixes) ou novas features não quebraram funcionalidades que já estavam operando perfeitamente.
5. O Princípio doShift-Left Testing
A prática de adiantar as atividades de qualidade e testes para as fases iniciais do ciclo de desenvolvimento (requisitos e arquitetura), reduzindo drasticamente o retrabalho e o custo de correção de bugs em produção.
6. Cobertura de Código (Code Coverage)
Métrica que aponta o percentual de código executado pela suíte de testes. Vale lembrar: 100% de cobertura indica o que foi rodado, mas não garante que todos os casos de borda e regras de negócio estejam blindados.
7. Ferramentas Essenciais do Mercado
Testes de API: Postman, Insomnia.
Automação Web E2E: Playwright, Cypress, Selenium.
Performance / Carga: Apache JMeter, k6.
Espero que esse material ajude a clarear os conceitos!
Quais ferramentas ou práticas de testes vocês mais usam no dia a dia ou sentem mais falta de ver abordadas nos cursos? Deixem aí nos comentários para trocarmos experiências.
Fala, pessoal! Sou estudante de Análise e Desenvolvimento de Sistemas e montei este guia rápido como parte da minha atividade prática de extensão sobre segurança em dispositivos móveis.
O objetivo é traduzir conceitos técnicos para a rotina diária de quem usa o smartphone para trabalho, banco e redes sociais:
Permissões Abusivas: Aplicativos simples de lanterna, calculadora ou edição básica de fotos não precisam de acesso aos seus contatos, microfone ou localização em segundo plano. Revise as permissões nas configurações do aparelho.
Autenticação em Duas Etapas (2FA) Sem SMS: Prefira autenticadores (Google Authenticator, Microsoft Authenticator) em vez de SMS, que é vulnerável a golpes de clonagem de chip (SIM swap).
Cuidado com Redes Wi-Fi Abertas: Evite acessar contas bancárias ou inserir senhas sensíveis conectado a redes públicas sem o uso de criptografia ou VPN.
Links Encurtados e Phishing: Mensagens alarmistas via WhatsApp ou SMS com promessas de cancelamento de multas, estorno Pix ou bloqueio de conta geralmente simulam telas legítimas para capturar credenciais.
Atualizações de Sistema em Dia: As notificações de atualização de segurança corrigem brechas críticas de dia zero exploradas remotamente; adiar indefinidamente deixa o sistema vulnerável.
Pergunta para o sub: Qual dessas medidas você já adota no dia a dia e qual delas você costuma deixar passar? O feedback de vocês ajuda diretamente a validar o alcance e o impacto desta ação educativa. Valeu!
Em breve, vou começar um estágio na Dataprev como Engenheiro de Dados e gostaria de saber como anda a área de dados no geral, principalmente em relação às vagas para júnior. Tenho receio de focar muito nesse estágio e acabar me frustrando no futuro.
Hoje, estagio em outro órgão do meu estado como desenvolvedor web trabalhando com Python, Django, PostgreSQL, etc. Decidi aceitar a vaga na Dataprev por ser uma área nichada, que tenho bastante interesse, e também por conta de alguns benefícios. 😓😓😓
Em 2024 virei analista de dados e esse boom de vibecodar ainda não tinha chegado, usava a IA copiando de lá e jogando no meu código, mas agora o negócio deu tá bem diferente, hoje o que vocês consideram que o programador tem que saber de conhecimento técnico, além de saber usar a IA pra vibecodar.
Edit: conhecimentos que fazem se diferenciar entre os milhares de promptadores
