Tag: linux

PHP no Windows 10 – Esqueça o Xampp e Instale o Apache no Subsistema Linux
Uma das melhores coisas do Windows 10 é a possibilidade de instalar um subsistema Linux nele. Com isso, você pode montar o seu servidor Apache direto nesse subsistema, deixando o ambiente local muito mais similar a onde você vai efetivamente publicar, e com muito mais performance e liberdade do que os AMPs disponíveis para o Windows (Xamp, Wamp, Mamp).

Habilitando e Instalando o Subsistema

Primeiro certifique-se que está usando a versão mais recente do Windows 10. Apesar do susbsistema Linux estar disponível há alguns anos, é interessante manter sempre sua máquina atualizada.

Clique em iniciar e digite Ativar ou Desativar Recursos do Windows, ou acesse a partir do Painel de Controle Clássico.

Ao abrir, desça a barra de rolagem até encontrar a opção Subsistema Linux para Windows. Ative a caixa e pressione em OK.

O Windows pedirá para reiniciar o sistema e fará alguns ajustes, para então permitir que você possa instalar uma distribuição Linux.

Uma vez reiniciado, você já pode fazer a instalação da distribuição. Para isso abra Microsoft Store. Na guia Pesquisar, pesquise por Linux. Uma grande opção contendo várias distribuições será mostrada a você.

Escolha a distribuição que melhor funcionar para você. Nesta demonstração iremos usar o Ubuntu, mas se você preferir uma distribuição baseada em outra distro, fique à vontade. Porém a integração do Ubuntu com o Windows é trabalhada em conjunto entre a Microsoft e a própria Canonical, o que deve garantir, teoricamente, uma integração melhor.

Para você trabalhar com o Subsistema Linux, você pode usar o próprio Prompt de Comando, ou o Power Shell, porém, a Microsoft lançou recentemente um Terminal para o Windows. Esse novo Terminal pode ser baixado diretamente pela Microsoft Store e é altamente recomendável seu uso, pois ele traz muitas melhorias para a usabilidade do WSL (Windows Subsystem Linux).

Para finalizar a instalação, simplesmente abra o Terminal e digite: ubuntu (ou o nome da distribuição que você escolheu) e aguarde a instalação. Ele pedirá para você criar uma conta de administrador e a senha.

Após instalar, se você fechar e abrir o Terminal, notará que apareceu mais uma opção para nova aba. Caso você prefira, você pode editar, em Settings, para que o Ubuntu seja o padrão, simplesmente alterando a configuração em seu json. Porém, se preferir, você também pode abrir o Ubuntu simplesmente digitando pelo OS a partir da barra de pesquisas, mas nesse caso ele abrirá o terminal dentro do console padrão do Windows.

Instalando o PHP e MySQL em seu Ubuntu Linux

A partir daqui não é diferente de instalar em um Ubuntu completo, porém, como a maioria dos usuários de Windows não possui familiaridade com os sistemas baseados em Linux, vamos detalhar passo a passo.

Obs: Se você quiser copiar o código aqui digitado, você pode digitar ctrl+c aqui e, no terminal, apenas clicar com o botão direito (esta ação será equivalente ao ctrl+v).

Antes de tudo, vamos dar um update para preparar o ambiente.
```
sudo apt-get update
```
Instalando o Apache 2

Para instalar o servidor do Apache, e verificar se a instalação está correta, simplesmente use os comandos abaixo, no Terminal:
```
sudo apt-get install apache2
sudo service apache2 start
sudo service apache2 status
```
Ao iniciar o apache, é possível que você receba a seguinte mensagem:

Windows TerminalProtocol not available: AH00076: Failed to enable APR_TCP_DEFER_ACCEPT

Não se preocupe com esse problema. Simplesmente esse protocolo ainda não está nativamente implementado no WSL. Você pode apenas ignorar ou adicionar as seguintes linhas no arquivo /etc/apache2/apache2.conf :
```
AcceptFilter https none
AcceptFilter http none
```
Instalando o PHP

Instalaremos o PHP 7.4 (então versão mais atual na última atualização deste post), mas você pode utilizar qualquer tutorial para Ubuntu para outras versões, ou simplesmente trocar os caminhos aqui associados. Atualizaremos este post conforme forem surgindo novas atualizações. Digite Y (yes) para tudo o que for perguntado.
```
sudo apt-get update
sudo apt-get install php php-cli php-fpm php-json php7.4-pdo php7.4-mysql php-zip php-gd  php-mbstring php-curl php-xml php-pear php-bcmath
php -v
```
Instlamos, assim, o cliente e os pacotes mais utilizados, mas você pode, futuramente, instalar pacotes adicionais para funções específicas. A terceira linha apenas verifica a versão do PHP instalada, para checar se está tudo correto.

Instalando o MySQL

Por último vamos instalar o MySQL. Você pode trabalhar com outros bancos de dados se quiser, basta, como dito anteriormente, usar qualquer tutorial para Ubuntu (ou a distro que você escolheu), pois, relembrando, o WSL é realmente um subsistema Linux instalado e integrado ao Windows. Ele não é uma máquina virtual ou emulação. Lembre-se de pressionar o Y, quando perguntado.
```
sudo apt-get install mysql-server mysql-client libmysqlclient-dev
sudo service mysql start
```
Caso perguntado, você pode ou não definir uma senha para o root do MySQL. Como você está em um ambiente de desenvolvimento, isso não é importante por hora. Mas lembre-se que em ambientes de produção uma senha forte deve ser usada.

Garantindo todos os privilégios para usuário administrador

Para você poder gerenciar todos os bancos e não ter que criar um usuário para cada um, você pode criar um usuário administrador e facilitar seu trabalho. Use o código abaixo para acessar o cliente mysql. Use a senha criada anteriormente.
```
sudo mysql -u root -p
```
Agora, use o código abaixo para criar o usuário administrador e você poder trabalhar de forma universal.
```
CREATE USER 'nome_de_usuario'@'localhost' IDENTIFIED BY 'sua_senha';
GRANT ALL PRIVILEGES ON *.* TO 'nome_de_usuario'@'localhost';
```
Digite \q para sair do cliente.

PHPMyAdmin

Você pode usar algum cliente externo para administrar o MySQL, mas a opção mais comum usada é instalar o PHPMyAdmin. Simplesmente utilize o seguinte comando:
```
sudo apt-get install phpmyadmin
```
Obs. A instalação irá perguntar se deseja instalar apache ou nginx, neste caso marque apache. Para marcar pressione espaço, se não fizer isso ele não instalará corretamente e você precisará rodar a instalação novamente.

Durante a instalação, você será questionado para criar uma senha para o PHPMyAdmin, caso deseje.

Testando

Uma vez que já instalamos e já inicializamos, podemos testar simplesmente acessando http://localhost. Para o PHPMyAdmin, use http://localhost/phpmyadmin

Para entrar no PHPMyAdmin, utilize o usuário e senha criado acima, com os privilégios:

Habilitando as configurações do Apache

Para poder funcionar corretamente certas opções, como o habilitar .htaccess, habilitar ou desabilitar determinados módulos, configurar max_*, etc., é ideal que você configure o Apache Virtual Hosts.
```
sudo bash -c "a2ensite '*.conf' && a2dissite 000-default.conf default-ssl.conf && systemctl restart apache2.service"
```
Feito isso, você pode configurar o VirtualHost para diversos sites, portas, ou simplesmente especificando configurações específicas para cada site / sistema em que você está trabalhando.

O arquivo de configuração gerado, fica em: /etc/apache2/sites-available/000-default.conf

Informações Importantes

Você pode iniciar o apache e o mysql a qualquer momento, simplesmente abrindo o Windows Terminal, no Ubuntu (ou direto pelo app Ubuntu) e colocando:
```
sudo service apache2 start
sudo service mysql start
```
A pasta padrão dos arquivos do Apache é:
/var/www/html

Para você abrir a pasta no Windows Explorer e você ver o os arquivos, digite no Terminal:
```
cd /var/www/html/
explorer.exe .
```
Recomendo que, para você poder operar sem problemas, no Windows, você execute, para dar permissão total:
```
sudo chmod -R 777 /var/www/html/
```
Extra: Criando um SSL autoassinado

Dependendo do que você estiver programando, pode ser necessário você utilizar uma conexão SSL. Isso geralmente é necessário em testes que irão alimentar diversas APIs ou até para utilizar alguns recursos do HTML5.

O Ubuntu já possui o openssl instalado nativamente no sistema. Então, basta você colocar:
```
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/apache-selfsigned.key -out /etc/ssl/certs/apache-selfsigned.crt
```
Enquanto você estiver criando o certificado, ele irá fazer algumas perguntas de identificação. Como é algo que vai ser usado localmente, essas informações não precisam ser reais ou fidedignas, basta responder. A ordem é:
- Nome de País (em código de 2 dígitos) – Brasil é BR
- Estado
- Cidade
- Nome da Organização
- Unidade da Organização
- Common Name – Digite localhost
- E-mail – Digite webmaster@localhost
Isso vai ser suficiente para criar um certificado auto-assinado, que vai funcionar localmente.

Agora vamos nas configurações do Virtual Hosts do Apache, para SSL.
```
sudo nano /etc/apache2/conf-available/ssl-params.conf
```
Dentro do arquivo, cole o seguinte texto (é uma configuração genérica, mas suficiente para nosso caso):
```
SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1
SSLHonorCipherOrder On
# Disable preloading HSTS for now.  You can use the commented out header line that includes
# the "preload" directive if you understand the implications.
# Header always set Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
Header always set X-Frame-Options DENY
Header always set X-Content-Type-Options nosniff
# Requires Apache >= 2.4
SSLCompression off
SSLUseStapling on
SSLStaplingCache "shmcb:logs/stapling-cache(150000)"
# Requires Apache >= 2.4.11
SSLSessionTickets Off
```
Obs. Digite CTRL+X, seguido de Y, seguido de ENTER, para fechar o nano, salvando.

Agora vamos editar a configuração do SSL.
```
sudo nano /etc/apache2/sites-available/default-ssl.conf
```
Com o arquivo aberto, você vai substituir os parâmetros abaixo, de acordo com o demonstrado na lista:
```
ServerAdmin webmaster@localhost.com
ServerName localhost

SSLCertificateFile /etc/ssl/certs/apache-selfsigned.crt
SSLCertificateKeyFile /etc/ssl/private/apache-selfsigned.key
```
Por fim, basta colocar no terminal, para ativar o ssl no Apache:
```
sudo a2enmod ssl
sudo a2enmod headers
sudo a2ensite default-ssl
sudo a2enconf ssl-params
sudo apache2ctl configtest
```
Se estiver tudo configurado corretamente, ele vai responder SINTAX OK.

Antes de recarregar o Apache, teremos que liberar a pasta onde salvamos o certificado. Vamos liberar para 777, para facilitar, apenas porque estamos em ambiente de desenvolvimento. JAMAIS FAÇA ISSO EM AMBIENTE DE PRODUÇÃO.
```
sudo chmod -R 777 /etc/ssl/private
service apache2 reload
```
Por fim, precisamos adicionar o SSL como confiável no Windows. Caso contrário, ao entrar em https://localhost, você vai receber aquela clássica tela de certificado não confiável.

Agora vá até a pasta onde você baixou o certificado e abra a pasta no explorer. Procure pelo arquivo do certificado apache-selfsigned.crt. Clique duas vezes nele para instalar no Windows.
```
cd /etc/ssl/certs/ 
explorer.exe .
```
Ao abrir o certificado, clique no botão Instalar Certificado

Simplesmente siga os passos para a instalação do certificado

Na área de Importação, selecione para colocar no repositório de Autoridades de Certificações Confiáveis, como nas imagens abaixo.

Você vai precisar confirmar a instalação do certificado. Marque Sim.

Agora é só acessar o localhost com https e ser feliz!
12 de outubro de 2019
Windows ganha Terminal – Uma opção ao PowerShell e CMD

Foi apresentado nesta segunda-feira (06/05), através do canal oficial Windows Developer, um novo terminal para o Windows 10. O objetivo é melhorar a produtividade em relação à soluções como Prompt de Comando, PowerShell e WSL (porém integrado entre estes).

O novo Windows Terminal poderá ser baixado e atualizado direto pela Microsoft Store, no Windows 10, não estando diretamente ligado ao Windows Update.

Vídeo de apresentação, que sugere um leiaute muito similar ao Windows Aero.

Similar aos terminais que vemos em Unix e Linux, o Windows Terminal trará suporte a múltiplas abas e podem ser integradas tanto aos comandos nativos do Windows como às soluções de subsistemas que já estão disponíveis na loja (WSL).

O Windows Terminal será acelerado por GPU a partir do sistema de renderização do DirectX, com um objetivo de criar uma qualidade na tipografia superior ao atual comportamento do ClearType. Com isso, também será possível incluir diferentes tipos de símbolos e glifos, tal como emojis; o que nos leva a crer que a Microsoft pretende mudar seu padrão de ISO para Unicode. Ainda, este terminal trará uma nova fonte, de código aberto.

O novo Windows Terminal quer entregar uma quantidade muito alta de personalizações e ferramentas, além de poder ser criado múltiplos perfis, para facilitar o uso. O mais interessante na verdade é que todo Windows Terminal está disponibilizado em código aberto no Github.
https://github.com/Microsoft/Terminal

A versão preview do Windows Terminal ficará disponível pela Windows Store durante o inverno brasileiro, deste ano. Sua versão 1.0 está programada para ser lançada no verão brasileiro, mas com possibilidades de ter seu lançamento adiantado.

Mais informações sobre ele, você pode encontrar no devblogs, da Microsoft:
https://devblogs.microsoft.com/commandline/introducing-windows-terminal/

6 de maio de 2019
Linus Torvald pede desculpas por falta de empatia, em carta (e-mail) aberta

No último Domingo (16/09/2018), Linus Torvald publicou, no LKML (Linux Kernel Mailing List) um e-mail cujo assunto estava incluso um “pedido de desculpas”. No e-mail, o criador do Linux afirma que o texto vai ser um pouco longo e que não é uma parte normal das discussões.

No e-mail, Linus busca explicar seu comportamento introspectivo, além de alguns desentendimento recentes, e afirma possuir um desejo honesto em melhorar, em um momento “olhe para você mesmo no espelho”.

“(…)

Esta é a minha realidade. Eu não sou o tipo de pessoa emocionalmente empática e provavelmente isso não é uma grande surpresa para ninguém. Ao menos pra mim. O fato que eu interpretei mal as pessoas e não percebi (por anos) o quão mal eu julguei uma situação e contribuí para um ambiente não profissional não é legal.

Esta semana, pessoas na nossa comunidade me confrontaram sobre minha vida de não entendimento de emoções. Meus ataques infantis em e-mails que foram tanto não profissionais quanto desnecessários. Especialmente as vezes que eu tornei isso pessoal. Na minha busca por melhorias, isso fazia sentido pra mim. Eu sei que isso não é OK e estou profundamente arrependido.

O que está acima é basicamente um jeito mais longo para chegar a uma dolorosa confirmação pessoal de que eu preciso mudar algumas coisas em meu comportamento, e quero me desculpar às pessoas cujo meu comportamento pessoal magoou e possivelmente as afastou totalmente do desenvolvimento do kernel.

Eu estou tirando um tempo para conseguir alguma ajuda em como entender as emoções das pessoas e as responder apropriadamente.

(…)”

— diz Linus em seu e-mail

Linus Torvald – photo by Alex Dawson

Linus ainda reforça que isso não é um pedido de aposentadoria, mas sim um aviso de que quer continuar trabalhando e melhorando nos pontos que ele considera que precisa. E deixa claro que está aberto a sugestões e mensagens.

Linus Torvald é um engenheiro de software, criador do projeto Linux e do Git. Conhecido mundialmente, ainda trabalha no desenvolvimento do kernel e é ativo na comunidade.

Você pode ler o e-mail na íntegra (em inglês) direto no site da LKML.

17 de setembro de 2018
Suse Linux é vendido para a EQT por US $ 2,5 bilhões

A empresa britânica de software Micro Focus International anunciou nesta segunda-feira que concordou em vender seu sistema operacional Linux SUSE para um fundo de private equity assessorado pela EQT Partners, da Suécia, por US $ 2,535 bilhões.

A Micro Focus disse que usaria parte dos recursos para reduzir a dívida e poderia devolver parte do restante aos acionistas.

A SUSE, pioneira em software de código aberto de nível corporativo, faz parte da Micro Focus desde 2014, quando a empresa britânica adquiriu o The Attachmate Group por US $ 2,35 bilhões.

É uma das mais antigas empresas de código aberto e talvez a primeira a fornecer serviços corporativos de Linux. Ela possui mais de 1400 funcionários em todo o mundo e a empresa fez uma venda de US $ 320 milhões em um mês que termina em outubro de 2017. Na época, a SUSE representava pouco mais de um quinto da receita do grupo Attachmate, segundo a Micro Focus.

O valor arrecadado de US $ 2.535 é 26,7 vezes o lucro operacional ajustado da unidade de software para os 12 meses até o final de outubro de 2017.

A SUSE está muito empolgada pela parceria feita com EQT . Mencionado em seu blog , o foco será expandir ainda mais o SUSE no campo de infraestrutura de TI.

“Esta é uma notícia empolgante para todos nós aqui na SUSE e marca o próximo passo em nossa trajetória de crescimento e dinâmica. O investimento e o suporte fornecidos pela EQT nos permitirão continuar impulsionando nossa estratégia de construção e compra de expansão tanto organicamente quanto por meio da aquisição de tecnologia..”

O CEO da SUSE Nils Brauckmann, promete que toda equipe da SUSE permanecerá unida e que liderará os negócios neste próximo capítulo mantendo-se claramente focado em sua missão: ajudar os clientes a transformar sua infraestrutura de TI para reduzir custos e competir de forma mais eficiente. reduzindo a complexidade e tornando-se mais ágil.

2 de julho de 2018
Projeto eelo: Um Novo Sistema Operacional Mobile Focado em Privacidade

Gaël Duval, conhecido por ser o criador do Mandrake Linux, está encabeçando o projeto de um novo sistema operacional para smartphones.

O Projeto eelo (se escreve em minúsculo) é um fork do LineageOS, variante famosa do Android com módulos de código aberto. A ideia é que o novo sistema operacional seja focado na privacidade e funcione como uma instituição sem fins lucrativos e comunitário, feito com o apoio de diversos desenvolvedores. A ideia é que as novas ROMs sejam disponibilizados em 2018 para diversos aparelhos e novos produtos sejam criados focados nesse sistema operacional já em 2019.

O eelo está sendo apoiado no Kickstarter e já passou dos 200% da meta em apenas 15 dias. Segundo Durval, a Apple tornou-se muito cara, muito chata e está “enlouquecendo com seus produtos”, enquanto o Google se tornou “gigantesca” e está capturando muitos dados dos seus usuários.

Um vídeo do projeto (legendado em português) foi disponibilizado no Youtube.

Gaël Duval acredita que o foco na privacidade e o compartilhamento em mídias sociais do projeto tornará o novo sistema operacional relevante para os consumidores e empresas. Segundo o analista da Gartner, Tuong Nguyen: “O Google gasta muito tempo e esforços para seus produtos serem fáceis de usar, para te manter dentro de seu ecossistema”.

Com notícias do Linux Insider e Kickstarter.

14 de janeiro de 2018
Sistemas Operacionais (parte 1 – história)
Quanto vale uma pedra de ouro se não houver uma utilidade para ela? Computadores são apenas pedaços de silício e plástico quando não possuem software para faze-los funcionar. Nos dias de hoje, o principal software para um computador é o Sistema Operacional. É chamado de Sistema Operacional o software, base, que faz o gerenciamento de recursos do hardware e define o modo como este se comunicará com as tarefas e processo de outros softwares.

Como tudo começou

No início, na época dos grandes mainframes, você precisava carregar o computador com toda a programação que iria utilizar. O primeiro sistema operacional realmente funcional foi o GM-NAA I/O, da General Motors, criado para funcionar no IBM 704. A ideia era automatizar diversas atividades sem ter que reenviar constantemente códigos bases para fazer uma determinada função, além de gerenciar melhor os recursos do equipamento. Com o tempo, diversas empresas desenvolveram sistemas operacionais para seus mainframes, algumas se especializaram na criação de sistemas para terceiros. O problema é que cada um apresentava características próprias e não possuíam nenhum tipo de comunicação entre si, criando a necessidade, aos poucos, de um padronização.

IBM 704

Em 1960, a IBM criou um sistema operacional chamado OS/360, para uma máquina chamada System/360. Várias versões do OS/360 foram desenvolvidos, conforme versões de sua máquina, algumas mais avançadas e outras menos eram lançadas. Algumas versões posteriores desse Sistema Operacional até receberam outros nomes e arquiteturas de terceiros. O fato é que a IBM não foi a única a lançar Sistemas Operacionais, outras instituições, principalmente universidades (ou em acordos com essas), começaram a fazer novos sistemas, como o SCOPE, MACE, NOS, dentre outros.

Sem dúvida, o mais famoso dos Sistemas Operacionais para mainframes, na época, foi EXEC, para o UNIVAC (UNIVersal Automatic Computer). Um computador que fez muito sucesso entre os anos 50 e 60, principalmente por serem considerados pequenos e mais baratos (chegando até a versões que tinham o tamanho de apenas algumas geladeiras). Dessa forma, esses computadores acabaram por ser mais acessíveis a universidades e pequenas empresas.

Univac 9400-1969

Todavia, a história do Sistema Operacional que utilizamos hoje, em microcomputadores, está ligada totalmente a história da computação pessoal, em especial, ao que foi considerado o primeiro PC: o Altair 8800.

Criado com uma das primeiras linhas de microprocessadores da Intel, o Altair 8800, era um microcomputador onde você precisava programar subindo e descendo chaves. Na prática, ele era um kit, e não realmente um computador, destinado a hobbystas. Porém, essa máquina era praticamente inútil, até que Bill Gates e Paul Allen resolveram pegar uma dessas máquinas e portar o BASIC (linguagem de programação) para essa máquina, criando o que seria conhecido como Microsoft-BASIC.

Os primeiros microcomputadores não rodavam realmente sistemas operacionais, mas algo bem próximo a esses, chamados de Interpretador. Eles rodavam comandos de programação, compilava e executava. Não demorou muito até que a ideia de Sistemas Operacionais, já usada em mainframes, chegassem aos microcomputadores. Afinal, carregar sempre um programa, sem sistema de arquivos, não era algo fácil, e os disquetes estavam começando a se tornar uma realidade.

Voltando um pouco no tempo, de volta a metade dos anos 60, houve um grande esforço de uma parceria entre o MIT, General Eletronics e da AT&T para a criação de um sistema operacional: o Multics. O problema é que até o final da década, o sistema não ficou pronto. Por conta de incertezas na busca pelo resultado e nos diferentes desejos de implementação de seus criadores, o Multics acabou sendo descontinuado. Porém, em 1969, Ken Thompson, um dos responsáveis pelo projeto, utilizou o seu conhecimento para uma versão menos ambiciosa, denominada então de Unics e, posteriormente, rebatizado como Unix.

Em 1973, o Unix foi reescrito em C (antes fora escrito em Assembly), pelo próprio Ken Thompson e por Dennis Ritchie (criador da linguagem C). Mais tarde, o Unix começou a ser usado como base para outros sistemas operacionais, principalmente seu o núcleo (kernel), criando assim uma série de derivados. Em especial, podemos destacar o Berkeley Software Distribution, ou BSD. Dessa série de derivados começou-se a criar a família de Sitemas Operacionais Unix ou ix, dos quais veio o POSIX, MINIX, FreeBSD, Solaris, dentre outros, mas ainda não foi agora que o Linux apareceu.

Terminal de Mainframe Rodando Unix

Os Sistemas Operacionais para PC

Voltando aos microcomputadores, logo após o Altair, diversos equipamentos começaram a surgir, com destaque ao Apple II. O Apple II possuía um interpretador BASIC, mas não apenas isso, foi criada, pela Apple o Apple DOS. O nome DOS veio do termo Disk Operating System (guardem bem esse nome), que teve outros derivados, da própria Apple, com o tempo. O fato é que o mercado da Maçã crescia mais e mais na área de computadores pessoais, e a IBM, grande detentora da venda de mainframes, resolveu criar um novo computador. Com uma oferta até então inédita para a companhia, eles criaram o PC-IBM, usando peças de terceiros para compor o computador. Porém, eles precisavam de um Sistema Operacional, e é aí que a história muda.

A IBM precisava de um sistema operacional para poder vender seu novo computador, porém não tinha tempo para fazer. Afinal, a Apple já estava em alta, e o mercado estava complicado. Dessa forma, a IBM precisava comprar um sistema operacional pronto, foi quando William Gates II fez uma recomendação para os advogados, e outros responsáveis pela IBM, sobre a empresa de seu filho, a Microsoft, já conhecida por portar o BASIC para o Altair e desenvolver alguns programas para Apple II.

Porém, a Microsoft não possuía sistema operacional, então Bill Gates (William Gates III), sócio fundador da Microsoft, ligou para a maior empresa de Sistemas Operacionais da época, a Digital Researchs, de Gary Kildall, desenvolvedora do CP/M. Infelizmente, a companhia não deu a atenção devida aos representantes da IBM, não finalizando nenhum acordo com a Big Blue (apelido da IBM). Então, a IBM voltou à Microsoft. Desta vez, Bill Gates não perdeu a oportunidade. Steve Ballmer, um dos três fundadores da Microsoft, soube de uma empresa que criou um sistema operacional simples, mas muito funcional. A Seattle Computers havia criado um sistema chamado QDOS, ou Quick and Dirty Operating System (Rápido e Sujo Sistema Operacional), baseado na tecnologia x86, dos processadores da Intel. Estima-se que esse sistema operacional tenha sido comprado por 40 mil dólares, porém isso é incerto, esse sistema foi adaptado e apresentado a IBM pela alcunha de MS-DOS (Microsoft Disk Operating System).

Fechando o acordo com a IBM, a única exigência da Microsoft era que os direitos de revenda do DOS pudesse ser dela. A IBM não se preocupou com isso, afinal, na época, cada Sistema Operacional era único para um computador, por questão de arquitetura. Algo que fez a IBM se arrepender, em 1982, por causa de uma empresa chamada Compaq e de uma coisa chamada engenharia reversa.

A Compaq contratou vários engenheiros (que afirmaram nunca ter trabalhado na IBM) que pegaram o computador da Big Blue e, ao ver como ele funcionava, perceberam que era uma amálgama de peças de outros fabricantes. Dessa forma, eles desenvolveram um computador Compaq PC, conhecido como IBM-PC Compatível. Dessa forma, todos os programas que pegavam no IBM-PC já funcionariam no novo computador da Compaq, incluindo o MS-DOS. Essa ideia fez surgir uma série de computadores compatíveis com IBM-PC, e muito mais baratos, criando um mercado forte e altamente competitivo, o que resultou na queda das vendas do Apple II.

MS-DOS

O início da Interface Gráfica

Em 1979, todo mundo esperava alguma novidade da Apple. A IBM estava ainda longe de lançar o PC-IBM, e Apple praticamente tinha um monopólio no mercado de computadores pessoais com seu Apple II. Na época, a Xerox possuía um ambiente focado em pesquisas chamado de PARC (Palo Alto Research Center). Em troca de poder comprar ações, a Xerox abriu suas instalações de pesquisas para a Apple. Steve Jobs, CEO da Apple na época, e outros executivos e engenheiros, foram até o PARC e lhes foram apresentados algumas tecnologias interessantes, como a Ethernet e a Linguagem Orientada a Objetos. Porém, o que realmente impressionou os visitantes foi uma versão bem arcaica de uma interface gráfica, com um dispositivo chamado Mouse, que estava ligado a um computador. Isso foi importante para poder criar o primeiro sistema operacional funcional com interface gráfica, o Lisa OS, para o Apple Lisa.

Com o avanço da IBM no mercado de computadores pessoais e, posteriormente de clones, a Apple precisava lançar algo novo no mercado. O IBM era mais barato e completo do que o Apple II. O Lisa estava ficando muito caro e a diretoria da Apple resolveu que estava na hora de Jobs procurar outro projeto. Passeando pelas instalações da Apple, ele encontrou um projeto destinado a computadores de baixo custo, o Macintosh. Rapidamente, Jobs afastou Jef Raskin (então criador da ideia) e assumiu o projeto Macintosh, mudando rapidamente seu conceito, porém querendo manter a parte de interação humano-máquina.

O Macintosh foi criado para ter um sistema operacional revolucionário, com interface gráfica, chamado de MacOS (hoje conhecido como MacOS Classic). Durante a produção do MacOS, diversos desenvolvedores foram chamados para criar programas para ele. Uma das empresas chamadas foi a Microsoft, que uso o acesso antecipado ao MacOS para criar não um sistema operacional ainda, mas uma GUI, Interface Gráfica do Utilizador.

Quando foi criado, o Windows ainda não era um Sistema Operacional, mas sim uma interface gráfica para o MS-DOS. O Windows só veio se tornar realmente um sistema operacional, com núcleo próprio, com a vinda do Windows NT. Quem tem mais idade vai lembrar que quando você ligava o computador ele iniciava no MS-DOS, sendo necessário digitar win, para usar o Windows.

No começo, o Macintosh foi um fracasso, que só veio se recuperar anos mais tarde com o advento do PostScript pela Adobe, mas essa já é uma outra história.

O fato é que pelo Macintosh ser muito caro, os PC-IBM e compatíveis começaram a ganhar mais e mais mercado, e, com isso, a Microsoft começou a ter uma liderança absoluta de mercado.

Apple Lisa

Surge o Linux

Em 1991, Linus Torvalds lançou a primeira versão de um núcleo de sistema operacional chamado de Linux. Diferente do que é divulgado por muitas pessoas, o Linux não é feito em cima do Unix. O Linux foi escrito do zero, inspirado pelo Minix (esse sim um sistema Unix). Torvalds dizia querer criar “um Minix melhor que o Minix”. Porém, este tinha o objetivo de ser simples, mas ainda sim, ser compatível com a grande maioria dos aplicativos para Unix.

Porém, a ideia de Linus Torvalds era divulgar e abrir o código para que diversas pessoas pudessem colaborar. Com ajuda de diversos outros programadores, a versão 0.02 do núcleo finalmente ficou pronta. Pouco depois, Linux Torvald colocou seu núcleo sobre a licença GNU (GNU Is Not Unix – é o que realmente quer dizer), que foi um sistema operacional, desenvolvido para ser compatível com o Unix, porém sem ter o código fonte do Unix.

O GNU era um projeto de sistema operacional sem núcleo e o Linux era um núcleo de sistema operacional sem bibliotecas e funções atreladas. Ao atribuir a licença GNU ao Linux, foi criado o GNU/Linux, sistema operacional base para diversas distribuições que surgiriam em seguida.

Em resumo, o Linux não é Unix, é um núcleo de sistema operacional, que, unido ao GNU, criou o GNU/Linux. Tanto o GNU quanto o Linux foi criado com o objetivo de ser mais simples que o Unix, porém com a compatibilidade para a maioria dos aplicativos Unix.

Linus Torvalds

Segundo a licença GNU, qualquer software que a utilize não pode ser fechado. Isto é, tudo deve ter o seu código aberto, disponível para editar o código e fazer o que quiser com ele. Porém Software livre não quer dizer software gratuito. É possível até vender o software, todavia o vendedor deve enviar o código fonte junto e não apenas o executável compilado.

Com o tempo e divulgação do GNU/Linux, diversas distribuições, baseados neste, foram sendo lançadas. Essas novas versões adicionavam sistemas de janelas, compatibilidade com outros sistemas de arquivos, bibliotecas para determinadas funções, pacotes exclusivos, etc. Essas distribuições eram criadas por terceiros, algumas por governos, outras por empresas que queriam algo mais personalizado para dar foco em uma determinada tarefa. Muitas dessas distribuições também foram criadas por grupos que tinham o interesse de criar sistemas cada vez melhores e mais completos.

As distribuições linux mais conhecidas hoje são:
- Mandriva
- Ubuntu
- CentOS
- Solus
- Arch Linux
- Fedora
- SUSE
Cada uma com um objetivo e conceito diferente. É muito comum, também, uma distribuição Linux se basear em outra. Por exemplo, o Ubuntu é baseado no Debian e o CentOS no Redhat. É importante que o usuário saiba em qual a distribuição que ele usa se baseou, pois alguns comandos podem mudar de uma distribuição para outra.

Sistemas Operacionais Desktop Contemporâneos

Hoje, os principais sistemas operacionais que usamos em desktops, servidores e laptops são o Windows, o MacOSX e as distribuições GNU/Linux (como o Ubuntu, Solus, Debian, etc.). Todos esses sistemas possuem versões específicas para usuário comum e para servidores.

Hoje em dia, todos os sistemas operacionais seguem uma mesma lógica de funcionalidades. Quanto a sua camada direta ao usuário, são formados por um sistema de janelas e um terminal para poder ter um acesso direto as funcionalidades técnicas.

As particularidades de cada um desses três sistemas, assim como seus sistemas de arquivos e versões, falaremos na parte 2 deste conteúdo.

Sistemas Operacionais para dispositivos móveis

Na segunda metade dos anos 2000, com o avanço das plataformas móveis, diversos sistemas operacionais com particularidades diferentes, específicos para esses equipamentos, foram criados. Eles precisavam ser mais leves e continham uma lógica de interação completamente diferente.

Nessa época foi quando surgiu o Symbian e o BB, da Nokia e Blackberry, respectivamente. Esses sistemas foram responsáveis pela popularização dos smartphones, trazendo acesso a aplicativos de produtividade e segurança, modernos, a usuários mais leigos. Claro, desde os anos 90 haviam sistemas operacionais para computadores de mão (PDA), como o palmOS e o NewtonOS, mas nem de longe conseguiram a popularização dos smartphones.

Hoje, o Symbian se tornou um sistema utilizado em alguns televisores, principalmente, e a BlackBerry não produz mais aparelhos com o BB10 (sua última versão). Porém a Google está em alta com o Android e a Apple com seu iOS. A Microsoft, que outrora sempre foi presente no mercado de palmtops (os computadores de mão), com seu Windows CE, está em último lugar nos sistemas operacionais para smartphones.

Falaremos das particularidades dos principais sistemas operacionais para smartphones (Android, iOS e Windows), na parte 2 deste conteúdo.

Outros Sistemas Operacionais

Praticamente tudo que tem um microchip, e rode aplicativos, hoje opera através de um sistema operacional. Existem sistemas operacionais em automóveis, em televisores, videogames, em relógios e outros vestíveis, etc. Temos sistemas operacionais dedicados até mesmo em comandar uma casa.

Porém, em nosso estudo, vamos nos dedicar aos principais sistemas operacionais para microcomputadores e dispositivos móveis, pois a maioria dos sistemas para outros gadgets são criados a partir desses. Além disso, todo o sistema operacional moderno utiliza alguns elementos que são padrões, o que facilitará a compreensão.

Concluindo

Nesta primeira parte vimos um pouco da história dos sistemas operacionais e algumas de suas definições. Essa história é importante para que conheçamos posteriormente os componentes dos sistemas operacionais e as peculiaridades disponíveis no mercado.

Este texto foi criado a partir das seguintes fontes:

Documentário The Code – A história do Linux
Documentários O Triufo dos Nerds, da ABC
Livro O Fascinante Império de Steve Jobs
Livro Computação Gráfica Teoria e Prática
Site oficial do Projeto GNU
Site oficial do Debian
30 de março de 2017
Rodando sua Primeira Aplicação C no Windows ou Linux
Sem dúvida uma das melhores linguagens para se começar a programar é C. Uma linguagem baixo nível, que dá para entender bem todos os conceitos de programação, tipos, etc. Uma linguagem procedural e que é utilizada até hoje em diversos softwares modernos, como o Photoshop, o OpenGL, o AutoCAD, dentre outros

Esta postagem é um complemento ao entendimento bem básico de C e programação.

C é uma linguagem de programação que precisa ser compilada, isto é, ela precisa ser transformada em um conjunto de códigos que a máquina interpretará para, então, criar um executável. Para fazer isso, a linguagem precisa de um compilador, que é um software que faz esse processado.

Obs. C é considerada uma linguagem auto-hospedada, pois com ela é possível criar o próprio compilador. Essa característica também é conhecida como linguagem completa.

Primeiramente, você vai precisar do seu código. Porém, antes de começar, precisamos passar por um pequeno glossário para que não haja confusões acerca de termos:
- I/O – Denomina-se I/O sistemas que fazem uso intensivo de entrada e saída de dados. I = input, O = output. Dentro da área de computação, a terminação I/O também é usada muito para expressar tecnologias novas de implementação.
- Editor de Texto – Na área de desenvolvimento é chamado de editor de texto qualquer programa onde você possa programar um código. Geralmente, editores de texto possuem auto-complete, que são dicas que ajudam a programar. Como exemplos temos o Notepad++, o Brackets, o Atom, etc.
- IDE – Ambiente de Desenvolvimento Integrado. Trata-se de uma ferramenta para desenvolvimento mais ampla do que um editor de texto. Além de inserir um contexto de projeto e não só de arquivos de texto editáveis, a IDE cuida da comunicação interna entre os elementos do código. Ou seja, é um ambiente completo para o desenvolvimento. Como exemplos temos o Eclipse, o JetBrains, o Visual Studio, o Coda, etc.
- Compilador – O compilador é um programa que transforma o seu código em algo que possa ser interpretado pela máquina. Os microcontroladores compreendem apenas bytecodes, ou outras linguagens de baixo nível indicadas em seus firmwares, de modo que se faz necessário converter o seu código para algo que a máquina entenda.
- Variável – Trata-se de um lugar que você reserva em sua memória para poder armazenar um dado, como um número, um caractere, etc.
- Função – É simplesmente um trecho de código com o propósito de executar um procedimento e, geralmente, retornar uma informação.
Outros termos poderemos ver em artigos futuros.

Para quem ainda está começando com programação, vamos deixar aqui abaixo um código, onde cada ponto de explicação está incluído como comentário.
```
#include <stdio.h>
// ^ Isto é uma diretiva. Ela serve para poder importar uma biblioteca externa
// (no caso, uma nativa do C conhecida como Standard I/O).
// As importações de bibliotecas devem ser a primeira coisa a ser declarada.
// O # simboliza que isso acontecerá antes de qualquer coisa ser executada pelo programa.

// Isto é um comentário. Você pode colocar duas barras
// no meio de um código e o compilador irá pular essa linha ou trecho
/* Você também pode usar /*, caso você queira
fazer um comentário com mais de uma linha.
Todavia, você precisa fechar com */

/**
 * Toda a aplicação em C deve ter uma função main() (principal).
 * Você deve ter reparado que este comentário está com uma cor diferente.
 * Convencionou-se que os comentários, antes de funções, devem ser feitos
 * com /** (Isso se chama Comentário de Cabeçalho). Isso indica a IDE que este
 * comentário descreve para quê serve
 * esta função. Isso acaba sendo incorporado a documentação do projeto
 * ou a dica de código mostrado por uma IDE. Você ainda pode usar
 * alguns parâmetros para indicar.
 * Colocar comentários, como este, não é obrigatório, mas faz parte de boas práticas,
 * pois você precisa lembrar o que esta função faz (e certamente, no futuro, você esquecerá),
 * ou indicar a um colega, como usar a função.
 * Por exemplo, esta função (também chamada de método), retorna um inteiro.
 * Logo, eu posso digitar:
 * RETURN :
 *            Type:   int   Resulta zero
 * Isso indicará a IDE e a documentação que a função retornará um inteiro.
 * Essa indicação de comentário de cabeçalho pode variar entre IDEs e linguagens.
 * */
int main() //A primeira palavra indica o que a função retorna, ou seja, a função,
// deve retornar um inteiro. Em seguida, coloca-se o nome da função, seguido de ().
{//Inicia a função (também conhecido como begin)

    int aInt = calcular(88,32); // uma variável do tipo inteiro
                                //(o nome aInt fui eu quem dei), que vai ser preenchido com o
                                //retorno da função calcular (veja abaixo)
    
    char str[15]; //uma variável do tipo caractere que eu chamei de str.
                  //O [15] significa que ela poderá ter até 15 caracteres.
                  //Vocês ainda vão entender o conceito de vetores.
    
    sprintf (str, "%d", aInt); //sprintf é uma função nativa do C que serve
                               //para transformar inteiros em caracteres,
                               //pois só posso imprimir caracteres no console (ou no dispositivo de saída).
    
    str[15] = strcat(str,"\n");//strcat é uma função nativa do C que serve para concatenar.
                               //Ou seja, juntar uma String (conjunto de caracteres) com outra.
                               //A String (que significa amarra em tradução livre, ou seja, uma amarra de caracteres)
                               //"\n" é um modo de dizer ao compilador que ele deve colocar uma quebra de linha
                               // Usar \n é algo padronizado como quebra de linha em qualquer tipo de texto plano.
                               // Lembrando que quebra de linha seria o equivalente a dar um CTRL+ENTER, em um texto comum.
    printf(str); //printf é uma função nativa do C que serve para mostrar (imprimir)
                 //algo no dispositivo de saída, no caso, no console abaixo.

    return 0; //O retorno da função.
              //Como a função diz que retorna um inteiro (lá no começo da função),
              //ela DEVE retornar um inteiro.
              //Caso você não retorne o inteiro, ela NÃO irá compilar, pois você prometeu que ela retornaria isso.
}//Finaliza a função (também conhecido como end)

/**
 * Você vai notar que esta função que eu criei, tem uma peculiaridade.
 * Repare que dentro dos parênteses há duas variáveis inteiras.
 * Essas variáveis se chamam parâmetros. Elas servem para que a função possa ser reaproveitada
 * a partir de outros termos que serão chamados acima.
 * Repare, em main(), que eu chamo calcular(88,32), mas você pode mudar para qualquer outro número inteiro.
 * O que o método (ou função), fará é calcular os dois valores que você colocar nos parâmetros.
 * No caso de C, se você não colocar os dois valores, ao chamar a função, o compilador falhará.
 * 
 * * INPUTS :
 *       PARAMETERS:
 *           int     valor                Primeiro somando
 *           int     valor2               Segundo somando
 */
int calcular(int valor, int valor2)
{
    int total = valor + valor2; //uma variável inteiro, chamada total, que retorna a soma dos parâmetros valor e valor 2;
    return total; //O retorno do método será um inteiro (como foi descrito no começo do mesmo).
    //Em main(), você pode ver que o retorno deste método retorna uma variável. 
}
```
Você pode simplesmente copiar e colar o código acima em um editor de texto qualquer (como os citados acima). Você pode usar até mesmo o bloco de notas do Windows, ou o Gedit, no Linux. Em, seguida, salve o arquivo com o nome que você quiser, porém, com a extensão .c, por exemplo: meucodigo.c.

Compilando C, no Windows

Para poder compilar em C, no Windows, usaremos uma ferramenta de código aberto chamada MinGW (caso deseje testar, pode usar a versão 64 bits do MinGW, porém a versão 32 é compatível com ambos os sistemas). Ao instalar você pode escolher algumas especificações e se quer ou não que ela opere em modo visual (em janela), além da integração com o Explorer.

Uma vez instalado o MinGW, você precisará selecionar o mingw32-base e mingw32-gcc-g++, pois ele é o compilador C / C++ para podermos trabalhar. Depois disso, basta ir no menu Installation e clicar em Apply Changes e, em seguida, no botão Apply. Ele irá instalar todos os arquivos do compilador que serão necessários para nosso teste.

Após concluída a instalação, já podemos usar o compilador.

Para poder compilar o seu arquivo, simplesmente abra o prompt de comando (cmd.exe), do Windows e vá na pasta do MinGW, localizada geralmente em C:\ (ou onde você preferiu instalar). Na dúvida basta digitar o código abaixo:
```
cd C:\MinGW\bin
```
Em seguida, vamos chamar o compilador e o arquivo que queremos que ele compile. Para isso, basta digitar o nome do compilador, o arquivo a ser compilado, o parâmetro do comando, e o nome final do programa.

No caso, teremos:

gcc meucodigo.c -o meuprograma.exe

Onde gcc é o processo (o compilador), meucodigo.c é o código fonte, o parâmetro -o significa que eu estou indicando qual é a saída e o meuprograma.exe indica o nome final do programa compilado.

No meu caso, como criei meu código fonte e o salvei dentro de Documentos, eu coloquei:
```
gcc C:\Users\rodri\Documents\meucodigo.c -o C:\Users\rodri\Documents\meuprograma.exe
```
Como é um pouco chato lembrar e até digitar todo o caminho, uma dica é arrastar o arquivo para dentro do prompt de comando, isso fará com que ele cole o caminho do arquivo.

Devido a quantidade enorme de comentários e observações no código, é bem provável que ele retorne alguns Warnings (alertas), ao compilar, mas não dará erro. Você poderá testar o resultado do seu programa simplesmente digitando o nome do executável no prompt de comando.

Compilando C, no Linux

Para compilar C, no Linux, é ainda mais simples do que no Windows. Dependendo da distribuição do Linux que você utilizar é possível até que já haja um compilador instalado. Vamos utilizar, no exemplo, a compilação de C em uma distribuição Debian, como o Ubuntu ou CentOS, por se tratar de distribuições muito usadas.

Abra o terminal do Linux e digite:
```
sudo apt-get update
```
Para quem é novo no Linux, o sudo é um comando que afirma que você vai executar como super usuário, ou seja, com acesso completo ao sistema operacional, e, por isso, ele deverá te pedir a senha. Já o apt-get update serve para atualizar o repositório (fonte de sistemas), de sua distribuição Linux.

Em seguida, basta digitar o comando:
```
sudo apt-get install build-essential
```
Esse comando serve para pedir para que seja instalado os elementos principais para compilação de diversas linguagens usadas pelo Linux, inclusive C, assim como todas os seus pacotes de dependências (bibliotecas necessárias para o funcionamento).

Agora vá até a pasta onde você salvou o arquivo do código, no meu caso está em /mnt/c/Users/rodri/Documents/.

Para compilar basta colocarmos:
```
gcc meucodigo.c -o meuprograma.out
```
Onde gcc é o processo (o compilador), meucodigo.c é o código fonte, o parâmetro -o significa que eu estou indicando qual é a saída e o meuprograma.exe indica o nome final do programa compilado.

Já para executarmos o programa, dentro do terminal, digitaremos:
```
./meuprograma.out
```
… e voilà

Concluindo

C é uma linguagem muito boa para quem está começando a programar ou está ainda entrando no mundo da tecnologia. Compilar por linha de comando te ajuda a ter uma base ainda melhor para compreender como funciona a compilação de uma linguagem e te dá mais liberdade para usar qualquer compilador, IDE ou editor de texto que você prefira e se adapte.

Para dar o exemplo no Ubuntu foi usado o Bash do Ubuntu disponível para Windows 10, todavia vai funcionar sem problemas em qualquer distribuição Linux, baseada em Debian, seja em máquina virtual ou em instalação normal. Se você quer saber como instalar o Bash do Ubuntu no Windows 10, acesse nosso artigo a respeito.
20 de março de 2017
Como instalar nativamente o Bash do GNU/Linux no Windows?

Uma das melhores características do GNU/Linux é seu terminal. Ele permite de forma simples e rápida executar e configurar ações e servidores que agilizam e permitem o uso e desenvolvimento de aplicações web e serviços. Apesar de possuir o PowerShell, o programador pode querer usar soluções Linux em seus testes e ambiente de desenvolvimento.

Pensando nisso, a Microsoft implementou uma forma de trazer o bash de algumas distribuições como subsistemas para o Windows. Basicamente isso significa que você pode ter uma distribuição GNU/Linux instalada em seu sistema operacional de forma integrada. Ou seja, funcionando como um sistema nativo e não em uma máquina virtual, economizando assim recursos da máquina e mantendo um acesso mais rápido.

ATUALIZADO

Nas versões atuais do Windows 10, a instalação do bash GNU/Linux é muito mais simplificada.

Basta primeiro você ir em iniciar e buscar por Ativar ou Desativar Recursos do Windows.

Ao abrir, procure e marque a opção Subsistema do Windows para Linux. Você vai precisar reiniciar o computador logo em seguida.

Após reiniciado, abra a Windows Store e na busca digite Linux. Você encontrará várias opções de subsistemas que você pode instalar em seu computador. Selecione o que você quiser e instale.

Dica: Caso você procure por uma versão específica, na busca da Windows Store digite o nome da distribuição de seu interesse.

Após instalar da loja, você vai notar que há um novo aplicativo no seu menu iniciar, referente a distribuição que você instalou. Ou você pode iniciar seu prompt de comando e digitar bash.

Assim que você abrir o aplicativo, ele irá avisar que vai baixar o sistema operacional escolhido. Em seguida, você deve definir o login e senha de administrador.

E, pronto! Você já pode usar o susbsistema GNU/Linux em seu Windows.

Dica: caso você entre pelo BASH e queira entrar dentro do drive C:/ do Windows, digite “cd /mnt/c” (sem aspas) e você será encaminhado para o drive C:/.

A partir de Outubro de 2017, se você atualizar para a versão Falls Creators Update, não é mais necessário ativar o modo de desenvolvedor para usar o Ubuntu no Windows. Agora, caso você esteja com o Windows atualizado, basta abrir a loja da Microsoft e adquirir gratuitamente o Bash do Ubuntu. Clique aqui para poder acessar a loja diretamente ou clique na imagem.Caso você não tenha essa atualização, continue o tutorial abaixo.

Após instalado, sempre que quiser usar o terminal do Linux, simplesmente vá no menu iniciar e digite “bash”, dessa forma, ele já abrirá no terminal nativo. Particularmente, eu prefiro abrir o prompt de comando e digitar “bash” (sem aspas) e ele iniciará o Ubuntu já dentro da pasta atual do Windows (no caso, Usersnome_usuario. O Ubuntu fica ligado nativamnete no Windows, não se trata de uma máquina virtual, então todos os recursos são compartilhados e o acesso é direto.

Dica: caso você entre pelo BASH e queira entrar dentro do drive C:/ do Windows, digite “cd /mnt/c” (sem aspas) e você será encaminhado para o drive C:/.

Usuários da versão Estável do Windows

Desde sua última atualização, em 2016, o Ubuntu pode ser instalado nativamente dentro do Windows 10 e trabalhado através de seu bash. Para que isso acontecesse, a Canonical e a Microsoft fizeram um acordo que gerou até certas piadinhas, sobre o quanto ele é aprofundado. O fato é que utilizar o bash do Ubuntu dentro do Windows ajuda muito desenvolvedores a realizarem certas atividades que antes necessitavam de programas de terceiros, como acesso SSH, SCP, funções como wget e apt-get, dentre outras. Este tutorial tem por objetivo ajudar aqueles que desejam usar o Linux profissionalmente, dentro do Windows, ou apenas experimentar o sistema do pinguim.

A primeira coisa que deve ser feita é colocar o Windows em modo desenvolvedor. Não se preocupe se você usa o Windows 10 Home, que ele também possui essa opção. Abra as Configurações do Sistema ou simplesmente digite “desenvolvedor”, na barra de buscas. Será necessário reiniciar o computador, após colocá-lo em Modo de Desenvolvedor.

Uma vez com o modo de desenvolvedor aberto, vá até o menu iniciar e digite “Ativar ou Desativar Recursos do Windows”. Você também poderá acessar essa tela a partir do Painel de Controles convencional (aquele que existe desde o Windows 98) e ir em Adicionar ou Remover Programas. A opção de recursos do Windows, será a primeira.

Procure pelo recurso: “Subsistema do Windows para Linux (Beta)”, marque, dê OK e aguarde ele fazer o download, algumas atualizações ativar o recurso.

Agora basta você abrir o prompt de comando do Windows 10. Assim que o prompt abrir digite: “bash” (sem aspas), e ele iniciará o Download do Ubuntu (até então o 14, mas podem ter atualizado). É possível que ele peça para você confirmar algumas coisas (com sim ou yes), confirme tudo o que for necessário. O download poderá demorar um pouco, pois se trata de uma instalação completa do sistema, então tenha paciência ou uma boa conexão de internet.

17 de março de 2017