domingo, 9 de dezembro de 2018

Forma simples de criar e rodar uma aplicação react native no celular

Como criar uma aplicação react native e rodar em um aparelho android?


- Primeiro, execute no terminal o comando: 

lsusb

- Deve aparecer uma lista mais ou menos assim:

Bus 002 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub 
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub 
Bus 001 Device 003: ID 22b8:2e76 Motorola PCS 
Bus 001 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub 
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub 
Bus 004 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub

Na lista acima, identifique o ID correspondente ao seu aparelho e execute o comando abaixo com o ID identificado acima:

echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="22b8", MODE="0666", GROUP="plugdev"' | sudo tee /etc/udev/rules.d/51-android-usb.rules
*Isso permite incluir seu aparelho na lista de dispositivos disponiveis para debug

- E então, escolha onde quer criar seu projeto e crie o projeto base com o comando: 

react-native init AppTeste

- Entre na pasta do projeto criado:

cd AppTeste

-Execute o comando abaixo (com o aparelho ja conectado em modo debug):

react-native run-android

domingo, 25 de novembro de 2018

vscode salvar arquivo ou pasta como administrador

Como alterar um arquivo sem ter que usar privilegios de administrador no linux?

Bom, antes de mais nada tenho algo a dizer: Esse artigo não é um artigo oO? Isso mesmo, é mais uma dica para resolver de uma forma decente algo que é um pouco chato enquanto desenvolvemos no linux.

Ok, e?

Ocorre que quando criamos nossos projetos, dependendo de onde e como criamos nosso workspace, acabamos por ter um diretório onde o dono é o root e tudo que criamos dentro dele, acaba herdando a propriedade, grupo e permissões. E nós percebemos isso quando vamos alterar um arquivo e uma IDE ou editor de texto não altera a menos que executemos a ação de salvar como super usuário.

Para evitar problema com seus projetos (caso isso ocorra com você), faremos:

- Primeiro crie ou localize via terminal a pasta onde pretende colocar todos seus projetos (geralmente chamamos de workspace): Eu gosto de criar no /home/<USER>/workspace
- Pasta workspace criada, no terminal teremos: <USER>@<USER>: ~/workspace$
- Caso a pasta workspace já exista e tenha conteúdo, verifique quem é o dono usando: ls -al
- E para alterar para seu usuário, faça execute o comando na /home/<USER>sudo chown <USER>:<USER> -R workspace/

Dessa forma você garante que os projetos atuais e os próximos criados dentro de workspace, não lhe trarão problemas de permissão, pois são do próprio usuário que está editando.

Aeeeeee :D chuva de CTRL + S no vscode

terça-feira, 20 de novembro de 2018

Emulador do android e variáveis de ambiente no linux

Como configurar o emulador do android e as variáveis de ambiente necessárias?


Feriado rolando e o que fazer com esse belo dia? Um curso de react native, claro!
Na verdade comprei o curso para incentivar minha esposa a estudar desenvolvimento mobile e tudo estava muito bem até o primeiro erro acontecer :'(

Bom, não é de hoje que problemas de configuração de ambiente são comuns (e o linux é um pouco mais chato quando tratamos de configurações e para quem está iniciando -depois de um tempo vc aprende a amar S2-). Só pra esclarecer, erros de ambiente são normais, em qualquer plataforma e com tempo e experiência você acaba resolvendo essas coisas naturalmente, sem ser massacrado (mas no início, sim, vc vai tomar uma bela surra de configurações, erros de ambiente, vai descobrir que existe o stackoverflow e sua vida vai mudar). Enfim, chega de bla bla bla e vamos para o problema... ahmm?? oO

Para, para, para, para...

Antes, apenas para contextualizar. O curso que comprei e incentivei minha esposa estudar é o curso de React Native do Professor Leonardo Moura Leitão - https://www.udemy.com/curso-react-native/ - (que pra mim, é o melhor instrutor do Udemy -não conheço o cara e nem tem relação com o cargo dele, só gosto das aulas dele mesmo hehe).

Enfim, o problema (ou, os problemas)

Já na seção 2 do curso, o erro a seguir ocorreu no terminal: ERROR: x86 emulation currently requires hardware acceleration! Esse erro ocorreu por falta de permissão para o usuário atual no grupo /dev/kvm. Mas antes de chegar nesse problema, por algum motivo eu fui verificar as variáveis de ambiente e após fechar o terminal e abrir novamente, constatei que elas não estavam mais no PATH.

Certo, então como configurar as variáveis de ambiente no linux para ficarem definitivamente no path?

Bom, pelo terminal, com seu usuário, usando o export NOME_VARIAVEL="valor", funciona para a sessão atual, mas e se eu quero que esses valores fiquem permanentemente no meu PATH (e eu quero). Então preciso dos passos vem a seguir:

- sudo vim ~/.profile
no fim do arquivo (e já estou contando que nesse momento o android studio já está instalado), adicionamos as linhas:
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
export ANDROID_HOME=$HOME/Android/Sdk
export PATH=$PATH:$ANDROID_HOME/emulator
export PATH=$PATH:$ANDROID_HOME/tools
export PATH=$PATH:$ANDROID_HOME/tools/bin
export PATH=$PATH:$ANDROID_HOME/platform-tools
(dica: i para modo de inserção, depois de editar pressione esc e digite :wq para sair e salvar)
- source ~/.profile

Feito isso, basta fechar o terminal e agora estará disponível sempre que você abrir o terminal.

Certo, variáveis configuradas, mas ainda temos o problema de permissão no grupo /dev/kvm

Para resolver isso, vamos seguir os passos abaixo no terminal:
- sudo apt install qemu-kvm
- sudo adduser <seu usuário do sistema> kvm
- reinicie o computador (sim!)

Alguns fóruns recomendam que você use o próximo comando:
- sudo chown <seu usuário do sistema> /dev/kvm

*Não faça isso. Isso vai resolver sem reiniciar pois estará trocando a propriedade do grupo para o seu usuário. Mas tem cara de gambiarra. Apenas reinicie o computador e seu usuário estará no grupo.

Agora o emulador do android já deve executar perfeitamente. Teste via terminal:
- emulator -list-avds
(copie o nome se aparecer um nome - se não aparecer você terá de configurar uma avd e isso é mais simples pelo android studio)
- emulator -no-snapshot -avd <nome copiado>

E... tá lá :D



Flwss, espero ter ajudado. :P


Referências:
https://stackoverflow.com/questions/37300811/android-studio-dev-kvm-device-permission-denied
https://sempreupdate.com.br/como-configurar-uma-variavel-no-path-do-gnulinux/

quinta-feira, 4 de outubro de 2018

Quadro você programador no programa Inova 360

Eu estive no quadro você programador no programa Inova 360 da Record News

Dia 30 de setembro foi ao ar mais uma edição do quadro você programador no programa Inova 360 da Record News. O quadro é um espaço que trata assuntos relacionados a área de tecnologia da informação e os convidados contam um pouco da própria experiência na área.

O quadro




O programa completo (23:05 min)




Então se você é ligado em tecnologia, inovação, gestão e startup. Você certamente vai gostar do conteúdo do programa. Clique aqui e confira o canal do Inova 360.

domingo, 23 de setembro de 2018

Linguagem de programação Rust

Rust, uma linguagem rápida e segura?

Ontem, dia 22 de setembro, aconteceu a 3ª edição do #abcdev (confirma detalhes do que rolou nesse link) e eu estava lá. O evento aconteceu em São Caetano no Auditório do Centro de tecnologia Leandro Klein e foi patrocinado por algumas gigantes como redhat, via varejo, nubank e outras.

Ah, Fui um dos primeiros a chegar :). E quando digo que fui um dos primeiro, eu fui exatamente o segundo. Na minha frente estava um colega (não tem nada a ver com pontualidade, só nos confundimos e chegamos uma hora antes :P rsrs).

O evento teve uma série de palestras e em uma delas, apresentada pelo Bruno Rocha da redhat, me foi apresentado o Rust. Uma linguagem de programação que se define como sendo uma linguagem de programação de sistemas que opera de maneira incrivelmente rápida, evita os defeitos e garante a segurança da thread. É importante mencionar que não fiquei nessa palestra por estar empolgado com Rust. Eu nem mesmo sabia que existia Rust. Porém, no momento em que o Bruno disse que ela é uma linguagem que se propõe a ser mais rápida que C e C++, eu imediatamente ofereci uma overdose de atenção a cada palavra daquele momento em diante.

O Bruno mencionou muitos detalhes sobre a segurança da linguagem, o fato do compilador evitar que você escreva um código fraco que leve a erro de runtime. A performance dela superar a performance de linguagens como C e C++ e a sintaxe ser um tanto quanto agradável (considerando a categoría em que ela se posiciona).

Beber cerveja e assistir meu time jogar ou programar em uma nova linguagem?

Pff, não tem nem o que se discutir né?; claro que escolhi programar! Obviamente fiquei curioso e não conseguiria terminar o final de semana sem brincar com Rust e compartilhar um pouco do que fiz.

Maravilha, show me the code!

Não!, Antes de olhar qualquer código, faça exatamente o que eu não fiz (seguir a recomendação do Bruno Rocha na instalação).
Instale seguindo os passos abaixo (e recomendo fazer isso para que você não saia digitando código, queira compilar e acabe por instalar parcialmente seu ambiente e depois tenha que desinstalar tudo para conseguir fazer direito).

- Certifique-se de ter o curl instalado
- Via terminal, execute: curl https://sh.rustup.rs -sSf | sh

Agora, vamos para a IDE

Eu não segui nenhuma recomendação do rust-lang.org, e tão pouco do Bruno. Fui direto pra minha IDE favorita e certamente encontrei um plugin. Ou seja, abri o visual studio code e busquei por Rust.

Tudo configurado, hora de "codar"

A primeira coisa que fiz foi exatamente a primeira coisa que devemos fazer. Isso mesmo, um Hello World. E curti muito o println!("{0} {1}", ..., ...);

E então pensei, o que fazer para usar alguns recursos a mais?

Resolvi escrever um programa para consultar uma lista de nomes da esquerda para direita, ignorando o case. E acredite, é um saco trabalhar com string no Rust. Mas, gostei mesmo assim, poderia ser pior (se fosse em C, por exemplo). Se liga no resultado:

- Primeiro criei meu arquivo main.rs (pode ser qualquer nome, mas a convenção do rust sugere que você use hífen como separador no nome dos arquivos caso tenha dois nomes .rs, por exemplo batata-quente.rs).
- Depois criei o ponto de início de qualquer programa Rust (o método main).
- E escrevi o código abaixo:


fn main(){
println!("{0}, {1}. {2}", "Olá",
"Esse é meu primeiro programa Rust (depois do hello world!)",
"\nAbaixo vou listar os nomes iniciados por \"r\"");

println!("{}", familia_celebrone("r"));
}

fn familia_celebrone(filtro: &str) -> String {
let nomes = ["Rodrigo", "Renan", "Flávia", "Ivone", "Sofia",
"Robson", "Carol", "Pedro", "Flaviano", "Creonice"];
let mut nomes_filtrados = String::new();

for(_i, nome) in nomes.iter().enumerate() {
let mut nome_cortado : String = nome.to_uppercase()
.chars().take(filtro.chars().count()).collect();
let mut filtro_cortado : String = filtro.to_uppercase().to_string();

if nome_cortado == filtro_cortado {

nomes_filtrados.push_str(nome);
nomes_filtrados.push_str(", ");
}
}

return nomes_filtrados;
}

- Feito isso, compilei com rustc main.rs
- E rodei o comando ./main para ver o resultado
- O resultado foi exatamente: "Rodrigo, Renan, Robson, " (é, não retirei a última vírgula por pura preguiça, já passa da meia noite).
- Perceba que em alguns lugares usei mut, pois por padrão o Rust é imutável. Pode parecer loucura, mas se observarmos a quantidade de cagada que fazem em outras linguagens, faz sentido inverter esse padrão.
- Outra coisa curiosa é o _i ali no for. O compilador recomendou que eu coloque um _ no ínicio de variáveis que não são utilizadas.

Enfim, é isso. No geral eu gostaria de deixar registrado que esse evento foi muito bem organizado. Rico de conteúdo e me apresentou uma linguagem que eu desconhecia. Sem mencionar os Web Components nativos com polymer, mas isso vou deixar como spoiler.

Vlw, abraços e espero que gostem do Rust assim como eu gostei :)


terça-feira, 21 de agosto de 2018

Java dentro do Oracle

Programando em Java, no Oracle, sem usar Load Java tool

Existem 3 tipos de pessoas. As que sabem o que vou escrever aqui, as que já usaram apenas o Java Load para carregar classes no Oracle e as que acham que isso não existe. Pois bem, se você é a segunda ou a terceira, siga a leitura. Se for a primeira, veja foto de gatos.

A verdade é que faz um bom tempo que trabalhei com classes java dentro do Oracle. Algo em torno de 7 anos ou mais e um projeto em particular, me fez considerar utilizar java para compartilhar a solução na aplicação e no Oracle.

A abordagem utilizando Java Load Tool, basicamente pega um .class ou .jar e carrega dentro do Oracle usando uma ferramenta que existe junto com a instalação do Oracle (o Java Load). Essa solução é bem conhecida e foi exatamente essa que utilizei a alguns anos. E existe uma infinidade de referencias ensinando a trabalhar com essa abordagem, como por exemplo essa, essa outra e essa aqui também. Em resumo, com essa abordagem você escreve sua classe ou seu programa java, compila e utiliza o utilitário java load para carregar seu compilado dentro do Oracle, tornando as operações da sua classe disponíveis para executa-las dentro do Oracle. 


Bacana né? nem tanto! poderia ser melhor... 

Como algo tão simples como compilar uma classe e carregar usando uma ferramenta não é simples?
Primeiro que você tem que executar o Java Load dentro do servidor do Oracle e isso por si só, já é um problema. Imagina em empresas de grande porte? Solicitar ao DBA, aguardar a fila de execução dos chamados para saber se compilou com sucesso. Ou em alguns casos mais rigorosos, você teria de apresentar o código e explicar ao DBA cada linha que está entrando dentro do banco de dados. Afinal, é uma classe compilada que será carregada por um utilitário. Não é apenas abrir uma procedure (por exemplo). 


Então ta, vamos então burlar o DBA ? 

Não, não vamos enganar o DBA, vamos tornar as coisas mais claras e mais simples para nós.
Assim como functions, procedures e outros objetos, podemos compilar um arquivo ".jsp" (não é o que você está pensando). Esse arquivo é exatamente uma classe java, com uma assinatura semelhante a de uma procedure. Assim:

create or replace and compile java source named HojeEhDia as

import java.util.Date;
import java.util.Calendar;

public class HojeEhDia
{
    public static void main(String[] args) {
        System.out.println("hoje é dia: " : hoje("/"));
    }

    public static String hoje(String separador) {
        
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());

        int dia = calendar.get(Calendar.DATE);
        int mes = calendar.get(Calendar.MONTH);
        int ano = calendar.get(Calendar.YEAR);

        return dia+separador+mes+separador+ano;

    }
}

Feito isso, você só precisa chamar sua operação usando uma function do Oracle. Assim:

CREATE OR REPLACE FUNCTION HojeEhDia_Java(separador IN VARCHAR2)
RETURN varchar2 AS

LANGUAGE JAVA NAME 'HojeEhDia.hoje(java.lang.String) return java.lang.String';

E está pronto :) Criamos um objeto do tipo Java Source e uma function para chama-lo. Para testar, basta um select:

select HojeEhDia('/') from dual;

Tudo compilado, facilmente modificável, como um simples objeto Oracle deve ser. 
Só fique atento com os imports. Referencias que não são nativas do java, até funcionam, mas você deverá colocar o .jar delas lá no servidor de banco de dados, na instalação do Oracle.

Me ajudou, espero que te ajude também :) Até a próxima!

domingo, 12 de agosto de 2018

Programação funcional em C#

Programação funcional com C#, na prática, para o dia a dia

Tem algo mais frustrante do que abrir o stackoverflow e ver que a única resposta é uma que não serve para nada e foi claramente publicada ali, só para que o sujeito ganhasse pontos fáceis? Sim, tem!

Tente buscar no Google sobre programação funcional e terá a mesma sensação (teoria, teoria e mais teoria).

Na equipe onde trabalho, temos um evento periódico que carinhosamente atribui o nome de DevTalk. Esse é um espaço para que os times de desenvolvimento troquem informações sobre determinados assuntos. Eu sempre sugiro que eles apontem assuntos para pesquisarmos e discutirmos nesses encontros (não é nada aleatório, a ideia é pensarmos fora da caixa, trazer ideias e avaliar se cabe no nosso dia a dia; para que aos poucos coloquemos em prática).
Na semana passada, apontaram como assunto "programação funcional"... E foi ai que resolvi escrever esse post (depois de um bom tempo sem publicar nada) ;/

Mas que diabos é isso?

Eu poderia escrever um monte de baboseiras aqui, como de onde veio, quando veio, quem teve a ideia. Mas não, isso está aos montes na internet (aqui, aqui e também aqui) e o paradigma funcional não é nada novo, só está em evidência pois agora o processamento paralelo está sendo amplamente utilizado nos sistemas web.


Então pra que esse artigo?

Como o próprio sub titulo diz. A ideia aqui é mostrar na prática como trabalhar com programação funcional em um cenário real (não esses montes de blocos de códigos espalhados nos artigos e que só trazem dúvidas ao invés de esclarecimentos).


Let it go, let it go...

Vou colocar abaixo uma classe c# com operações bancárias, da forma como fazemos no dia a dia e depois vou aplicar nessa classe os conceitos de programação funcional e explicar as vantagens de um modelo para o outro.

public class Caixa {
   private double Saldo {get; set; }

   public Caixa(double saldoInicial){
      this.Saldo = saldoInicial;
   }

   public void Depositar(double valor) {
       this.Saldo += valor;
   }


   public void Sacar(double valor) {
       this.Saldo -= valor;
   }


   public string ImprimirExtrato() {
       return "Seu saldo atual é de: " + this.Saldo;
   }
}

Usando exemplo 1):
var caixa = new Caixa(10.5);
caixa.ImprimirExtrato();
caixa.Depositar(31.4);
caixa.Sacar(5.7);
caixa.ImprimirExtrato();




public class Caixa {

   public double Depositar(this double saldoAtual, double valor) {
       return saldoAtual += valor;
   }


   public double Sacar(this double saldoAtual, double valor) {
       return saldoAtual += valor;
   }


   public string ImprimirExtrato(this double saldoAtual) {
       return "Seu saldo atual é de: " + saldoAtual;
   }
}

Usando exemplo 2):
double saldo = 10.5;
saldo.ImprimirExtrato().Depositar(31.4).Sacar(5.7).ImprimirExtrato();


Enquanto isso, no dia a dia...

Observando os exemplos acima, a grande "vantagem", é a forma como utilizamos os métodos. Parece mais "legível" e para por aí. Porém, se pensarmos em utilizar esse formato em um ambiente multi-threading, as vantagens crescem infinitamente. É possível executar operações exatamente após a operação anterior e os problemas com mutabilidade que frequentemente encontramos na programação imperativa, são minimizados ou até mesmo eliminados por completo. Mas, Porque? 

Imagine que as mesmas operações acima, são assíncronas (um app web, SPA por exemplo) e utilizam multi-processamento:

Se "caixa.Depositar(31.4)" fosse uma operação mais demorada que "caixa.ImprimirExtrato()", em um cenário multi-threading, o valor do extrato seria impresso sem considerar o depósito de 31.4, pois as operações executam paralelamente. Então, no mundo imperativo, utilizamos algo como: "caixa.Depositar(double valor, Action callback)" para resolver o problema e então teríamos algo semelhante a isso:


var caixa = new Caixa(10.5);
caixa.ImprimirExtrato(() => {
   caixa.Depositar(31.4, () => {
      caixa.Sacar(5.7, () => {
         caixa.ImprimirExtrato();
      });
   });
});

Certo, e qual o problema com isso?

Além de feio, bizarro e complexo? Observe o método "ImprimirExtrato()". Para essa implementação, eu teria de ter 2 métodos "ImprimirExtrato()" e "ImprimirExtrato(Action callback)" na minha classe Caixa. Um que recebe um parâmetro do tipo Action (para executar um callback) e outro sem esse parametro. Estaríamos aumentando a quantidade de código, os pontos de manutenção e a complexidade pelo simples fato de não utilizarmos o paradigma funcional.


Então eu devo utilizar funcional sempre que trabalho com multi-threading?

Preferencialmente, sim. Mas sempre vai depender da sua necessidade. Se seu problema exige trabalhar com Imutabilidade de estado; trabalhar com o paradigma funcional pode ser de grande ajuda. No geral, sistemas que trabalham com computação matemática, inteligência artificial e processamento paralelo são sistemas onde o paradigma funcional funcionará melhor do que a programação imperativa. Mas podemos ter sistemas tradicionais, aplicações web e em determinados pontos usarmos o paradigma funcional para resolver o problema com maior elegância, eficácia e eficiência.

Ah, se você tem pelo menos mais de 5 anos em desenvolvimento de software, certamente você já teve problemas com inclusão e processamento de arquivos em banco de dados e teve que criar controles absurdos para contornar esses problemas, não foi? Pense como sua vida teria sido mais fácil usando o paradigma funcional (não fica triste não, eu todos já passamos por isso rsrs).

Espero ter ajudado de alguma forma, até a próxima =)

domingo, 29 de abril de 2018

Como eu conquistei a certificação PSM I

Passos para conquistar a certificação PSM I da Scrum.Org

Esse mês de abril foi bem corrido. Além do curso de CI e CD da 4linux (que recomendo bastante), foi o mês que conquistei a certificação PSM I da scrum.org com nota de 96,3% Essa certificação é classificada como nível intermediário, mas, após seguir os passos abaixo, você vai classificar sentir uma segurança e facilidade extrema no momento da prova.

Material de estudos

Utilizei como fonte de estudos o curso preparatório para a certificação PSM I da TI Exames. O curso possui 18 horas distribuídas em alguns módulos (link do curso). Possui simulados e comentários de aprovados com recomendações de estudo.

Antes de iniciar o curso, resolvi fazer um simulado para entender onde eu estava e o quando eu precisava me dedicar para ter 100% de segurança no dia da prova (e não adiantou, fiquei nervoso do mesmo jeito rsrs). No simulado que fiz, antes de iniciar os estudos, fiquei com 60% (precisa de 85% para ser aprovado). Bom, essa é minha primeira recomendação: Não faça essa cagada etapa. Tentar medir meu conhecimento só serviu para que eu ficasse nervoso até ter finalmente feito a prova e ter sido aprovado. Foi uma estupidez. Eu sou ansioso e isso só piorou as coisas. Então, estude o material da TI Exames antes de fazer qualquer simulado.


Scrum guide

Leia no mínimo uma vez o scrum guide. É um PDF de 19 paginas. Eu li em uma noite, em torno de uma hora você consegue ler ele por completo. Essa etapa é recomendada por muitos que tiraram a certificação. Por mais que muitas das questões sejam situacionais, ou seja, será apresentada uma situação e a partir dos seus estudos você deve indicar qual a melhor resposta para aquela situação (então é normal muitas das questão terem mais de uma alternativa verdadeira - a correta será a que é melhor aplicada na situação em questão).

A leitura do scrum guide permite que você entenda os princípios do scrum e os motivadores, auxiliando para que você não falhe nas questões com mais de uma alternativa verdadeira.


Simulados, simulados e mais simulados

Concluindo o material de estudos e a leitura do scrum guide, é hora de fazer simulados até não querer mais olhar para eles. Uma recomendação que li nos comentários de um dos alunos da TI exames é que eles façam os simulados até atingir uma média de 95% em todos os simulados. Ou seja, a dica aqui é fazer simulados até sua pontuação atingir 95% em todos os simulados

Ah, a scrum.org tem um simulado com 30 questões básicas sobre scrum. Se você não gabaritar esse simulado, nem pense em tentar a certificação.


Anotações

Por fim, após todas as etapas anteriores, eu recomendo fazer anotações. Anote tudo aquilo que errou nos simulados e leia novamente o assunto. Anote também tudo aquilo que tem dúvidas ou que você acredita ir em desencontro com qualquer outro ponto dentro do scrum.

Escrever ajuda a memorizar. Veja como eu fiz:






sábado, 28 de abril de 2018

Aula de Desenvolvimento de Software

Montei o cronograma, apresentamos a proposta, montamos a turma e foi um sucesso.


Gusteau no filme "Ratatouille" dizia: Qualquer um pode cozinhar. Eu digo: Qualquer um pode programar... E foi com base nessa crença que planejei, montei um cronograma e abrimos a oportunidade para que qualquer pessoa na empresa, pudesse se inscrever para participar do treinamento de desenvolvimento de software com C# .Net.

É de conhecimento de muitos que tenho buscado uma oportunidade para colocar em pratica um projeto social para dar aulas de programação para crianças (a partir dos 12 anos +-), porém estamos no Brasil e nem todo mundo tem interesse em apoiar um projeto sem fins lucrativos. Um projeto que o objetivo é apenas ensinar por ensinar.

Expondo esse meu interesse, a empresa onde trabalho resolveu organizar um projeto para aplicarmos isso internamente. Sem nenhum objetivo, apenas para dar oportunidade para pessoas de áreas totalmente aleatórias, de conhecerem e praticarem programação de software.

O projeto

A primeira etapa do projeto, foi montar um cronograma. Eu já tinha um montado para o projeto das escolas, mas precisava adaptar pois não iria mais ensinar crianças de 12 anos, mas sim profissionais de áreas diversas (e foram diversas mesmo rsrs). Basicamente retirei exemplos onde utilizo jogos como MineCraft, Roblox e outros para explicar sobre comunicação entre cliente e servidor, ou apps como WhatsApp e Facebook para explicar estruturas básicas destes softwares, como também removi alguns pontos onde demonstro e sugiro jogos para praticar programação como o Code Combat. Filtrei um pouco o conteúdo e inclui algumas instruções sobre como e porque debugar, e obviamente, usei os softwares da empresa como ferramentas para explicar estrutura, arquitetura e decisões tomadas com base no que negócio (bem como a influência do negócio no produto final).

Caso tenha interesse em aplicar esse projeto na sua empresa, fica ai um exemplo do cronograma base que utilizei: link do google drive


Ok, mas como foram as aulas?

Busquei usar o cronograma como base e eu aumentava ou diminuía a complexidade de acordo com o avanço dos alunos. Passamos por conceitos, esclarecimento de dúvidas, até chegar ao Html, Css, Javascript e concluir com C# usando o padrão MVC do .Net framework MVC. As aulas não foram code, code, code... Para ter uma ideia, eles sabem o que é MVC, o que é um Framework, um servidor web. Eles sabem que a aplicação no servidor entrega um código HTML para ser renderizado no browser (eles sabem o que é renderizado rsrs). Busquei explicar todas essas siglas e nomenclaturas que para nós que somos de desenvolvimento de software é algo tão comum como colocar a roupa depois de sair do banho. O resultado foi satisfatório. No final, entreguei na mão deles classes e views fora de um projeto (dentro de um arquivo rar) e eles tiveram de criar um projeto usando Visual Studio 2017 (empty + MVC - expliquei que NUNCA devem usar o template MVC por montar um projeto com muita coisa que provavelmente não usaremos. Então usar um projeto em branco e configurar tudo foi a abordagem que usaram, e fizeram isso perfeitamente bem). O modelo do projeto utilizado eu disponibilizei no GitHub

Obviamente eu não iria apenas entregar classes para que eles montassem um projeto. Isso seria simples. Eu entreguei classes com diversos erros e bugs. Então, além de construírem o projeto, eles tiveram de tratar os bugs, debugar, ler o stacktrace, identificar onde estava o problema e corrigir. E sinceramente, eu fiquei impressionado com o resultado. Se não me engano foram 12 horas de curso. Conseguimos um resultado muito bacana. A cada aula eu buscava entregar dicas no grupo de e-mail que criamos, matérias para que eles pudemos compreender mais o que discutimos naquela aula. E no final, enviei alguns cursos gratuitos para que eles seguissem com os estudos.

O Code School tem algumas opções interessantes para auxiliar quem está iniciando. E obviamente o queridinho de todos, o Udemy.

No LinkedIn é possível ver um pedacinho do que rolou por lá.



Então é isso. Termino por aqui reforçando o que falei no início desta postagem: Qualquer um pode programar!.

Bônus: Ah, de quebra arrecadamos doações para a APAE de São Caetano do Sul :)

domingo, 15 de abril de 2018

Programação assíncrona, async e await e conceitos

Cada vez mais estamos utilizando o conceito de programação assíncrona. Agora com as facilidades do async e await presentes desde do .Net Framework 4.5, podemos melhorar a experiência do usuário com pequenas alterações no nosso código.

Não pretendo explicar muito sobre isso pois muitos outros já fizeram isso. Como esse artigo bem esclarecedor no site da Microsoft ou até mesmo, esse outro do Marcoratti.

Então, mão na massa

Nesse primeiro caso, quero exemplificar uma situação comum, onde precisamos executar nosso Action e dentro do Action quero executar uma ação que não impacta na UI, mas que deve ser executada (um registro de log, por exemplo). Então, ao invés de:




Perceba que o tempo de resposta é pouco mais de 10 segundos. Porque? Porque o método TrabalhoQuePrecisaExecuta(), rodou na mesma thread que as outras operações. E quando fazemos isso, estamos enfileirando as execuções.

Podemos fazer isso (vale lembrar que não precisamos do async e await para usar essa abordagem. O que estamos fazendo aqui, é apenas isolando nosso código em uma thread a parte):


Perceba que o simples fato de jogar o TrabalhoQuePrecisaExecutar() dentro de um Task.Run, deixamos de enfileirar esse processamento e nosso Action simplesmente passou por por essa operação, mandou executa-la em outra thread e seguiu com nosso código.

Mas e quando eu quero que meu método async retorne algo para a UI?


Bom, vamos pensar... Se eu quero que um método que está em outra thread, retorne algo para minha UI, eu preciso obrigatoriamente, esperar esse método carregar e fatalmente vou cair na mesma situação exposta no primeiro caso:




Ué, então não existe mágica?

Não existe :( 

Mas, existe o conceito de estratégia, em grego strateegia, em latim strategi, em francês stratégie...

O que sabemos?
- Se jogarmos nosso código em uma thread separada, isolamos o processamento. 
- Se usarmos o Result, podemos recuperar o retorno (isso causa block).

Então, se eu deixar meu código dentro de uma thread logo no início (sabendo que ele demora para executar), seguir com o processamento e pedir o resultado da thread no final, vou "processar em paralelo e reduzir o tempo de resposta". Assim:


Lol, faz sentido O.o !

Mas, e onde entra o async e o await em toda essa história?

Certamente você leu o artigo do Marcoratti e da Microsoft que coloquei no inicio do post (eu sei que você nem clicou), então, deve ter percebido que o async e o await, permitem que eu execute Tasks uma após a outra, mas ainda em paralelo. O próximo teste, usar o código acima, mas vou chamar o método TrabalhoQuePrecisaExecutar() 2 vezes dentro de uma outra thread e utilizar o async e await para paralelizar as duas execuções e somar os retornos. E a thread principal, no result (que vai bloquear a execução na thread principal), vai pegar a soma dessas duas operações. ou seja:



Nos exemplos onde usamos o .Result, perceba que ele tem o mesmo efeito que o await, pois trava o processamento até conseguir recuperar o retorno da thread.

Para colher todos os frutos dessa abordagem, é interessante trabalhar com esse backend em aplicações SPA. Assim podemos utilizar chamadas assíncronas (com ajax) sem bloquear a UI do usuário em momento algum.

Nos exemplo acima, a partir do momento que usamos um controller e um action para retornar os dados em uma View tradicional, estamos bloqueado, porém, usando algumas abordagens para otimizar o tempo de resposta usando os conceitos de programação assíncrona.

Dentro de um controller, por vezes somos obrigados a chamar alguma API externa e acabamos por cair nessa situação. Para essas situações onde a requisição é síncrona e uma implementação dentro dela necessita de uma chamada assincrona, usamos o .Result para garantir o retorno. Não é o melhor cenário, mas para essa situação, em implementação pontual, resolve sem ter de refatorar toda a aplicação.

sábado, 10 de fevereiro de 2018

Como o ensino será influenciado pela tecnologia?

Faz alguns dias que iniciei uma série de questionamentos, com diversos profissionais de áreas distintas sobre a influencia da tecnologia no ensino. Surgiram várias opiniões e previsões, desde as mais conservadoras, acreditando que pouca coisa vai mudar até algumas que descaracterizam totalmente o formato do ensino como conhecemos hoje.


Vale lembrar que estamos tratando do ensino médio. É no ensino médio que o jovem é direcionado para a área do conhecimento que mais lhe interessa e é no ensino médio que o jovem deve ser apresentado as profissões que serão ofertadas quando esse jovem sair do ensino médio e faculdade.

Certo, e o kiko?

Ocorre que, eu, assim como outras pessoas, acreditam que o ensino na forma como ele conduzido hoje nas escolas, tende a limitar a visão dos futuros profissionais, visto que as profissões do futuro, deveriam ser apresentadas aos seus profissionais, agora, no presente.
Não estou dizendo que temos de parar de ir para a escola e focar apenas em tecnologia. Não, pelo contrário. A Escola precisa reduzir ou eliminar conteúdo que não tenha relação direta ou indireta com as profissões do futuro. Um exemplo que me ocorreu são os conteúdos que sofrem impacto direto com o passar do tempo, como em geografia, quantidade populacional por região (nossa, tive que fazer um trabalho seguido de pesquisas na escola, não lembro absolutamente nada dessa pesquisa, mas caso eu necessite, a wikipedia pode me ajudar).



Mas e o que a maioria pensa?

Os argumentos de diversos colegas, principalmente de profissões que não possuem relação direta com tecnologia, é que muitas das disciplinas que aprendemos na escola, são bases para estimular nossa curiosidade e facilitar a escolha da profissão no futuro.
Aprendizagem de máquina, Internet das coisas, Desenvolvimento de software, Cientista de dados e outras, são exemplos de profissões do momento e eu sinceramente não me recordo de ter sido estimulado para se quer conhecer qualquer uma dessas opções!



Porque eu acredito estar certo?

A relação entre minha profissão atual e o que aprendi na escola (vale reforçar que de todas as disciplinas, matemática era a que eu mais detestava e fui parar em exatas) e praticamente inexistente. Ah, e eu detestava matemática porquê me foi apresentado Teorema de Pitágoras, Fórmula de bhaskara, Trigonometria, etc...
A soma dos quadrados dos catetos é igual a hipotenusa... e eu só sei disso por causa da música "Uma Arlinda mulher" dos mamonas assassinas, nem pra isso a matemática no ensino médio me foi útil (Os pedagogos defensores dos métodos lúdicos vão a loucura com essa analogia rsrs).
Não estou afirmando que o conteúdo matemático exemplificado acima, não é aplicável a alguma profissão, talvez um físico nuclear ache isso útil. Porém, se compararmos físicos nucleares e desenvolvedores de aplicativo móvel (por exemplo), qual desses existe maior empregabilidade hoje?
Ou seja, não é para eliminar tudo, mas alterar conteúdos que possivelmente (e depois explico o possivelmente), farão parte da realidade dos profissionais dentro de 10 ou 15 anos.

Por outro lado, existe uma variável que é quase impossível prever, que é o fator inovação. Não podemos prever o que alguém vai inventar amanhã e se essa invenção vai ou não modificar tudo que fazemos (por isso eu disse possivelmente no parágrafo acima). Mas se isso ocorrer, acredito que é nossa obrigação, dos governantes e dos profissionais da educação em responderem rapidamente as mudanças para não jogarem verdadeiros vegetais dentro das faculdades e torcer que eles se identifiquem com algo dentro do mercado de trabalho.

Não é skynet

Existem alguns indícios claros de mudanças que poderiam e deveriam ser imediatamente aplicados no ensino escolar (eu voto colocar qualquer outra coisa no lugar da Fórmula de bhaskara).

- Uber está investindo em carro autônomo para acabar com o maior problema do Uber hoje (o motorista). Imagina como ficaria mais barato usar apenas o Uber do que usar um carro ou até mesmo o transporte público e imagina quantas profissões seriam impactadas com isso. E profissões se fortalecem com essas iniciativas, como Big data, machine learning, IA, IOT, Cloud computing.

- IBM Watson é um sistema capaz de processar o equivalente a 1 milhão de livros por segundo. Não teremos de nos preocupar em pesquisar respostas, os computadores farão isso para nós. O Filme WALL·E é uma animação da Pixar, que trata um pouco desse assunto. Um computador capaz de responder a informações tão rapidamente, com base em instruções catalogadas? O que vai acontecer com advogados, por exemplo? E ciências de dados, programadores, engenheiros e arquitetos de software...?

- Existem empresas startups que hoje trabalham com mineração de informação, buscando o gosto e desejo das pessoas com base na experiência e na intenção delas (sim, apenas de ler um artigo qualquer ou o tempo que você fica dentro de uma página web hoje, já é informação o suficiente para que as empresas consigam lhe oferecer um produto com maiores garantias de sucesso na venda). Sem contar os e-commerces. Se hoje está assim, imagina dentro de 10 anos, como ficam os vendedores? Aqui também cabem diversos programadores (aliais, faltam programadores), arquitetos, Sys admins.

- O Google e outras ferramentas já nos dão informações mais do que suficiente para definirmos se queremos ou não ir a algum lugar. Eu mesmo já deixei de ir em restaurantes, oficinas mecânicas, bares ou pousadas apenas por consultar o que essas ferramentas me oferecem. E o que vai acontecer com todas as pessoas e profissões impactadas por toda essa facilidade? Programadores, programadores e mais programadores, cientistas de dados, BI, Big Data, engenheiro de dados, entre outras...


Então, todo mundo tem que ir para TI?

É certo que TI está abrindo uma gama enorme de possibilidades, hoje muitos profissionais dessa área podem se dar ao luxo de escolher onde querem trabalhar, escolher salários e até mesmo regalias. Mas TI também está se modificando. Porém, como TI trata diretamente tecnologia e inovação, a resposta aos impactos dentro dessa área, é quase que instantâneo (e se você conhece alguém te TI que está com dificuldades no mercado de trabalho, saiba que essa pessoa ainda não percebeu que a faculdade é o menor influenciador dentro dessa área - TEM QUE ESTUDAR TODO DIA). Mas se você não gosta de TI, procure analisar com base na necessidade. Por exemplo, as pessoas estão adquirindo mais informações, conhecendo, mesmo que de longe, novas culturas, então a culinária pode pegar um atalho apresentando sabores de outras culturas para que pessoas possam se aproximar dos sabores dessas culturas.
Outra gama de profissões que podem vir a gerar muito dinheiro, são aqueles que lidam com o lixo. O lixo produzido é cada vez maior, precisamos de ideias, empresas, projetos e profissionais que transformem esse lixo ao invés de despeja-lo no meio ambiente.
A saúde tem se tornado um fator de grande preocupação. Estamos cada vez mais expostos a diversos agrotóxicos, conservantes, gorduras, etc..., então as doenças estão cada vez mais presente e os profissionais da saúde, estão com a bola toda, tanto os profissionais que atuam na prevenção, como os médicos que atuam nas enfermidades. Apesar que esse último em pouco tempo terá uma maior relação com TI, computadores e aplicativos dando diagnósticos já é uma realidade.
Tem diversas outras profissões que estão sofrendo mutações e TI está impactando e ditando o rumo dessas, como profissões que não possuem impacto direto da tecnologia e profissões que estão prestes a acabar (sério, pense bem se pretende estudar direito).



Conclusão

Minha percepção não é do fim dos tempos, apenas acredito que muitos dos conteúdos que apresentamos hoje nas escolas, não será útil na maioria das profissões em que os futuros profissionais serão apresentados.

quarta-feira, 17 de janeiro de 2018

Arquiteto ou Engenheiro de software?

Quais diferenças entre um Arquiteto de software e um Engenheiro de software?

É comum programadores com muito experiência e que busquem um "próximo passo" na carreia, se depararem com cargos de Arquiteto de software e Engenheiro de software e a menos que já tenham buscado esclarecer o que é cada um deles, a dúvida de qual das duas profissões seguir, será algo um pouco chato de se esclarecer. Principalmente por encontrarmos poucas definições claras do que é um Arquiteto de software e/ou Engenheiro de software e suas atuações.

Antes de prosseguir, precisamos entender a origem dos nomes das duas profissões. Os termos foram extraídos da construção civil. Porém, diferente do que acontece na construção civil, arquitetos e engenheiros de software, ainda "deixam de colocar a mão no cimento". Explicarei!


Engenharia de software

De acordo com Friedrich Ludwig Bauer Engenharia de Software é "A criação e a utilização de sólidos princípios de engenharia a fim de obter software de maneira econômica, que seja confiável e que trabalhe em máquinas reais" (veja mais aqui). 

Então, engenharia de software é a área da computação voltada a especificação, desenvolvimento e manutenção de cada componente interno de um sistema de software utilizando-se de padrões de projetos e boas práticas. Na prática, a atuação principal do Engenheiro é nos requisitos funcionais do projeto de software. É também responsabilidade dos Engenheiros, aplicar o uso de padrões de projetos.

Arquitetura de software

De acordo com o SEI (Software Engineering Institute), Arquitetura de software se preocupa com a estrutura ou estruturas de um sistema, com todos os elementos de software vendo e tendo suas propriedades vistas por todos os outros elementos e relacionamentos (veja mais aqui).

Então, Arquitetura de software é a área da computação voltada a definição dos componentes de software, propriedades externas, e relacionamento com outros softwares. O termo também se refere à documentação da Arquitetura de software do sistema. Com o objetivo de facilitar a comunicação entre stakeholders, registrar decisões acerca do projeto, e permitir o reuso dos componentes e padrões entre projetos. Na prática, a atuação principal do Arquiteto é nos requisitos não funcionais do projeto de software. É também responsabilidade do Arquiteto de software a definição de padrões de arquitetura

E onde fica o desenvolvedor?

Bom, sabemos que o Arquiteto vai "definir na interação entre os componentes e sistemas, documentar os sistemas e trabalhar nos requisitos não funcionais" e sabemos que o Engenheiro vai "desenvolver especificar e desenvolver os componentes com base no negócio e nos requisitos funcionais". O desenvolvedor vai codificar as funcionalidades dentro dos componentes, utilizar as documentações e especificações para codificar a integração entre os sistemas e interfaces definidas pelos Engenheiros e Arquitetos.

No ínicio do artigo mencionei que no mundo do software, diferente da construção civil, Arquitetos e Engenheiros precisam colocar a mão na massa. Isso acontece porque, diferente da construção civil, bibliotecas, frameworks e tecnologias surgem a todo instante. É responsabilidade dos Arquitetos e Engenheiros, validarem tecnologias que serão aplicadas dentro do software. Na construção civil, cimento, martelo, e tubulações novas, não surgem a todo momento (tubos e conexões, é tigre). Uma vez que uma marca é consolidada e possui um preço atrativo, essa é utilizada constantemente sem previa validação de outras alternativas. Já no mundo do software, existem diversas tecnologias pagas ou gratuitas e a cada dia surgem mais, então os Arquitetos e Engenheiros precisam garantir que estão utilizando as melhores tecnologias possíveis, para aquele Software.

É isso ai, espero ter sido claro. Eu mesmo já me confrontei com essas questões um dia.