Diolinux - O modo Linux e Open Source de ver o Mundo

Responsive Ad Slot

Mostrando postagens com marcador shell. Mostrar todas as postagens
Mostrando postagens com marcador shell. Mostrar todas as postagens

GTK 4 recebe melhor compatibilidade com Vulkan

Nenhum comentário

terça-feira, 8 de outubro de 2019

O GTK é um toolkit multiplataforma para criação de interfaces gráficas. Caso você utilize a versão principal do Ubuntu, ou distros como Fedora, Linux Mint, Elementary OS, Endless OS e Pop1_OS em suas principais versões. É o GTK que compõe as interfaces gráficas destes sistemas. Ao contrário do que muitos pensam, apps para outras plataformas, por exemplo, o Windows, podem ser escritos em GTK. Atualmente a versão suportada na maioria dos sistemas é o GTK 3.

gtk4-vulcan-mutter-gnome-apps-linux-open-source-software-livre-api-graphics-opengl

Quando o assunto é GTK, lançamentos frequentes não são comuns, e sempre existe aquela velha rixa com o Qt. Esse também utilizado para desenhar interfaces gráficas. Deepin e KDE são ótimos exemplos. Não quero entrar no mérito de quem é melhor ou pior, o mais importante é que os softwares construídos com essas tecnologias cumpram seus objetivos. 

No início do ano escrevi uma postagem sobre o GTK 4, e que seu lançamento pode estar cada vez mais próximo. Caso queira ver algumas das mudanças do atual GTK 3 para o GTK 4, acesse a postagem mencionada acima e veja as vantagens dessa nova versão.

Aprimorado o uso do Vulkan no GTK4


Se você é do meio gamer, já deve conhecer o Vulkan. Essa API gráfica vem demonstrando melhoras significativas na performance dos jogos no Linux, e até mesmo no Windows. Atualmente o GTK 4 além de suportar o OpenGL, também suporta Vulkan.

Fazendo o uso de uma API como o Vulkan ou OpenGL, as aplicações podem ter melhor performance. Pois, podem aliviar o uso das GPUs ao processar gráficos. Utilizar uma GPU dedicada para trabalhar, dá maior autonomia ao processador. Afinal, ao invés de se preocupar com tarefas gráficas, o mesmo pode focar em processos mais importantes.

Quando você abre uma aplicação em seu sistema, uma quantidade assombrosa de pixels desenham em tela tudo que você está vendo. Para fins comparativos, um monitor full hd tem 2 milhões de pixels em tela. Obviamente que as GPUs modernas podem dar conta dessa quantidade de informação, entretanto cada vez que um simples detalhe é modificado durante o uso da aplicação, por exemplo, clicar em um pequeno botão, é necessário redesenhar tudo novamente.

Imagine esse processo sendo feito a cada momento, o tempo todo em que você faz uso de algo no sistema. Para contornar isso, os compositores de janelas usam uma técnica inteligentíssima: apenas redesenhar a parte que realmente teve algum detalhe modificado.

Assim o GTK rastreia quais partes da janela mudou, envia essas informações ao compositor de janelas, para que o próprio compositor possa redesenhar apenas o novo conteúdo. Ao utilizar o EGL (uma interface entre as APIs de renderização, OpenGL, OpenGL ES ou OpenVG), tudo já era bem otimizado, contudo com o Vulkan problemas ocorriam.

gtk4-vulcan-mutter-gnome-apps-linux-open-source-software-livre-api-graphics-opengl

Você pode perceber na imagem acima que o resultado não foi o dos melhores. Georges Stavracas, desenvolvedor do Gnome, após efetuar muitas pesquisas e testes conseguiu solucionar o problema. Para quem desconhece, Georges é um desenvolvedor brasileiro e vem desempenhando um trabalho primoroso no GNOME. Graças a ele, a função de arrastar e soltar os ícones para agrupá-los no menu do GNOME Shell tornou-se realidade (sem o uso de extensões de terceiros).

A descoberta do problema foi durante o desenvolvimento do GNOME To Do, programa que o brasileiro vem mantendo, e pasmem os senhores, já faz uso do GTK 4. Por padrão o renderizador do Vulkan no GTK 4 sempre envia toda janela para o compositor. A GPU é a encarregada por todo processo, mas não deixa de ser uma solução deselegante. Todavia através de uma função do Vulkan, “VK_KHR_incremental_present”, a renderização pode ser otimizada e apenas os detalhes que forem novos serão redesenhados na janela.

gtk4-vulcan-mutter-gnome-apps-linux-open-source-software-livre-api-graphics-opengl

Tudo indica que o GTK 4 de fato está bem próximo, com melhor desempenho e fazendo uso de tecnologias, como o Vulkan, a tecnologia promete dar um salto em comparação ao GTK 2 e GTK 3. Somando o Wayland na equação, e quem sabe sua compatibilidade com drivers proprietários NVIDIA (tendo em vista que os drivers abertos da AMD já possuem um desempenho bem interessante com o Wayland) a performance seja ainda superior. Claro, que a compatibilidade dos drivers proprietários da NVIDIA não é de responsabilidade da comunidade. Afinal, como implementar algo sem a ciência de seu real funcionamento? Engenharia reversa é algo extremamente complexo e seria bem mais simples a NVIDIA cooperar com o projeto.

Ansioso para o GTK 4? Sei que muitos estão torcendo para que ele dê um up na performance de aplicações e do GNOME Shell. Será que em 2020 veremos o GTK 4, enfim, sendo utilizado em larga escala?

Participe de nosso fórum Diolinux Plus. Assim você sempre fica por dentro das novidades.

Até o próximo post, te espero aqui no blog Diolinux, SISTEMATICAMENTE! 😎

_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


Como importar as configurações e temas do OhMyZsh para o usuário “root”

Nenhum comentário

terça-feira, 24 de setembro de 2019

Os usuários de computadores e tecnologia em geral podem ser divididos em dois grupos. Aqueles que gostam das coisas apenas funcionais, sem se importar com a estética. E aqueles (como eu), que além das coisas funcionais também gostam delas “bonitinhas”. Sim, gostamos de uma boa “perfumaria”. 😃

como-importar-as-configuracoes-e-temas-do-ohmyzsh-para-o-usuario-root

O artigo de hoje é um complemento à outro artigo, que você pode encontrar aqui. E também aos dois vídeos abaixo. Caso você não saiba o que é “ZSH” ou “OhMyZsh”, é essencial que, para o completo entendimento deste artigo, você assista a estes dois vídeos.



Bom, agora que você já sabe do que se trata, vamos ao assunto.

No artigo, e nos vídeos citados acima, vocês aprenderam a como instalar o ZSH e utilizá-lo como o shell padrão, no lugar do bash. Também aprenderam à customizar a aparência do ZSH através do OhMyZsh, podendo escolher entre muitos temas para deixar o terminal com “a sua cara”.

Porém, um pequeno detalhe não foi abordado nos posts anteriores: como fazer com que as configurações e temas do OhMyZsh também sejam aplicadas quando utilizamos o terminal em modo “root”.

Após ter instalado ambos, ZSH e OhMyZsh, e configurado o tema desejado (no meu caso, o tema Agnoster), conforme explicado nos posts linkados acima. Você terá o seu terminal com uma aparência semelhante a imagem abaixo:

ohmyzsh-com-tema-agnoster-antes-do-procedimento

Porém, como você pode ver na imagem, ao entrar em modo “root”, as configurações não se mantém e voltam ao padrão do ZSH.

O quê vamos fazer agora é configurar para que todas as configurações referentes ao OhMyZsh, sejam aplicadas também ao usuário “root”.

Como realizar o procedimento?


O tutorial abaixo será dividido em duas partes, cada uma com um método diferente para a realização do mesmo procedimento. Independente de qual método você escolha, o resultado será o mesmo.

O primeiro método (1), é mais indicado para quem prefere executar o procedimento via interface gráfica, através de um script que fará todo o passo a passo de forma automática. E o segundo (2), para quem quiser fazer manualmente, através do próprio terminal.

1) Executando o procedimento via interface gráfica.


Faça o download do script clicando aqui. Para acessar a página do repositório no Github, clique aqui.

Nas preferências do seu gerenciador de arquivos, na aba “Comportamento”, na seção “Arquivos de texto executáveis”, selecione a opção “Perguntar o que fazer”. Isso permitirá que você execute o script sem a necessidade de abrir o terminal.

Obs.: Todos os gerenciadores de arquivos mais populares possuem esta opção. Porém, ela pode estar em outro lugar, ou possuir um nome um pouco diferente, caso você esteja utilizando um outro gerenciador de arquivos que não o “Nautilus”.

preferencias-do-nautilus

Clique com o botão direito do mouse sobre o script que você baixou, vá em “Propriedades”. Na aba “Permissões” marque a caixa de seleção “Permitir a execução do arquivo como um programa”.

propriedades-do-script-zshroot.sh

Agora dê dois cliques sobre o script, clique em “Executar no terminal”, digite a sua senha e pressione “Enter”.

executando-script-duplo-clique

• Após poucos segundos será exibida a mensagem “Operação concluída.”. 

script-finalizado

Pronto! Agora é só abrir o seu terminal e ver como ficou.

2) Executando o procedimento manualmente, via terminal.


Execute os comandos abaixo na seguinte ordem:

Copie o arquivo “.zshrc” para o diretório “/root”.

sudo cp /home/$USER/.zshrc /root

Copie a pasta “.oh-my-zsh” para o diretório “/root”:

sudo cp -r /home/$USER/.oh-my-zsh /root

Edite o arquivo “.zshrc” que está no diretório “/root”:

sudo nano /root/.zshrc

Cole a linha abaixo dentro do arquivo “.zshrc”, de forma que fique igual a imagem abaixo:

export ZSH="/root/.oh-my-zsh"


• Pressione “Control + O” seguido de “Enter” para salvar, e em seguida “Control + X” para fechar o editor de texto.

Reinicie o terminal, e pronto!

O quê você acha dessas “perfumarias”? Você, assim como eu, pensa que o aspecto visual é sim muito importante, ou acredita que o importante é apenas ser funcional? Diga-nos a sua opinião nos comentários.

Você gosta de Linux e tecnologia? Tem alguma dúvida ou problema que não consegue resolver? Venha fazer parte da nossa comunidade no Diolinux Plus

Por hoje é tudo pessoal! 😉

_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


Curso EXTREMAMENTE AVANÇADO de Shell Script!

Nenhum comentário

segunda-feira, 24 de junho de 2019

Agora que você já perdeu o medo do terminal Linux chegou a hora de dar um passo a mais e usar todo o potencial que ele te oferece como uma ferramenta para controle, automação e até diversão, por que não?

Cursos avançado de Shell Script







O meu amigo Marcos, do canal Terminal Root, vem desenvolvendo há muito tempo um material extenso e completo sobre o uso de aplicações em modo texto, terminal e shell script e hoje eu tenho o prazer de anunciar a disponibilidade deste material!

O que você vai aprender se fizer o curso?


Absolutamente tudo sobre manuais, processos, animações em ASCII e Unicode. Vai aprender inúmeros comandos de manipulação de dados do Terminfo e Termcap. Também vai descobrir todo raciocínio e lógica utilizada para criação de games, utilizando a raíz da criação. 

Aprenderá a criar um instalador pra o Arch Linux, bem como manipulação de Sistema de Arquivos via linha de comando. Entre diversos outros tópicos para criar programas profissionais e com recursos UX e UI deixando-os mais intuitivos.

No vídeo à seguir o Marcos te mostra a aplicação prática do Script de instalação do Arch.



São 22 vídeos, mais de 2GB de conteúdo que você pode baixar e guardar com você para sempre, 18 apostilas em PDF, 18 Scripts didáticos e ainda vários arquivos, imagens e outros, tudo isso para te ajudar a estudar e virar um ninja especialista no terminal.

Quanto custa?


O curso possui o valor de investimento de R$ 174,90, porém, um requisito importantíssimo é já ter conhecimento básico ao menos em Shell Script, para que assim você possa desenvolver as habilidades propostas no curso de forma mais rápida.

Caso você não satisfaça esse pré-requisito, o Marcos também preparou alguns cursos que vão te dar toda a base necessária para ir para o curso extremamente avançado.

1 - Curso do Iniciante ao Avançado de Shell Script - Onde você aprenderá o essencial, além de manipular banco de dados e usar Shell Script para Web.

Valor: R$ 39,90.
Mais detalhes em: terminalroot.com.br/bash

2 - Curso do Editor Vim - Você aprenderá a customizar o Vim, podendo por exemplo mapear qualquer tecla para responder como deseja.

Valor: R$ 29,90
Mais detalhes em: terminalroot.com.br/vim

3 - Curso Extremamente Avançado em Shell Script Bash - Para criação de animações, instaladores de distros, games e muito mais, como já comentado neste artigo:

Valor: R$ 174,90
Mais informações em: terminalroot.com.br/shell

PORÉM, como aqui não brinca quando o assunto é promoção, agora, em uma parceria entre o Diolinux e o Terminal Root, você pode levar todos os 3 cursos por apenas R$ 179,90!

Um bônus: Além destes cursos mencionados, você também receberá o curso de SED - Editor de fluxo completo.

Como você pode comprar?


Na verdade, de forma muito simples. Todo o material dos cursos será enviado para você por e-mail, então basta fazer a compra aqui.

Depois disso é só aguardar o recebimento do material, se tiver alguma dúvida, entre em contato diretamente com o Marcos em terminalroot.com.br.

Fique ligado no blog e o no canal Diolinux, pois provavelmente sortearemos alguns cursos completos para nossos leitores e inscritos em breve!

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


5 Dicas PRO para Shell Script

Nenhum comentário

segunda-feira, 1 de abril de 2019

Dizem que depois que você aprende o Terminal é que você realmente começa a entender Linux profundamente. Seja isso uma verdade ou não, de fato, é verdade que dominar o terminal te dá algumas vantagens em relação ao que você pode fazer com o seu sistema. Hoje você vai conferir 5 dias para quem quer ser um PRO no Shell Script.







1 - Portabilidade dos seus Shell Script



Muitas vezes indicamos automaticamente o caminho da Shebang como #!/bin/bash, no entanto, se o Bash estiver instalado num diretório diferente (como em sistemas como FreeBSD, OpenBSD e algumas distros Linux) provavelmente ela não conseguirá encontrar o interpretador e seu programa/script não funcionará.

Logo, a melhor maneira de você evitar esse tipo de problema é indicar o caminho da env que é padrão em todos os sistemas e a mesma se encarrega de redirecionar pro caminho onde o interpretador está localizado. Então, procure sempre iniciar seus programas/scripts com o seguinte caminho após a Shebang:

#!/usr/bin/env bash

O mesmo vale para outros Shells: ZSH, FISH, etc.

2 - Procure sempre pôr cabeçalho nos seus scripts


Os cabeçalhos são importantes para que a pessoa saiba pra que serve seu programa/script, como lhe contactar em caso de algum problema, qual a forma de utilização e entre diversos outros pontos positivos.

Geralmente num cabeçalho deve haver o "help", "changelog", "TODO", "FIXME",... ou seja, diversas informações necessárias. No entanto, em resumo, algumas informações são fundamentais, tais como: Descrição do script; Autor; Versão e Licença. Veja abaixo um exemplo mínimo e básico de um cabeçalho:

# autor: Nome Sobrenome <site.dominio>
# descrição: O que seu Script/Programa faz 
# version: 1.0
# licença: MIT License

O exemplo acima está em Português, mas é interessante deixá-lo em Inglês, para ficar ainda mais global.

3 - Separe por função


O motivo inicial da Linguagem Orientada à Objetos é a organização. No entanto, linguagens procedurais ou estruturais podem manter a organização separando cada "transformação" em funções . Em Shell Script, você pode declarar uma função em duas formas de sintax, veja abaixo ambas as formas:

USANDO a palavra function
function minha_funcao(){
echo "Minha função"
}
Ou SEM USAR a palavra function
minha_funcao(){
echo "Minha função"
}
Para chamar a função, basta invocar o nome da função no script, ex.: minha_funcao

4 - Deixe seu código com indentação


No Shell Script, como na maioria das linguagens de programação, a indentação não é obrigatória, no entanto, ela é interessante para deixar seu código mais organizado, então procure sempre manter seu código indentado.

Uma dica legal é se você usar o editor Vim , basta você selecionar tudo pressionando a tecla ESC e em seguinda combinando as teclas ggVG , após tudo selecionado, basta agora teclar duas vezes o sinal de igual == e seu código será automáticamente indentado. Mágica! :)

5 - Declare nomes descritivos


Quando criar nomes de variáveis e de funções, procure descrever (não tanto, lógico) e separando com underline **_** , pois ficará mais profissional e menos provável de haver conflito de nomes e situações desagradáveis, alguns exemplos de como descrever: set_name, get_name, display_info_start, etc.
  
Se você ainda não domina Shell Script e o Terminal Linux. Aproveite uma promoção onde você pode adquirir 5 CURSO DO TERMINAL LINUX incluindo Shell Script, Expressões Regulares, Vim e Sed. Clicando nesse link http://bit.ly/Promo5pg para adquirir com o PagSeguro ou nesse link http://bit.ly/5CursosLinux para adquirir com o PayPal. Se quiser mais detalhes da promoção veja essa postagem: 5 Cursos do Terminal Linux para você! .

Esse artigo foi escrito em parceria com a galera do Terminal Root, os quais são os autores dos cursos mencionados acima, até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


Como extrair informações de um vídeo do YouTube usando Shell Script

Nenhum comentário

sábado, 8 de setembro de 2018

O Shell Script pode ser utilizado em lugares muito diferentes e pode servir para automatizar qualquer tarefa que você poderia fazer passo a passo usando a sua distro Linux, hoje vamos aprender a extrair alguns dados do seu canal favorito do YouTube.

Shell Script no YouTube













Para aqueles que são Produtores de Conteúdo com Linux e vivem querendo saber a repercussão do vídeo que acabou de lançar no Youtube , mas está cansado de ficar abrindo toda hora o vídeo pelo navegador, esperando carregar para obter os dados do vídeo como:
  • Inscritos;
  • Gosteis/Likes;
  • Não gosteis/dislikes;
  • Comentários.
Sem dizer também aqueles que acompanham um vídeo que ele gostou e/ou comentou e deseja acompanhar se há novos comentários e etc. Vamos criar um Shell Script que irá nos passar esses dados com um simples comando no terminal linux! Esse exercício faz parte da série Não é magia, é Shell Script! .

Antes de mais nada precisamos criar um cabeçalho, além da Shebang (#!), o cabeçalho precisa de dados do autor, link ou e-mail, licença e a versão do software, logo ficaria assim:

#!/bin/bash
# author:  Marcos Oliveira <diolinux.com.br>
# license: MIT
# version: 1.0

Após isso precisamos criar uma função para pegar os dados do youtube, criamos um arquivo temporário em /tmp com o comando mktemp baixamos a página do youtube relativa a qualquer vídeo e jogamos a saída do wget no nosso arquivo temporário que armazenamos numa variável, leia as linhas que começam com # (comentários):


# Rodamos o comando mktempo numa subshell, logo seu conteúdo 
será armazenado em page_video_youtube 
page_video_youtube=$(mktemp)

# Com a linha abaixo o conteúdo da paǵina HTML será guardado no
arquivo referenciado pela variável
wget "https://www.youtube.com/watch?v=hj-aDdRasGY" -O
$page_video_youtube


Próximo passo agora é filtrar o conteúdo dos dados que baixamos, após abrirmos o arquivo no editor de texto, verificamos que a linha que mostra o ID do canal, possui uma string única na página que pode nos ajudar para pegar dados do canal como: Título e inscritos.

Como o Youtube utiliza um padrão para endereços canais, então podemos filtrar os dados utilizando o Sed e baixando a página principal do canal que há as informações mais precisas e já armezarmos em variáveis o conteúdo que desejamos, para não poluir nosso ambiente, criaremos novamente arquivos temporários e jogaremos os dados nas variáveis referenciadas.

Leia os comentários no código


# Pega o id do canal e armazena na variável, rodando numa 
subshell id_do_canal=$(cat "$page_video_youtube" | grep 
'channelId' | sed 's/.*\=\"//' | sed 's/\".*//')

# Criamos outro arquivo temporário na pasta /tmp que será nosso 
canal page_canal=$(mktemp)

# Sabemos que o Youtube tem esse padrão, então passamos o ID que
 pegamos e adicionamos ao padrão de url do Youtube
# Fizemos o wget rodar "silenciosamente" jogando a saída para o 
vazio, podemos fazer no anterior também
wget "https://www.youtube.com/channel/$id_do_canal" -O 
"$page_canal" 2>/dev/null


Pronto, já possuímos todos os arquivos que precisamos, logo agora só resta filtrar os conteúdos e armazená-los numa variável para exibirmos numa próxima função que levaremos a ela via array, leia os comentários para entender as linhas, verifique que agora estamos passando a url via parâmetro pra função, pois iremos enviá-la pelo prompt:

function get_dados_youtube() {

# Filtramos o número de inscritos, título do víde, visualizações e gosteis ou não com sed e awk
num_inscritos=$(cat "$page_canal" | grep yt-subscription-button-subscriber-count-branded-horizontal | sed 's/<[^>]*>/ /g' | awk '{print $NF}')
titulo_video=$(cat $page_video_youtube | sed '/title/{p; q;}' | grep title | sed 's/<[^>]*>//g' | uniq | sed 's/...YouTube.*//')
views_video=$(cat $page_video_youtube | grep watch-view-count | sed 's/<[^>]*>//g')
likes=$(cat $page_video_youtube | grep like-button-renderer-like-button-unclicked | sed 's/<[^>]*>//g ;s/ //g')
dislikes=$(cat $page_video_youtube | grep like-button-renderer-dislike-button-unclicked | sed 's/<[^>]*>//g ;s/ //g')

echo "Nome do canal: $titulo_do_canal"
echo "Número de inscritos: $num_inscritos"
echo "Título do vídeo: $titulo_video"
echo "Visualizações: $views_video"
echo "Gosteis: $likes"
echo "Não gosteis: $dislikes"
}

Agora é só criar uma condição que obriga o usuário a informar o vídeo e pronto, veja o script pronto abaixo, copie o código, cole num arquivo, dê permissão de execução e rode:


Shell Script YouTube

No próximo artigo da série vamos adicionar nº de comentários, cores e uma condição para quando não houver URL, nosso script pegar os dados do vídeo mais recente! E depois para finalizarmos essa série, teremos uma surpresinha 😎 !

Se você ainda não tem muitos conhecimentos em Shell Script e está procurando uma forma eficaz de aprender do zero? Ou quem sabe você já possui conhecimentos em Shell mas quer evoluir e aprender a criar manuais, processos, games, animações, instaladores e muito mais?

Então não deixe passar a oportunidade de conhecer o "Curso Extremamente Avançado de Shell Script" que oferecemos junto com a galera do Terminal Root, são 3 cursos pelo preço de um, conheça aqui.

Até a próxima e bons estudos! linha de espaço Fim do texto
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.

Fazendo a pós-instalação do Arch Linux com i3+Polybar+Pywal

Nenhum comentário

sábado, 25 de agosto de 2018

O Arch Linux é uma distro que permite que você customize a instalação de todos os pacotes de software que farão parte do seu sistema, mas por ser, em sua forma padrão, uma distro de configuração bastante manual, é natural "perder tempo" configurando o Arch para deixar ele do seu jeito. No artigo de hoje o nosso amigo Marcos, do canal Terminal Root, vai te dar algumas dicas de pós-instalação do Arch Linux, ideal para quem quer um ambiente minimalista.

Arch Linux - Pós-instalação






O i3 é um Window Manager muito minimalista, mas ele fica melhor quando personalizado. Neste artigo vamos falar sobre ele com a pós-instalação do Arch Linux do i3 (clique aqui para ver um vídeo sobre i3 no Ubuntu Minimal), Polybar, Pywal e mais dos aplicativos listados abaixo de forma Automatizada com Shell Script!

Os pacotes necessários para este tutorial serão:
  • xorg;
  • fonts;
  • lightdm;
  • xterm;
  • firefox;
  • e bash-completion.

Após a instalação do Arch Linux, muitas pessoas perdem muito tempo para deixá-lo pronto pro uso com i3, Polybar e Pywal, nesse caso utilizamos Shell Scripts que automatizam e aceleram todo o processo.

Instalamos o wget, pois ele só existia no CD de boot do Arch . Após baixamos nosso software para pós-instalação automatizada, damos permissão de execução ao programa, verificando quais opções estão disponíveis com o parâmetro --help e otimizamos o espelho de rede, para que as instalações fiquem mais rápidas com o parâmetro --mirror.

Criamos e configuramos um usuário para ser o sudo. E então efetuamos a pós-instalação com nosso aplicativo ninja 😎 !!! Após finalizado, vamos reiniciamos o sistema.

passwd
pacman -Syu
pacman -S wget
wget terminalroot.com.br/pos-arch.in
chmod +x pos-arch.in
./pos-arch.in --help
./pos-arch.in --mirror
./pos-arch.in --sudouser [seu-usuario]
./pos-arch.in --install
reboot

Após iniciar sessão gráfica no i3 , instalamos o Polybar e o Pywal com outro Shell Script Ninja: o Popy
git clone https://gitlab.com/terminalroot/popy.git
cd popy && ./popy.in --all
Além de outras dicas complementares que podem ser consultadas assistindo o vídeo abaixo:


Aprenda a criar aplicativos semelhantes ao pos-arch.in e o popy de forma PROFISSIONAL e EXTREMAMENTE AVANÇADA, se você ainda não tem muitos conhecimentos em Shell Script e está procurando uma forma eficaz de aprender do zero? Ou quem sabe você já possui conhecimentos em Shell mas quer evoluir e aprender a criar manuais, processos, games, animações, instaladores e muito mais? Então não deixe passar a oportunidade de conhecer o "Curso Extremamente Avançado de Shell Script" que oferecemos junto com a galera do Terminal Root, são 3 cursos pelo preço de um, conheça aqui.

Links Úteis

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


Não é magia, é Shell Script! Truques da linha de comando Linux

Nenhum comentário

segunda-feira, 20 de agosto de 2018

Dominar o Shell Script é, em outras palavras, automatizar o Linux da forma mais pura. Hoje vamos começar uma série que vai te ajudar a fazer as pazes com o terminal e ainda lhe dar algumas dicas úteis.

Terminal Linux - Shell Script






O Shell Script foi criado por Ken Thompson (Thompson Shell, mais tarde foi substituído pelo Bourne Shell desenvolvido por Stephen BourneBourne Shell), o criador do Unix e Linguagem C, juntamente com Dennis Ritchie. O objetivo principal foi: criar uma forma rápida, fácil e que fosse possível automatizar a comunicação com o Kernel. A principal característica do Shell Script é a mesma que lhe difere de diversas linguagens de programação, que é poder de jogar a saída de um comando para outro comando, o pipe, que atualmente pode ser "invocado" pelo caracter: | .

O Shell Script está presente em todos os sistemas Unix e Unix-like (Linux, FreeBSD, OpenBSD, HP-UX, Solaris, AIX, NetBSD, Irix, etc.), sem dizer que o Microsoft Windows, na sua última versão, possui Shell Script, além do macOS que é um sistema que possui o kernel FreeBSD customizado. Existem diversos tipos de Shell, essa variedade passou a existir por conta das licenças de software. Nas distribuições Linux, o Shell padrão é o Bash (Bourne Again Shell, tratando-se de uma melhoria do Bourne Shell e com uma licença mais permissiva), que é o que utilizaremos aqui.

Customizando a aparência do seu prompt de comando (Variável PS1)


Da mesma forma que existem diversos tipos de Shell, existem também diversos emuladores de terminal para o Shell e diversas formas de apresentar suas características. A primeira coisa que você vê quando abre o terminal é o prompt de comando, para entender melhor ele, podemos dizer que é uma "barra indicadora" da sua posição no Shell. A aparência dele depende diretamente da variável PS1 , que pode ser configurada nos arquivos: ~/.bashrc, .profile ou qualquer arquivo que faça parte da árvore recursiva . Veja na imagem abaixo o exemplo do meu prompt de comando:

Terminal

Ou seja, isso é o conteúdo da minha variável $PS1 . Se você atribuir outro valor a variável PS1 utilizando o próprio Shell, você verá que o prompt será alterado. Exemplo, copie e cole o conteúdo abaixo e cole no seu terminal e depois tecle enter:

PS1=
"blog@diolinux: "

Você notará que o prompt será modificado, mas não se preocupe, se quiser que retorne ao prompt anterior, basta fechar e abrir de novo seu terminal ou rodar o comando abaixo:

source
/etc/profile

Se quiser modificar permanentemente a configuração do seu prompt basta atribuir o valor que deseja no seu .bashrc . Você pode adicionar: sintaxes específicas, cores, caracteres,... Por exemplo, para que seu prompt apresente: o nome de usuário, o nome de seu computador e o diretório em que você se encontra, use essa configuração para seu prompt:
  • \u  - indica o nome de seu usuário;
  • \h  - indica o host;
  • \w  - indica o diretório;
  • \n  - pula para linha abaixo.
E vamos separá-lo por alguns caracteres definidos por nós como: seta,relâmpago e espaços. Ficando assim:
PS1="\u → \h \w\n ⚡"
Abra o arquivo .bashrc com um editor de texto e crie uma nova linha no final do arquivo e insira o conteúdo acima, ou rode o comando abaixo:
echo 'export PS1="\u → \h \w\n ⚡"' >> ~/.bashrc
O comando export serve para deixá-la global!
Se quiser defina cores para sua PS1, usando a seguinte sintaxe: :
  • NUMERO - Corresponde ao número da cor: (31 é vermelho, 32 verde, 33 amarelo, 34 azul, 35 rosa, 36 ciano, 37 branco e 30 preto)
  • TIPO - Define se aparecerá em negrito, sublinhado ou normal: (1 é negrito, 4 sublinhado e 0 normal)
A letra m, logo após o TIPO tem de existir e pode ficar "colada" com o restante do conteúdo. Veja esse exemplo que eu criei para esse artigo:
  • Verde negrito para o nome de usuário: [32;1m
  • Amarelo negrito para a seta: [33;4m
  • Branco normal para o diretório: [37;0m
  • Rosa negrito para o relâmpago: [35;1m
  • E no final desligamos as cores: [m
sh PS1="\e[32;1m\u \e[33;1m→ \e[36;1m\h \e[37;0m\w\n \e[35;1m⚡\e[m"


Terminal customizado

Colorindo o Manual e tornando a leitura mais amigável


O manual do sistema é uma das partes mais acessados pelo Shell, e muita gente não gosta muito de utilizá-lo, pois acha ele técnico demais dizendo que não consegue entender bem. Um dos motivos dessa dificuldade está relacionada ao visual do mesmo. Assim como vimos a dica anterior que incluia utilização de cores, podemos customizar o manual para que ele separe os trechos com cores que FACILITARÃO MUITO nossa leitura. Exemplo: Copie o comando abaixo e cole no final do seu .bashrc e depois abra o manual e veja a diferença:
export LESS_TERMCAP_mb=$'\e[1;32m'
export LESS_TERMCAP_md=$'\e[1;32m'
export LESS_TERMCAP_me=$'\e[0m'
export LESS_TERMCAP_se=$'\e[0m'
export LESS_TERMCAP_so=$'\e[01;33m'
export LESS_TERMCAP_ue=$'\e[0m'
export LESS_TERMCAP_us=$'\e[1;4;31m'

Depois feche e abra o terminal ou rode o comando source ~/.bashrc abra o manual e veja a diferença, ex.: man bash

Manual customizado Linux

Se você ainda não tem muitos conhecimentos em Shell Script e está procurando uma forma eficaz de aprender do zero? Ou quem sabe você já possui conhecimentos em Shell mas quer evoluir e aprender a criar manuais, processos, games, animações, instaladores e muito mais? Então não deixe passar a oportunidade de conhecer o "Curso Extremamente Avançado de Shell Script" que oferecemos junto com a galera do Terminal Root, são 3 cursos pelo preço de um, conheça aqui.

Até a próxima e bons estudos! 
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


O que são GUI e DE? Quais suas diferenças?

Nenhum comentário

terça-feira, 17 de julho de 2018

Uma das dúvidas e confusões de quem está iniciando no mundo Linux: Qual a diferença entre Interface Gráfica e desktop environment? Se você usa Linux há muito tempo e possui essa dúvida, não se sinta mal, o importante é que vamos conferir essa diferença agora mesmo!



A interface gráfica ou GUI (graphical user interface) em um sistema operacional, é uma aplicação, uma das partes do sistema operacional, já o DE (desktop environment), é algo mais abrangente que engloba por exemplo, até mesmo a própria interface gráfica. O desktop environment é composto de várias aplicações e não somente da interface. A interface é uma das aplicações que acompanham o desktop environment e a interface gráfica é basicamente o que você vê na tela do seu sistema operacional.

Podemos usar como exemplo o projeto KDE, que é responsável por gerenciar várias aplicações diferentes, desde aplicações como calculadora, calendário, o nosso querido Kdenlive, utilizado para editar os vídeos do canal e é claro a interface gráfica KDE Plasma, ou somente "Plasma", como os próprios desenvolvedores do KDE convencionaram chamar. Sendo assim, o desktop environment KDE é composto do Plasma juntamente com outras ferramentas desenvolvidas pelo projeto KDE. 

Apesar de usarmos o KDE como exemplo, o mesmo vale para, virtualmente, qualquer outro projeto. Além disso, você pode utilizar uma interface gráfica, mas com aplicações de projetos diferentes. Uma prova disso, é utilizar uma distro como o Linux Mint, com a interface Cinnamon, mas com aplicações GNOME, como o Monitor do Sistema, ou seja, você usa parte de um desktop enviroment em uma distro cujo ambiente gráfico corresponde a outro diferente.

Nesse vídeo no canal, discutimos com vários exemplos a diferença entre interface gráfica e desktop environment no Linux e vale muito a pena conferir.


Espero que este post e vídeo tenham lhe ajudado :)

Até mais!

_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


Matrículas abertas para o curso de SHELL SCRIPT! (TEMPO E VAGAS LIMITADAS)

Nenhum comentário

sábado, 5 de agosto de 2017

Depois de dois meses em hiato, finalmente vamos conseguir abrir as vagas para o curso de Shell Script do Diolinux EAD. Agora o Tiago Salem, nosso professor, estará apto a receber e atender novos alunos.

Curso de Shell Script






Chegou a hora de abrirmos as matrículas para a nossa segunda turma de alunos para o curso "Shell Script - Dominando o Linux uma linha  por vez" ministrado no Diolinux EAD pelo professor Tiago Salem, ex-desenvolvedor da Canonical e atual Engenheiro de Suporte L3 na SUSE.

Assim como fizemos no lançamento da primeira turma, não podemos deixar as matrículas abertas tempo demais e nem deixar as vagas liberadas por conta da agenda do Tiago, que quer dar atenção especial a todos os seus alunos.

Vagas limitadas e tempo limitado


Quando fechamos as matrículas pela primeira vez, colocamos no Diolinux EAD um formulário para que as pessoas pudessem entrar na lista de espera para esta próxima turma, a ideia era fechar uma turma de 50 pessoas no máximo, porém, tivemos uma popularidade incrível e por conta disso vamos abrir 100 vagas, pois 91 pessoas já haviam se candidatado a  uma vaga no curso através deste formulário.

Essas mais de 90 pessoas receberam de antemão em seus e-mails hoje pela manhã o link para compra para garantir as suas vagas. De qualquer forma, as matrículas ficarão abertas somente até o dia 10 de Agosto, depois fecharemos elas novamente por tempo indeterminado, até que tenhamos mais capacidade para atender todo mundo.

Atenção para as pessoas que colocaram seus nomes da lista: O fato do seu nome estar lá não lhe garante uma vaga necessariamente, mas ele te deu uma vantagem em relação aos outros compradores para que você possa comprar ele antes.

Se você quiser dominar o Linux através do Shell Script, a hora é agora!


Como as vagas são limitadas e o tempo também, o melhor momento para você comprar o curso é exatamente agora, corra lá e garanta o seu espaço em um curso extremamente bem elaborado e com um profissional de primeiro nível como instrutor.

Se estiver precisando de "incentivo", nós temos 50 cupons de desconto para serem usados por pessoas que não fizeram o curso de Bash ainda, estes recebem automaticamente um desconto especial para o curso de Shell Script, para comprar o curso de Shell com R$ 49,90 de desconto basta inserir o código a seguir na hora de finalizar a compra:

HWAYTSHELL

Pegou a referência ao AC/DC? 😀

Esperamos você no curso enquanto durarem as vagas, clique aqui para acessar.

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


O que é possível fazer com Shell Script?

Nenhum comentário

sexta-feira, 4 de agosto de 2017

Recentemente um dos alunos lá do EAD do Diolinux fez uma pergunta interessante:  O que é possível de se fazer com shell script? Como esta é uma dúvida muito comum, aqui neste artigo vamos entender melhor o que é possível de se fazer com shell script e quando se deve (ou não) usar shell script.

Curso de Shell Script




A primeira coisa que temos que entender é que as linguagens de programação (e incluo shell script aqui) são ferramentas que nós entusiastas de tecnologia utilizamos para resolver problemas.

Dependendo da natureza do problema, existe uma ferramenta mais adequada.

Explico:

Vamos supor que você precise serrar uma tábua. Você tem a opção de escolher entre um serrote e uma faca de cozinha. Qual você escolheria?


É claro que a ferramenta que vai dar resultado mais rápido e com menos esforço é o serrote.. mas.. se você quisesse usar a faca, também iria funcionar, só que iria exigir *muito* mais esforço e demoraria muito mais tempo.

Com linguagens de programação é a mesma coisa, e por isso que não existe "a melhor linguagem".

Cada uma é boa em fazer uma coisa, e quanto mais você domina a "ferramenta", melhor e mais rápido você resolve os problemas.

Shell Script é uma linguagem que você utiliza para pedir que o Bash automatize diversos tipos de tarefas, especialmente quando estas tarefas envolvem invocar comandos do terminal.

O Bash trabalha muito bem interagindo com comandos da linha de comando (capturando saída de comandos, condicionando execução de comandos, etc), e por isso é a ferramenta preferida de uma enorme quantidade de pessoas para automatizar tarefas principalmente administrativas.


É claro que em outras linguagens também é possível de se obter o mesmo resultado, mas pode talvez não ser tão trivial quando em shell script.

O oposto também é verdadeiro. Já vi gente implementando um servidor web em shell script (tipo um apache ou nginx). É claro que funciona, porém é uma solução que não "escala". Shell script não é uma linguagem de alta performance, e portanto este servidor web, apesar de ser um ótimo exercício para fins didáticos, não poderia ser utilizado "para valer" devido ao seu desempenho ruim comparado a um servidor escrito em C ou C++.


Outro exemplo é um projeto muito bacana: Mario em shell script.

Simplesmente sensacional e mostra todo o poder do shell script, mas evidentemente não é a ferramenta ideal para se escrever um jogo.

Resumo da obra:

O poder está na mão do programador em decidir qual é a ferramenta mais adequada para se resolver algum problema, e se este problema envolve automatização de comandos disponíveis no terminal e tarefas administrativas, não precisa pensar duas vezes e pode mandar bala no shell script.

E por falar nisso, se você já tem experiência na linha de comando e gostaria de passar para o próximo nível, entender como o processo de criação de um script funciona e entender os diversos operadores e estruturas que o bash fornece para automatizar processos, em breve abriremos mais vagas no curso de shell script lá no EAD do Diolinux.

Existe uma fila de espera para os cursos, são 100 vagas que serão abertas, até o momento temos 84 inscritos, então se você tem interesse, corre lá para ver!

Este texto foi escrito pelo Tiago Salem, nosso professor no Diolinux EAD.

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.




Como criar um Shell Script simples para automatizar a instalação de programas no Linux

Nenhum comentário

terça-feira, 13 de junho de 2017

Uma das coisas mais legais do Bash é o poder de automatizar tarefas, até mesmo na própria linha de comando. Hoje você vai aprender a criar um simples Shell Script para instalar um programa.

Shell Script




Para você entender o conceito, vamos dar um exemplo com um programa popular e simples, o GIMP. O GIMP é um manipulador de imagens que está no repositório de todas as distros Linux praticamente, como exemplo nos comandos vamos usar o gerenciador de pacotes "apt", comum no Debian, Ubuntu, Linux Mint e derivados, apesar disso, entendendo o conceito, você pode aplicar em qualquer distro, basta entender o gerenciador de pacotes dela e os comandos que ele aceita.

Claro, o GIMP pode ser instalado por centrais de apps sem comandos, pode ser também instalado com um simples # apt install gimp mas a intenção é te mostrar como você pode estruturar um script para automatizar a instalação de qualquer programa ou de vários ao mesmo tempo.

Vamos imaginar que você queria instalar o gimp a partir do terminal.

Muito provavelmente os passos que você dará serão:

1) Atualizar os repositórios
$ sudo apt-get update
2) Instalar possíveis atualizações do sistema:
$ sudo apt-get dist-upgrade -y
3) Efetivamente instalar o pacote.
$ sudo apt-get install gimp

O processo manual da instalação de um programa pode levar algum tempo, pois você deverá esperar que o primeiro comando termine sua execução para digitar o próximo.

Nem sempre atualizar repositórios é rápido e portanto é o seu tempo que está sendo gasto esperando algo que poderia facilmente ser automatizado.

O primeiro nível de automatização que poderíamos fazer aqui é criar uma fila de comandos (chamadas de listas) que serão executados pelo Bash em sequência.

Para isso basta separar os comandos com um ponto e vírgula:
sudo apt-get update ; sudo apt-get dist-upgrade -y ; sudo apt-get install gimp -y
Apesar de já automatizar um pouco o processo, não há praticamente nenhuma lógica envolvida.

Você muito provavelmente não deseja executar um "dist-upgrade" se o "update" falhar antes por qualquer motivo. Certo?

Aqui chegamos no nosso segundo nível de automatização. Em vez de usar o ponto e vírgula, podemos separar os comandos com "&&", e desta forma o Bash somente executará o comando seguinte se o anterior finalizar a execução com sucesso.
sudo apt-get update && sudo apt-get dist-upgrade -y && sudo apt-get install gimp -y
Agora já melhoramos bastante o processo, porém no caso de algum dos comandos retornar falha, esta fila de comandos simplesmente para de ser executada sem qualquer tipo de aviso mais elaborado para o usuário.

É possível em linha de comando adicionar mais lógica para continuar aperfeiçoando este nosso procedimento, porém este é aquele momento em que talvez seja mais proveitoso se criar um script de verdade e deixar o processo legível, em vez de simplesmente criar uma "tripa" de comandos que depois poderá dificultar a sua vida na hora de encontrar e consertar qualquer erro.

Para este nosso exemplo, usaremos o próprio "if" do Bash (que é uma estrutura de condicional explicada brevemente neste vídeo aqui)

Basta criar um arquivo de texto que você pode 'chamar do que quiser .sh", tipo "batatinha_quando_nasce.sh" e inserir os dados que vamos te mostrar. Tá bom, talvez seja melhor criar um arquivo chamado instala-pacote.sh o seguinte conteúdo:

#!/bin/bash

echo Atualizando repositórios..
if ! apt-get update
then
    echo "Não foi possível atualizar os repositórios. Verifique seu arquivo /etc/apt/sources.list"
    exit 1
fi
echo "Atualização feita com sucesso"

echo "Atualizando pacotes já instalados"
if ! apt-get dist-upgrade -y
then
    echo "Não foi possível atualizar pacotes."
    exit 1
fi
echo "Atualização de pacotes feita com sucesso"

# note que $1 aqui será substituído pelo Bash pelo primeiro argumento passado em linha de comando
if ! apt-get install $1
then
    echo "Não foi possível instalar o pacote $1"
    exit 1
fi
echo "Instalação finalizada"

Veja que utilizamos o operador "!" após o "if" para inverter o resultado do comando seguinte, portanto o conteúdo das condicionais (código que está entre o "then" e o "fi") somente será executado caso os comandos falhem na execução. Também utilizamos o comando "exit 1" para pedir ao Bash que interrompa a execução do script em caso de falha.

Para executar o script basta rodar a seguinte linha:

sudo bash instala-pacote.sh gimp

Desta forma podemos utilizar o mesmo script para qualquer pacote, e o "sudo" só precisa ser invocado uma vez. Basta passar o nome do pacote desejado em linha de comando e ver o Bash fazer o resto sozinho.

É possível melhorar e incrementar o script de diversas maneiras. Podemos imprimir mensagens com cores, suprimir a saída em tela do comando apt-get para facilitar a leitura, dentre outras coisas.

Basta ter criatividade e dominar a linguagem do shell script para poder automatizar praticamente o que você quiser.


Outra coisa que você pode fazer é incluir dentro do Shell Script os comandos para a instalação do pacote em específico, assim você pode rodar apenas o Shell Script e ele se encarrega de fazer a instalação para você.

Você pode por exemplo criar um script de pós formatação para o seu sistema, acrescentando repositórios, pacotes e programas que você normalmente usa, incluindo as opções para fazer a atualização do sistema e apenas rodar um Shell Script depois de instalar a sua distro e ir tomar café enquanto seu sistema é montando automaticamente. É mais do que bacana!

Nós lançamos nesta semana o nosso curso avançado de Shell Script, onde você vai aprender coisas como esta deste post e muitas outras para automatizar a sua vida de usuário Linux, as matrículas estão abertas até Quinta-feira, dia 15 de Junho e tem promoção especial para quem comprar hoje até a meia-noite. Corre lá pra conferir antes que fechem as matrículas.

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.




Blog Diolinux © all rights reserved
made with by templateszoo