yo! Nesse artigo vou mostar como usar o Slackware64 “rolling-release”, também conhecido como -current. Como o foco é desktop, vou mostrar com habilitar o suporte à multilib que é necessário para o wine e o virtualbox.

Os nossos passos serão:

- Baixar o mutilib e o kde 4.8.0

- Instalar o Slackware64 13.37

- Atualizar para o -current

- Instalar o multilib

- Instalar o driver de vídeo proprietário no caso de placas da NVIDIA ou AMD

- Instalar o kde 4.8.0

- Compilar e instalar o wine

- Instalar o Virtualbox

 

Passo 1: Baixar o mutilib e o kde 4.8.0

Primeiro vamos baixar o multlib e o kde-4.8.0 e deixá-los num pen-drive ou partição para já instalarmos logo após atualizar para o current:

rsync -av --delete rsync://taper.alienbase.nl/mirrors/alien-kde/4.8.0/x86_64/deps /mnt/alien/kde48/deps/
rsync -av --delete rsync://taper.alienbase.nl/mirrors/alien-kde/4.8.0/x86_64/kde /mnt/alien/kde48/kde/
wget http://taper.alienbase.nl/mirrors/alien-kde/4.8.0/x86_64/kdei/kde-l10n-pt_BR-4.8.0-noarch-1alien.txz
rsync -av --delete rsync://taper.alienbase.nl/mirrors/people/alien/multilib/current /mnt/alien/multilib/

Pronto. Vamos para o próximo passo.

 

Passo 2: Instalar o Slackware64 13.37

Não vou explicar como instalar o Slackware Linux, já espero que você saiba como fazê-lo.

Durante a instalação não é necessário instalar o kde, afinal vamos usar o kde mais novo do alien.

 

Passo 3: Atualizar para o -current

Agora vamos atualizar o novo sistema para a versão -current.

Edite o /etc/slackpkg/mirrors escolhendo um mirror e mudando o 13.37 para current.

Atualize para o current:

slackpkg install-new
slackpkg upgrade-all

Quando o slackpkg perguntar se quer rodar o lilo, diga que sim (Y). Quando ele perguntar sobre o arquivos de configuração novos, respoda que quer sobrescrever.

Reinicie o sistema e depois vamos ao próximo passo.

 

Passo 4:  Instalar o multilib

Monte o pen-drive ou partição aonde salvou o multilib e o kde 4.8:

mkdir /mnt/alien
mount /dev/sdb1 /mnt/alien
cd /mnt/alien/mutilib/current
upgradepkg --reinstall --install-new *.t?z
upgradepkg --reinstall --install-new slackware64-compat32/*-compat32/*.t?z

Pronto. Agora vamos colocar os pacotes do alien na blacklist do slackpkg para evitar que ao atualizar o slackware você sobrescreva os pacotes da glibc e do gcc.

Edite o /etc/slackpkg/slackpkg.conf e adicione no final do arquivo:

# Alien's multilib packages
 [0-9]+alien

 

Passo 5: Instalar o driver proprietário de vídeo

Essa parte é só para quem tem placa de vídeo da NVIDIA ou AMD e quer usar o driver proprietário. Não vou explicar como executar o procedimento em si (entrar no site do fabricante, baixar o driver e executar a instalação), mas deixarei registrado a pós-instalação.

Contudo, antes um detalhe importante: é necessário instalado o mutilib antes do driver de vídeo, assim ele detecta que o sistema suporta 32bits e já instala as bibliotecas 32bits junto com as 64bits.

Após a instalação do driver, adicione o driver opensource na blacklist:

Para placas AMD:
echo "radeon" >> /etc/modprobe.d/blacklist.conf
Para placas ATI:
echo "nouveau" >> /etc/modprobe.d/blacklist.conf

Isso é imporante pois o driver opensource “conflita” com o driver proprietário e coisas estranhas acontecem se os dois estiverem carregados.

E depois configure o xorg, bastando criar o arquivo /etc/X11/xorg.conf.d/50-device.conf:

Section "Device"
   driver "fglrx"
EndSection

Passo 6: Instalar o kde 4.8.0

Para instalar o kde, você tem 2 opções:

1. Pode instalar tudo com upgradepkg –reinstall –install-new kde/*t?z

2. Pode instalar só o que precisa, então entre no diretório do kde e execute pkgtool. Ele irá mostrar o pacote com sua descrição e então você escolhe quer instalar ou não. Lembre-se se instalar o pacotes importante do kde (kde-*, kdeadmin*, kdeartwork*, kdegraphics*, kdelibs*, kdemultimedia*, kdenetwork*, kdepim* kdeplasma*, ark*, kcalc*, kcolor*, konsole*, ksecrets*, kwallet*, kwebkitpart*, lib*, marble*,  okular*, oxygen*, perl*, polkit*, pykde*, qtruby*)

cd /mnt/alien/kde48
upgradepkg --reinstall --install-new deps/*.t?z

Procure por novos arquivos de configuração: slackpkg new-config

Instale o pacote de idioma: installpkg kde-l10n-pt_BR-4.8.0-noarch-1alien.txz

Pronto. Reinicie o computador.

 

Passo 7: Compilar e instalar o wine

O wine não funciona bem em 64bits, pelo menos por enquanto e por isso precisamos do multilib (sem contar outros programas como o skype).

Um detalhe importante é que você pode instalar as dependências somente em 32bits. No meu caso eu instalo o pacote 64bits e refaço o pacote 32bits para só possuir a libs e os binários. Logo abaixo mostrei as duas opções.

Vamos precisar e instalar dos slackbuilds (na ordem): OpenAL, fontforge, webcore-fonts, prelink e wine. Desses só o webcore-fonts é que pode ser instado 64bits já que ele não depende de arquitetura.

sbopkg -i webcore-fonts

Para instalar os slackbuilds 32bits são necessários dois passos: o primeiro é rodar o script 32dev.sh do Alien que serve para preparar o ambiente e o segundo é alterar a variável LIBDIRSUFFIX do arquivo pacote.Slackbuild. Também vamos alterar o OUPUT para gerar o pacote num diretório especifico ao invés do padrão que é o /tmp. Irei mostrar para como fazer isso para um dos pacotes e cabe a você fazer nos outros.

O pacote será o OpenAL

Edite o OpenAL.Slackbuild e altere:

de: OUTPUT=${OUTPUT:-/tmp}
para: OUTPUT=${OUTPUT:-/home/slackbuilds32}

e em outra linha

de: elif [ "$ARCH" = "x86_64" ]; then
 SLKCFLAGS="-O2 -fPIC"
 LIBDIRSUFFIX="64"

 para:
 elif [ "$ARCH" = "x86_64" ]; then
 SLKCFLAGS="-O2 -fPIC"
 LIBDIRSUFFIX=""

Lembre-se de criar o diretório /home/slackbuilds32

Prepare o ambiente para compilação 32bits:

. /etc/profile.d/32dev.sh

(sim, o . antes faz parte do comando)

Compile o slackbuild:

./OpenAL.Slackbuild

Tudo pronto. Agora é que tem a diferença que comentei no ínicio dessa parte.

Se você quiser ter apenas a versão 32bits, então basta instalar o pacote com o comando installpkg /home/slackbuilds32/OpenAL*.t?z

Se você quiser ter o pacote 64bits e as libs e binários do mesmo em 32bits, então vamos modificar o pacote 32bits para só instalar as libs e os binários. Para isso:

cd /home/slackbuilds32
tar xvf OpenAL*.t?z

Irão surgir os diretórios aonde o pacote instala seus arquivos, que geralmente são install, usr e etc. Precisamos apagar o etc, usr/doc, usr/man, usr/share/ usr/include e quaisquer outros diretórios que sejam independente de arquitetura.

Depois movemos os binários para um outro diretório:

mkdir usr/bin/32
mv usr/bin/{arquivos} usr/bin/32/
mv usr/sbin/* usr/bin/32/
NOTA: {arquivos} são os binários do programa. Mova-os para do diretório usr/bin para usr/bin/32

Agora refazer o pacote:

tar czf OpenAL-1.13-x86_64-lib32-1.tgz install usr

Agora basta instalar o pacote.

Precisamos instalar a versão 64bits do mesmo programa, para ter os arquivos 64bits e os independente de arquitetura que removemos do pacote 32bits. Para isso, você precisa abrir um outro terminar, já que o atual está modificação para compilação de programas em 32bits. No novo terminar basta instalar o pacote:

sbopkg -i OpenAL

Agora é só repetir os passos com os outros programas.

 

Passo 8: Instalar o Virtualbox

Baixe o Virtualbox de www.virtualbox.org. Por exemplo:

wget http://download.virtualbox.org/virtualbox/4.1.8/VirtualBox-4.1.8-75467-Linux_amd64.run
chmod +x VirtualBox-4.1.8-75467-Linux_amd64.run

entre como root e instale-o com

./VirtualBox-4.1.8-75467-Linux_amd64.run

Para instalar o extension pack e ter suporte à usb, rdp e etc., baixe o extpack e instale

http://download.virtualbox.org/virtualbox/4.1.8/Oracle_VM_VirtualBox_Extension_Pack-4.1.8-75467.vbox-extpack

Por fim, adicione seu usuário no grupo vboxusers:

gpasswd -a seu_usuário vboxusers

 

Tudo pronto! E por fim, seguem algumas dicas:

-  montar pen-drives com ntfs não tem permissão de escrita porque é usado o driver ntfs do kernel ao invés do ntfs-3g. Para corrigir isso faça com root:

 cd /sbin; ln -s mount.ntfs-3g mount.ntfs

Referência: http://www.linuxquestions.org/questions/showthread.php?p=4441319

- configurar o teclado em pt-br:

Crie o arquivo /etc/X11/xorg.conf.d/10-keyboard.conf:

Section "InputClass"
        Identifier "mykeyboard"
        MatchIsKeyboard "on"
        Option "XkbLayout" "br"
        Option "XkbOptions" "terminate:ctrl_alt_bksp"
EndSection

Referências:

http://alien.slackbook.org/dokuwiki/doku.php?id=slackware:multilib

http://taper.alienbase.nl/mirrors/alien-kde/4.8.0/

http://alien.slackbook.org/blog/

Pensando no futuro, a Apple deixa registradas muitas patentes que parecem ideias de filmes futuristas. No Patently Apple, o blogueiro Jack Purcher mostra alguns desses planos. Um deles é o de um sistema de projeção holográfica, com o qual imagens de dispositivos poderiam ser vistas em 3D sem a necessidade de óculos especiais.

Recentemente, a Apple registrou patente relacionada à tecnologia Liquidmetal, para fazer células de combustível capazes de produzir energia necessária para mais de um mês de uso de um celular. Outra patente registrada é a de um projetor de tela acoplado ao iPhone e ao iPad, capaz de reproduzir as imagens dos aparelhos em superfícies.

Fonte: http://www1.folha.uol.com.br/tec/969491-patentes-da-apple-preveem-tela-holografica-e-bateria-de-um-mes.shtml

yo! Saiu ontem os novos releases do FreeBSD, a 8.2-RELEASE e a 7.4-RELEASE. Dentre as novidades da versão 8.2-RELEASE estão:

- Suporte à Xen HVM no FreeBSD/amd64 e Xen PV no FreeBSD/i386 melhorados.

- ZFS on-disk format atualizado para a versão 15.

- Suporte completo à GPT (GUID Partition Table).

- Adicionado o driver aibs(4). Ele suporta os sensores de placas-mãe ASUS e substitui o acpi_aiboost(4).

- O driver xhci(4), que suporta Extensible Host Controller Interface (xHCI) e USB 3.0, foi adicionado.

- O emulador de linux no FreeBSD agora suporta a API video4linux. Ele requer hardware e drivers nativos do video4linux como os disponíveis em multimedia/pwcbsd e multimedia/webcamd.

- O sysinstall agora usa os seguintes número como padrão e mínimo para as partições: 1GB para /, 4GB para /var e 1GB para /tmp.

- O ISC BIND foi atualizado para a versão 9.6-ESV-R3 e o OpenSSL para 0.9.8q.

- O GNOME foi atualizado para a versão 2.32.1.

- O KDE foi atualizado para a versão 4.5.5.

Para mais detalhes, veja a páginas de anúncio[1] e as notas de lançamento[2].

[1]: http://www.freebsd.org/releases/8.2R/announce.html

[2]: http://www.freebsd.org/releases/8.2R/relnotes.html

Iae Galera, estou de volta ;P

Bom uma rápida introdução do que é o ssh reverso.

Ssh reverso consiste em: o cliente se conectar ao servidor, assim habilitando o servidor se conectar ao cliente. De que maneira?

Vamos lá!
No cliente o comando é o seguinte:
ssh -R ${porta}:localhost:22 ${login}@${ipservidor}
Na pratica:
ssh -R 2222:localhost:22 user@server.com

Depois do cliente conectado o servidor pode se conectar ao cliente, sem saber o ip e nem nada só pela porta

No servidor fica assim então:
ssh -p ${porta} ${login}@localhost
Na pratica:
ssh -p 2222 user@localhost

Os usuário não precisam ser os mesmo e ambos servidor e cliente, pode ser qualquer usuário existente, por exemplo: do cliente eu acesso o servidor com o usuario “halfling” e do servidor eu acesso o cliente com o usuário “root”

Cliente:
ssh -R 2222:localhost:22 halfling@server.com

Servidor:
ssh -p 2222 root@localhost

Beleza agora que sabem disso, vale lembrar que o acesso não é insento de senhas, você precisa digitar a senha em ambos os casos, cliente e servidor.

Pois bem, agora vamos a uma parte interessante do tipo, pra que serve isso?

Exemplos:
Da minha casa eu deixo uma conexão ssh reversa aberta em um servidor e do meu trabalho consigo acessar o servidor que acesso minha casa.
Coloco num cliente da empresa para se conectar a empresa e da empresa conecto no cliente.
E por ae vai…

Tá bacana até aqui, mas e se o cliente cair, e se reiniciar o PC, como faço?

Bom ae entramos na parte que me fez criar esse artigo.

Primeiro vamos trabalhar com chaves publicas ssh, onde eu autorizo chaves no meu ssh para que entre sem senha.
A idéia é que o cliente entre sem senha no servidor e o servidor entre sem senha no cliente.

Rápida nota sobre chaves.
Criando uma chave:
comando: “ssh-keygen -t rsa”

A chave criada estará em ~/.ssh/id_rsa.pub

Beleza faça isso no cliente e no servidor

Se você der um “cat ~/.ssh/id_rsa.pub” vai ter em sua tela o conteudo da chave.

Muito bem você precisa pegar o conteudo da chave do cliente e inserir dentro de um arquivo no servidor.
O arquivo é: ~/.ssh/authorized_keys
normalmente ele não existe então é só criar, depois de criado adicione a chave do cliente dentro do authorized_keys do servidor e a chave do servidor dentro do authorized_keys do cliente

Muito bem agora cliente e servidor se conectam sem senha um com o outro(com o usuário que você criou a chave)

Beleza, voltando ao conectar automaticamente, mesmo se reiniciar o PC ou cair a conexão.

Com uma grande ajuda do meu pai(Ricardo Leite), criei um script para automatizar a conexão, então segue ele ae:

#!/bin/bash
{
echo “Iniciando SSH REVERSO…”
ipremoto=192.168.1.1 #ip do servidor que você quer se conectar
login=halfling #login que você quer se conectar ao servidor
porta=2222 #porta de conexão com o servidor
dorme=300 #tempo(em segundos) que ele espera pra verificar se a conexão ainda está ativa

iplocal=$(lynx –dump charlesgoncalves.com.br/myip.php | tr -d ‘ ‘) #pega o IP de internet do cliente de um script PHP que retorna o IP de internet
reverso=$(host $(lynx –dump charlesgoncalves.com.br/myip.php) | awk -F ‘ ‘ ‘{print $NF}’ | sed ‘s|\.$||g’) #igual ao anterior, mas depois de pegar o IP ele pega o reverso do IP

while [ 1 ] ; do

porip=$(ssh ${login}@${ipremoto} “who”| grep ${iplocal} | wc -l)#conecta no servidor e vê se já tem conexão aberta pelo IP de internet
porname=$(ssh ${login}@${ipremoto} “who”| grep ${reverso} | wc -l)#conecta no servidor e vê se já tem conexão aberta pelo reverso do IP
#echo “Checa se existe uma conexáo aberta…”
if [ "$porip" -gt "0"  -o "$porname" -gt "0" ] ; then #compara se tem conexão aberta por IP ou por reverso do IP
#echo “Ja esta conectado…”
sleep 1
else #caso não tenha conexão aberta, nem pelo IP nem pelo reverso do IP, abre uma nova conexão
#echo “Conectando…”
screen -wipe #remove as screen mortas
screen -r sshreverso -X quit #mata a screen antiga
screen -AmdS sshreverso ssh -R ${porta}:localhost:22 ${login}@${ipremoto} #abre uma nova  screen com o SSH REVERSO
fi
#echo “durmindo por $dorme segs…”
sleep $dorme #espera o tempo até a próxima checagem
done
} &

Bom tentei comentar ao máximo o que o script faz.

Outra coisa eu coloquei o link pra meu server com meu “myip.php” se você tem seu próprio server e quer por um “myip.php” segue o conteudo do “myip.php” :

<?php $ip=$_SERVER['REMOTE_ADDR']; echo $ip; ?>

Só isso gente espero ter ajudo em algo

Qualquer dúvida mande-me um e-mail nos meus dominios:
@halfling.com.br
@charlegoncalves.com.br

Como de costume, comprei a coleção completa do homem de aço, um clássico desde os tempos do Christopher Reeve e estava com problemas de reprodução.

Simples, instale o kubuntu-restricted-extras, certo?

Quase..isso é a metade do trampo….para reproduzir dvds protegidos precisamos da libdvdcss2, que agora não se encontra mais no instalador de pacotes.

Para isso, instale (se o restricted-extras não instalou) o pacote libdvdread4

e depois

sudo /usr/share/doc/libdvdread4/install-css.sh

Aproveite e instale o SMPLAYER

É isso, curto, direto ao ponto!

yo! Como está difícil conseguir 2 discos rígidos do mesmo tamanho, mesmo comprando o modelos iguais no final eles são diferentes! Desse modo, fazer raid 1 com geom mirror do disco inteiro como mostra no handbook é impossível. Depois de adquirir 2 discos Samsumg e 2 Western Digital de 500Gb para no final descobrir que eles tem o número de blocos diferentes, eu resolvi tomar uma abordagem diferente e fazer o gmirror do slice, assim não importa o tamanho do disco, apenas o tamanho do slice que é controlado pelo sysadmin.

Existem dois jeitos mais comuns de se fazer isso. O primeiro é com o sistema offline através do Fixit e o segundo é online, criando o raid1 no disco vazio e depois migrando os dados para ele.

A vantagem do primeiro é que é mais rápido o processo todo, pois não é necessário replicar os dados no segundo disco e a desvantagem que vejo é que o sistema precisa ficar offline por cerca de 10 minutos, tempo mais que suficiente para criar o raid1.

Read more…

Olá a todos, estava tentando instalar o driver da ATI no meu notebook de mesa, no qual chamo carinhosamente de tenebroso (é um P3 – 850 com 256 MB e 20 GB de HD), instalei o driver,  mas quando reiniciei tive uma triste mensagem que não podia carregar meu Xorg, que coisa linda!

Bom como havia feito o backup do meu arquivo xorg.conf, pensei é só copiar e reiniciar. Fiz isso mas não fui muito feliz, pesquisei um pouquinho e descobri como restaura o xorg e vou postar como fiz…

Primeira passo remova seu xorg

# aptitude purge xserver-xorg

Segundo passo instale novamente

# aptitude install xserver-xorg

Depois de instalado, demorou alguns minutos aqui, mas creio que você consiguirá instalar mais rapido. Execute este comando.

# Xorg -configure

Este comando segundo a pesquisa que eu fiz, configura seu xorg com configurações padrões. E tem esta configuração sugerida pelo Debian:

# dexconf

Depois de tudo isso reinicie sua máquina para terminar a restauração, se deu tudo certo irá entrar na sua tela de login.

Bom é só isso e até a próxima!

Pessoal,

Estou divulgando aqui o compilador MASM32 para windows.

( Ref: http://www.masm32.com )

Ele possui umas features interessantes que o tornam muito bom para fazer programas minúsculos.

Tenho um exemplo de programa que é um backdoor para Windows feito pelo WhiteScorpion ele roda na porta 31337.

Este Exemplo é apenas para ilustrar o compilador dá pra ver as features do MASM32 pois é em um programa bastante simples e pequeno que usa recursos de TCP/IP.

Uma das coisas interessantes no MASM32, é que ele implementa um conjunto de pseudo instruções que facilitam muito a vida do programador.

Em Assembly, normalmente, você tem que criar os IFs, criar os WHILEs e todas as estruturas de loop e de condicionais de forma artesanal escrevendo tudo na unha usando as instruções e flags do processador..

Mas as pseudo instruções do MASM32 criam tudo isso para você e sem stress.

Vejam:

.IF eax==SOCKET_ERROR

    invoke WSACleanup

    invoke ExitProcess,eax

.ENDIF

Ele já cria a comparação para o registrador eax sem você ter que esquentar a cabeça. E olhe este WHILE:

.WHILE bytesRead>=1023

        invoke ReadFile,readout,addr bufferout,1023,addr bytesRead,NULL

        invoke lstrlen,addr bufferout

        invoke send,remsock,addr bufferout,eax,0

        mov eax,offset bufferout

        mov ecx,sizeof bufferout

zeromem2:

        mov byte ptr [eax],0

        inc eax

        dec ecx

        test ecx,ecx

        jnz zeromem2

.ENDW

Ele ainda entende os sinais de >,<.>=<= e != . Sem você ter que fazer isso tudo na unha.

Muito mais simples, não é mesmo ?

Qual a vantagem de usar Assembly e não usar um C por exemplo ?

Programas minúsculos, conhecimento do sistema maiúsculo e é muito mais sexy.

Todas as pseudo instruções são precedidas de ponto e dá pra criar macros ainda mais complexas.

Vocês podem pegar o programa exemplo que inclusive é funcional e tem os binários já compilados em: http://www.koflinux.com.br/backdoor.zip

A última e mais polêmica coisa sobre o MASM32 é que o autor é avesso ao GPL. Apesar do MASM32 ser freeware e você puder usa-lo como te der na telha. O autor NÃO quer que se produza programas sob a GPL usando o compilador.

Ah, ia me esquecendo, o programa exemplo que eu passei como exemplo está sob a GPL …

Vejam o que é dito no site do cara:

Exclusion of open source projects and software.

The MASM32 project cannot be used to create open source software or any other project under any form of licence that requires the user of the MASM32 project to surrender the rights they are afforded under the MASM32 licence. In particular the MASM32 licence completely excludes projects licenced under the GNU organisation’s published GPL licence and/or variants.

Em C não se pode criar variáveis no meio do programa.
Deve-se que cria-las somente no início das funções, Certo ?
Errado !

Isso é para Pascal que é amarrado, em C você pode criar as variáveis onde quiser.
Só precisa de um bloco de código que inicia co ‘{‘ (abre chaves) e termina com ‘}’ (fecha chaves).
Ou seja vc pode colocar entre um for(…){ }  entre um while(…) {  } ou até entre um bloco de programa composto apenas de ‘{‘ e ‘}’ …

Assim são válidas as seguintes formas de criar variáveis:

// estude com cuidado este exemplo pois os whiles tem pontos que podem causar bugs lógicos terríveis
//fique atento.
#include <stdio.h>

main(){
        int z=0;
        // neste while o x é zerado toda vez que dá loop
        while(z<=3){
                int x=10; // o valor de x volta a ser 10 noloop.
                printf("x somente existe neste bloco (x=%d)\n",x);
                x++;
                z++;
        }

        // neste while o x não é zerado.
        z=0;
        while(z<=3){
                int x; // o valor de x não é zerado no loop.
                if (z==0) x=0;
                printf("x somente existe nste bloco (x=%d)\n",x);
                x++;
                z++;
        }

        {
                int i;
                for(i=0;i<10;i++){
                        int y=0;
                        printf("i:%d y:%d\n",i,y);

                }
        }
}

Só uma coisa depois do ‘}’ fecha chaves o programa desconhece a variável, ela só vale para dentro daquele bloco. ou seja, é uma variável local do bloco e se for referenciada fora do bloco trata-se de OUTRA variável e não a mesma.
Por exemplo:

#include <stdio.h>
main(){
        int x=10;

        printf("x vale:%d\n",x);

        {
                int x=123;
                printf("x vale:%d\n",x);
        }

        printf("x vale:%d\n",x);
}

Nesse exemplo o x vale 123 somente dentro do bloco onde ele é referenciado, fora ele vale 10... o resultado pro programa é:
x vale:10
x vale:123
x vale:10

Também deve-se observar que dentro de um loop se declaramos um valor inicial á variável este valor inicial é novamente carregado na variável assim que ocorrer o loop.
Isso não deve ser esquecido (ler primeiro exemplo de código com cuidado).

Imagine agora que você tem um programa com uma função que é pequena e você só usa uma vez. e você quer refatorar e colocar esta função dentro do programa principal.
Basta copiar o conteúdo da função dês do ‘{‘ até o ‘}’. Não tem que mover as variáveis locais para fora nem nada disso. Somente tem que passar os parâmetros de outra forma mudando o nome das variáveis de parâmetro para os valores ou variáveis do programa principal.

Esite um outro uso: Alguns trechos do programa exigem variáveis que somente serão usadas naquele lugar. Então não é necessário declarar as variáveis lá no inicio da função ou como global. Você pode declarar dentro do bloco local. Isso é bom para usar a memória somente quando necessário.