2012

Como programadores matariam um dragão e salvariam a princesa

Há muitos anos virou moda na internet classificar gêneros, do que quer que sejam, através da maneira na qual chegariam em um castelo, matariam um dragão e salvariam a princesa.

Um belo exemplo disso é o que tem no site Whiplash, sobre os diferentes tipos de metal:
http://whiplash.net/materias/humor/000593.html

Vamos ver como os programadores matariam os dragões...

Nostalgia tecnológica

ICQ, mIRC, barulho do modem 56k conectando...lembra?
Então confira a melhor tirinha já feita.

Quanto ganha um programador?

E um analista? E desenvolvedor? Administrador de redes?

Se a função de cada um já é confusa, imagina pra saber o salário.
Segue um post para você se informar melhor sobre comparação salarial, CLT x PJ e outras utilidades.

E se as linguagens de programação fossem jogadores de futebol?

Em que posição cada linguagem iria jogar?
Seria um craque, estaria fora de forma ou um nato goleador...?

Faxineiro da Microsoft

Não sei bem a origem, provavelmente é mais uma piada/trollagem que roda pelos e-mails do mundo, mas vi no site Eu faço programas.

Embora seja uma piada, tem um cunho filosófico por trás...

Vida de programador

Pretende ser programador ou trabalhar na área?

http://www.vidadeprogramador.com.br

Se prepare para ouvir coisas do tipo de sua família, namorada(o), amigos...

Richard Stallman em Goiânia

Recebi um pedido de divulgação do 9º Fórum Goiano de Software Livre - FGSL, que acontecerá nos dias 31/11 e 01/12/2012.

Terá a participação mais que especial do Richard Stallman, criador do movimento free de software, do projeto GNU, da Free Software Foundation e ainda é ateu.

Uma das figuras mais importantes na criação e existência do Linux estará no Brasil, em Goiânia.

Quem puder ir, não perca essa oportunidade!

Mais informações em: http://fgsl.aslgo.org.br/fgsl/

Engenharia de Telecomunicações: o que é, o que estuda, para que serve, área de atuação, o curso acadêmico e mercado de trabalho

Engenharia de Telecomunicações

Este artigo tem por objetivo falar sobre o curso acadêmico, ramo profissional e mercado de trabalho relacionado com a Engenharia de Telecomunicações, que lida diretamente com tudo que está relacionado com o ramo da tecnologia da informação, incluindo a programação.

De uma maneira mais simples e específica: o ramo das telecomunicações é o responsável pela comunicação existente entre os mais diversos tipos tecnologias.

A diferença entre programadores bons, ruins e convencionais

Encontrei em um blog - Aureliano Martins - um texto que fala sobre a diferença entre programadores bons, realmente bons, ruins e os convencionais.
É uma versão traduzida do original, que é de David Veksler e foi postada sob o nome de Some lesser-known truths about programming (Verdades pouco conhecidas sobre programação).

Tecnologia? Avanços Científicos? Maravilhas do Mundo Digital? Não, obrigado. É programação mesmo.

Quem nunca pensou em ser médico? Salvar vidas, ajudar as pessoas, melhorar a qualidade de vida dos outros. Muito nobre.

Ou defender os pobres? Fazer justiça? Empregar a Lei e lutar por um país mais digno onde todos possam ter seus direitos garantidos? Quem não se revolta com as injustiças?
Quem não queria ser Advogado?

Que tal desenvolver o país? Obras, estradas, estádios, vilas olímpicas?
Saúde e justiça são essenciais, mas só se cresce com obras.
Quem não quer ser Engenheiro?

E quando olhamos pro lado e vemos os computadores, celulares, equipamentos médicos, aviões, GPS, iPhones, complexos sistemas de computação e robóticas ajudando pessoas, ou quando usamos a Internet para obter qualquer informação, o que pensamos?
Em programar? Não.
Em desenvolver projetos com Hardware? Não...Pensamos em...

Linux: Livros sobre Open Source

Série de livros sobre Open Source, GNU, Richard Stallman e outras coisas relacionadas ao Linux.

Alguns são informações biográficas, outros mais técnicos, seja no aspecto de desenvolvimento ou sobre a questão de licença e aspectos legais, mas todos relacionados com o mundo do Software Livre.

Todos gratuitos, claro.

O incrível algoritmo de Iam Laz

Tá precisando? O Iam resolve!

Seção Humor

Quem frequenta comunidades e fóruns sabe o quanto é comum gente pedindo pra fazer suas tarefas.
Não pedindo ajuda, pedindo pra resolver seus deveres mesmo.

Alguns chegam ao absurdo de copiar e colar as questões com quantos pontos vale cada uma, não agradecem e nem voltam ao tópico.

Já ajudei e me estressei muito. Tá na hora de curtir:

Clusters: definição, características e diferenças em relação ao grid

Definição:

São vários computadores, trabalhando junto em um único objetivo, de uma maneira próxima (tanto fisicamente - como em uma sala -, como na maneira que estão conectados por software), e em uma rede de alta performance.

Computação em Grade (Grid Computing): A Evolução dos Sistemas em Redes

Muito se fala em desperdício de energia, água, poluição dos mares e desmatamento de florestas...mas ninguém notou que estamos desperdiçando processamento de dados, armazenagem, hardware, banda de internet, dentre outros recursos.

Não acha isso muito importante? Essas coisas 'nerds' não são tão sérias e graves como as relacionadas com meio ambiente?

Saiba que, com os recursos que estão sendo desperdiçados, poderíamos usar para prever catástrofes climáticas, ajudar pesquisas no combate ao câncer ou Aids, dentre milhares de outras pesquisas científicas que afetam diretamente você.

Com as noções de Computação Distribuído do artigo anterior, e sobre Grid desse artigo, vou te mostrar o motivo de nosso sistema de internet ser tão obsoleto e o saiba porque o Grid é um sistema evoluído de rede.

Computação Distribuída: Introdução e exemplos de uso

Sistema distribuído é uma porção de computadores, todos conectados em rede, coordenados por uma, ou mais, máquina(s) administradora(s) e que utilizam softwares que permitam o compartilhamento de seus recursos, como memória, processamento, hardware (como impressora etc) para um único fim, como quebrar um código, criptografar ou descobrir a melhor solução de um problema em matemática.

Ou seja, são vários computadores, que se comportam como um só, para fazer uma coisa de uma maneira rápida e eficiente, ou ter muito espaço de armazenamento.

São sistemas muito usados em supercomputadores, que fazem pesquisas científicas, predições climáticas, descobrir novas partículas, controlar epidemias e outras doenças, fazer simulações e tudo...foi-se o tempo que ciência era feita no papel, lápis e laboratório.

Saiba por que o mundo depende da computação distribuída, e por que sistemas distribuídos são a evolução da Internet.

Linux: permissão de leitura, escrita e execução de arquivos e diretórios - os comandos chmod, chown e chgrp

Um dos maiores motivos de segurança nos sistemas do tipo Unix, como o Linux, são o modo como arquivos e diretórios podem ser acessados.

É tudo bem dividido entre owner (dono), grupos e outros usuários.
Uns podem ler, outros escrever e apagar, outros executar...

Sabendo e usando isso terá um total controle do sistema, além de entender um pouco o motivo do Linux ser um sistema tão seguro e flexível.

Curso de Java Online e Gratuito

Apostila de Java

Se está aqui, fez uma sábia escolha e optou por estudar Java!

Caso seja totalmente novo na área de programação, indico a leitura da seção Comece a Programar.
Para saber melhor o que é, para que serve, onde é usado e outras informações sobre Java, clique aqui.

No mais, aproveite o curso. É uma promissora linguagem. Sabendo Java, oportunidades não faltam.

A ordem indicada para o curso completo é a seguinte:

Segurança Digital: Criando Certificados Digitais com o OpenSSL

Chega de teoria!

Agora que você sabe o que é um certificado e sua relação com criptografia/chaves públicas e privadas, como funcionam e para que servem, está na hora de fazer um com suas próprias mãos.

Segurança Digital: Certificados Digitais, o que são e como funcionam

Quando você faz uma compra em uma loja você recebe a nota fiscal, você vê a loja, os vendedores, conhece ela, conhece quem compra, ela faz propaganda em mídias conhecidas...isso tudo certifica você sobre sobre a autenticidade da loja, que ela é confiável.

E na Internet? Como você sabe quem está por trás daquele site ou daquele serviço? Como confiar? Como as grandes empresas confiam uma nas outras?
Neste artigo falo a respeito do Certificados Digitais, que é o meio que as pessoas, empresas e serviços usam para se 'reconhecer' como confiáveis na rede!

Segurança Digital: Chaves Públicas e Privadas, como funcionam? Para que servem? Como usá-las?

Ter só uma chave, seja da sua casa ou de arquivos e certificados digitais é dor de cabeça.
A ideia por trás das chaves é de milhares de anos, e até César já se envolveu com criptografia, mas sua ideia é 'boba' e insegura demais pra ser usada hoje em dia.

Aprenda como usar chaves públicas e privadas, o que são, como são usadas, para que servem e através de exemplos simples veja como proteger suas informações e seus dados.
São ideias geniais!

Segurança Digital: Criptografia assimétrica e a importâncias das chaves

Poder contar algo a alguém e ter a tranquilidade que ninguém vai saber é o sonho de muita gente, inclusive de grandes reis, militares, países, antigos reinos, do FBI, políticos...como ouvir o segredo alheio é o sonho de muitos espiões e hackers.

Criptografia, senha, segredos...sempre foi e sempre serão assuntos que despertarão curiosidade.

Redes e Internet: Atrasos e Perdas de Dados

Por que a Internet caiu? Por que o arquivo veio danificado?
Por que não criam programas sem erros?
Como funciona isso? Tem como melhorar?

Pra você que não se contenta em reclamar, mas quer saber como funciona a Rede mãe e quer saber por que ocorrem os erros e perdas de dados, aprecie e entenda, pois reclamar sem saber é pros tolos!

Microsoft libera livros grátis para Download

Já imaginou se a Microsoft liberasse seu material de estudo?
Já imaginou se soubesse qual livro, apostila, curso seus funcionários usam?
Ou se conseguisse seus aplicativos de forma gratuita pra usar em casa ou na sua empresa, free mesmo, sem piratear?

APROVEITE! DEU A LOUCA! ELA LIBEROU!
E material de excelente qualidade!

Clique, confira a lista e baixe os livros!

Redes e Internet: Centrais e Servidores de Rede

Já parou pra pensar como as músicas, vídeos e e-mails que você vê na Internet chegam até você?

Por que chegam até você e não pro seu vizinho? Por que chega até você e não ao seu tablet ou ao computador de seus pais, já que estão tão próximos?

Com bilhões de computadores, iPhones, iPads e notebook conectados, as coisas não se embaralham?

Será que alguém não dá uma 'espiadinha' pelo meio do caminho?

Se você sempre teve essas e outras curiosidades, continue lendo. Explicarei alguma destas e mostrarei o caminho que as informações percorrem (visualmente, inclusive), até chegarem em você.

Não se surpreenda ao ver que os dados passam pela China, India e outros países antes de chegar até você ;)

Redes e Internet: Introdução & Protocolos

Tudo em Redes e Internet funciona à base de Protocolo.
Pra fazer um download, tudo obedece um protocolo.
Pra mandar um e-mail...protocolo.
Regras e vigências pra acessar o Facebook do seu trabalho, através de protocolo.
Como seu cahorro se comunica com você? Através dos mesmos protocolos.

Entenda como as Redes, e o mundo, se comunicam por meio de protocolos.

Comece a programar: A Linguagem de Programação C

O kernel, que é a base (ou miolo ou talo do sistema) de todo sistema operacional, é feito C.
Os drivers, que fazem tudo funcionar em seu computador, são feitos em C.
Os programas mais essenciais e que mais exigem desempenho são feitos em C.

Equipamentos eletrônicos, chips, microprocessadores e eletrodomésticos de nossa casa tem C no meio.
É e a linguagem mais usada, mais importante e muito provavelmente você não conhece ninguém que programe em C. Como pode?

O que é linguagem C? É difícil? Ainda se usa? Como começar a programar em C? Meu amigo disse que é ultrapassada e morta, é verdade? Ainda vale a pena estudar? Que programas são feitos em C? Onde se usa a linguagem C?

Comece a programar: A Linguagem de Programação Java

Portabilidade, sabe o que é? É programar em Windows, Linux, no Mac, pra Web, pra celular, em uma pedra...sem se preocupar com compatibilidade. Como é possível?
Compatibilidade é o que mais atormenta os programadores!

Muito simples, Java não roda no computador! Roda em uma máquina virtual!

O que é o Java? Como surgiu? Para que serve ? Onde posso utilizar? Que programas conhecidos são feitos em Java? É verdade que Java é só moda? Programar em Java é emprego garantido? É a mais fácil? Por que todo mundo tá estudando e falando de Java?

Comece a programar: Que linguagem estudar

- Quais são as linguagens disponíveis? Quais devo estudar? Para que cada uma serve? Qual paga melhor? Qual a mais difícil e qual a mais fácil?

Quais linguagens de programação Qual linguagem Paga mais

Que linguagem de programação estudar ?

C, Java, Assembly, C++, C#, Visual Basic, PHP, Python, Perl, Ruby, JavaScript, Delphi/Object Pascal, Lisp, SQL, VB.NET, Pascal, Ada, Lua, MATLAB...e a lista não para por aí. Nesse momento devem estar criando mais alguma linguagem.

Ao ver tantas letras, palavras e símbolos temos as mais diversas reações:
"Por que?"
"Pra quê?"
"Ah, [nome do seu amigo] disse que [escolha uma linguagem] é a melhor"
"Eles não tem o que fazer?"
"Preciso aprender tudo?"
"Meu amigo manja Java e faz tudo, óbvio que só preciso de Java"
...

Primeiro, calma. Ninguém precisa aprender todas.
E se aprendeu, aprendeu por curiosidade, pois não deve ser 'fluente' em nenhuma.
Todas tem seu propósito e utilidade específica.

De cara, vamos logo quebrar um mito:
A linguagem [escolha a linguagem da moda] não é a melhor, nem mais importante. Nem nunca vai ser. Simplesmente porque isso não existe.

Atualmente a linguagem da moda, ou mais famosa, é o Java. Sim, é a mais em alta.
Mas nunca fama foi sinônimo de 'melhor'.
(Ainda bem, pois Justin Bieber é o cantor mais famoso e Restart a banda mais famosa).

Profissionalmente, a faca também tem dois gumes. Se souber Java, dificilmente ficará sem emprego. Porém, em todo quarteirão tem alguém que sabe Java, o que, no geral, deixa baixo o salário dos programadores Java. Se quiser ganhar bem em Java, tem que saber mais que a maioria (na verdade, em qualquer ramo da vida é assim).
Existem poucos programadores COBOL, é uma linguagem quase em desuso, e também existem poucos programadores de C (não é muito pop e um pouco 'cascuda', pra não dizer difícil), mas quem dominar essas linguagens, tem seu lugar ao sol, com um bom salário.

Java vem revolucionando o mercado por conta da portabilidade.
Programar em Windows é diferente de programar em Linux, que é diferente de programar em Mac, do que num Iphone, do que num Ipad, Ipod, aipim...a maneira de escrever é diferente, os códigos são outros. Há muitas variações.
A genialidade do Java reside que você escreve uma vez, e ele roda em qualquer lugar. Pois ele não roda no computador/aparelho/arquitetura. Ele roda numa máquina virtual, a Java Virtual Machine, a JVM. Que bom né? Por que todos não fazem isso?

Tudo tem seu preço. O preço dessa ideia fantástica da JVM é o rendimento. Fica lento. É pesado. Demora mais mesmo.
Um código que roda em Java em alguns segundos, pode levar alguns milisegundos para rodar em C.

Ora, escrevamos em C!
Ok! Mas vai ter que fazer alterações para rodar em Windows, Linux, Mac, Mobile...e agora? Qual programar? Qual a melhor?

Não tem melhor. Simples assim.
Linguagem de programação é igual a religião ou time, é uma coisa pessoal. Não se discute. Não há melhor nem pior, é uma questão de escolha, ambiente, propósito, influência.

Dizer que é PHP é mais importante que C++ é dizer que Engenharia é mais importante que Medicina. Ou que maçã é melhor que banana. Não faz sentido. Não se compara. Como será mostrado nos artigos que virão, cada linguagem tem seu propósito. Cada uma foi criada visando um nicho específico, para tratar determinados tipos de problemas.

Se ouvir alguém na internet ou pessoalmente, dizer ou se exibir, dizendo que essa linguagem ou aquela é melhor, desconsidere. É um amador, um ignorante, alguém sem noção ou um adolescente que começou agora a programar e quer atenção. Se quiser, me mande o que ele disse que te digo uma pergunta pra você perguntar pra ele que o fará se calar. Qualquer que seja a linguagem que ele disser ser melhor.

Mais uma vez, pra ficar claro. Não existe melhor ou mais importante linguagem. Existem linguagens mais apropriadas pros mais diversos tipos de problemas/situações. Somente isso.

Escolha o que você quer. Escolha seu ramo. Já decidiu o que quer? Leia, veja os artigos da série Come a programar, se informe bem e depois mergulhe fundo no que quer, estude bastante.

É complicado generalizar. Não leve muito a sério a seguinte recomendação.
Não por estar errada, mas por ser superficial.
Ela serve somente para guiar você sobre quais linguagens/ferramentas/tecnologias você deve estudar para atingir seus objetivos.

Criar aplicações para Windows: C# e tudo .NET ; Java
Criar aplicações para Linux/Unix: C ; Java
Criar aplicações para empresas e estabelecimentos comerciais: Delphi ; Java
Criar jogos de alto rendimento: C++
Criar jogos para Web: Java e Flash
Trabalhar com Hardware: chips, microprocessadores, microcontroladores: Assembly e C
Criar sites e funcionalidades para tal: PHP, JavaScript, (X)HTML/XML
Banco de dados: SQL, MySQL, PostgreSQL
Redes/Administração de redes: Perl, linguagens de script, Linux!
Uso pessoal (serve pra todo mundo): Python, Perl, Shell Script e outras linguagens de script
Tudo relacionado a tecnologia e programação: Linux! Use Linux! Sempre aprenda sobre Linux!

Mesmo depois de escolhido seu ramo e tendo seu emprego, continue estudando. Sobre sua área e sobre outras.
Nunca, jamais se limite.
Aprender uma linguagem nunca é inútil. Você aprende a pensar diferente.
A cada linguagem aprendida sua mente passa a pensar diferente, você se torna um programador melhor na linguagem X se aprendeu a Y. Terá mais ideias, a mente mais ampla e mais flexível.

Visando essa constante informação e aperfeiçoamento de todos, essa seção do blog estará sempre sobre constante atualização.
Sobre linguagens, ferramentas, tecnologias, paradigmas(estrutura de blocos, procedural, orientação a objetos, computação distribuída, funcional), programação linear, modular, estruturada, OO, sobre o processo de interpretação, compilação, linkagem etc.

Porém, não se assuste com esse excesso de informações. Faz parte da área.
Primeiro, pela importância e pela abrangência dela. Está em todo canto. Se usa em todos os lugares e o crescimento da área é simplesmente absurdo, está crescendo mais que o mundo é capaz de suportar.
Segundo, você deve gostar disso. Se continuar estudando essas tecnologias e programação te incomoda ou te chateia, considere mudar de profissão.

A leitura sobre todos essas linguagens, nas suas mais específicas características, tipos e processos, é altamente recomendada.

Apache Ant: O que é, Instalando e configurando de maneira simples no Linux

Sobre

Apache Ant é uma ferramenta poderosíssima e muito útil, feito em Java para a construção de aplicativos. É um projeto da já famosa Apache Software Foundation, e é, obviamente, Open Source.Quem já está acostumado com a dupla make/makefile do GNU/Linux, é correspondente.Mas estamos em tempos de portabilidade e não podemos ficar preso nem que seja ao nosso maravilhoso sistem Unix.

O Apache Ant é pra isso, construir. É um build multi-plataforma, extremamente útil e poderoso.Ele vem com uma série de recursos, para compilação, assembler, teste e para rodar aplicações Java.Porém, ele não se limita só a Java, pode-se também construir e testar aplicações de outras linguagens, como C ou C++, por exemplo.

A sua vasta opções de de bibliotecas, a antlibs, falam por si e definem sua versibilidade, não me deixando escrever sobre as milhares de utilidade do Apache Ant.

The Apache Ant Project

Instalando o Apache Ant

Escolha sua versão binária em: http://ant.apache.org/bindownload.cgi

1.Descompacte

2.Para prosseguir na instalação, precisemos usar as variáveis de ambiente do java e da pasta que você descompactou o Apache Ant, por isso descompacte em um local que saiba onde vai ficar e que não vá mexer nele depois.

3. Abra o terminal (BASH) e exporte, com os comandos:

export ANT_HOME=/usr/local/apache-ant-1.8.4
export JAVA_HOME=/usr/lib/jvm/jdk1.7.0
export PATH=${PATH}:${ANT_HOME}/bin

No caso, mostrei onde estava minha pasta do apache ant e minha jdk.
Você não é obrigado a instalar nesta pasta, /usr/local, mas é recomendável, é meio que o padrão para softwares que ficarão acessíveis aos usários do sistema. Assim, todos podem usar.

4. Após feito isso, vá na pasta do ant.
Você pode fazer isso diretament com o comando: cd $ANT_HOME

5. Agora você irá checar e fazer o download de uma série de dependências (bibliotecas) que o Ant irá usar. Faça isso com o comando:
ant -f fetch.xml -Ddest=sys

O processo é automatizado.

Você pode adicionar mais bibliotecas manualmente em: http://ant.apache.org/antlibs/proper.html

Após tudo isso, vamos checars e a instalação ocorreu bem. Digite o seguinte comando no terminal:
ant

você deve obter um resultado parecido com este que eu tive:
~/Documents/apache-ant-1.8.4$ ant
Buildfile: build.xml does not exist!
Build failed

Mas calma, óbvio que o build falhou, pois não especificamos nada para construir.

Agora cheque a versão do ant:

ant -version

Aqui obtive isso:

Apache Ant(TM) version 1.8.4 compiled on May 22 2012

Para que estes comandos tenham efeito permanente, adicione estas três linhas ao seu .bashrc:
sudo gedit .bashrc

E cole lá.

Comece a Programar: O que são Linguagens de Programação?

O que são Linguagens de Programação? Preciso aprender para programar? São difíceis?

Comece a Programar: Obtenha todas as informações para começar a programar

Como começar a programar

São poucos os que se perguntam coisas do tipo:
"Como funciona um computador?",
"Como se criar um sistema operacional?",
"Como fazer um site?"

Os que se perguntam, rapidamente ficam sabendo que a base de tudo é a programação, que é necessário saber uma porção de códigos chamados linguagens de programação.
Com um pouco mais de pesquisa e curiosidade, se percebe que não é algo óbvio e fácil.
É preciso ter vontade de estudar, querer aprender e se esforçar bastante.

Para quem desejar iniciar essa empreitada, vamos responder algumas perguntas:

Quer começar a programar e não sabe por onde começar?

Não sabe que material estudar?

Não tem dinheiro pra comprar livros?

Não tem tempo para cursar uma faculdade ou curso?

Esta seção foi feita exatamente para isso.
O intuito desta parte do site é informar sobre o que é programação, sobre as linguagens e qual delas você deve buscar informações e começar a estudar para atingir seus objetivos.

Introdução
O que é Programação ?
O que são Linguagens de Programação ?
Que linguagem estudar ?
- Java, a portabilidade -> Curso de Java Completo: Java Progressivo
- C, a linguagem mãe -> Curso de C Completo: C Progressivo
- HTML & CSS: Como criar sites -> Curso de HTML e CSS: HTML Progressivo
- C++ e programação de Jogos de alto desempenho
- Objective-C: Invista na Apple, invista no futuro
- C#, a portabilidade da Microsoft e o mundo .NET
- Assembly, a verdadeira linguagem de computador
- Visual Basic
- PHP
- Python
- Perl
- Ruby
- JavaScript
- Ruby
- Delphi / Object-Pascal
Como não ser um bom programador - Erros e péssimos hábitos que você deve evitar

Dentre as profissões/cursos universitários que usam direta ou indiretamente a programação, podemos citar:

Quem tem um blog, um site ou simplesmente é envolvido com qualquer área referente a tecnologia da informação, TI, é constantemente bombardeado por perguntas e dúvidas, algumas bem estranhas, vindas por e-mail ou pessoalmente mesmo, de pessoas leigas e interessadas.

Essas perguntas geralmente são:

Como programar ?
Que linguagem começar? Qual delas é a melhor? Preciso aprender todas?
O que é o Linux? Ele morde? Por que não tá no meu menu 'Iniciar' ?
Quanto vou ganhar? Fico mais rico que o Bill Gates antes dos 18 anos?
É difícil ?
Como começar?
Isso é só pra gênio?
Tem que nascer com esse dom?
Só os hackers programam?
Se eu começar hoje, consigo invadir a NASA até sexta? Tenho que viajar final de semana
Tem que ser muito inteligente?
Posso criar uma nova versão do Quake, World of Warcraft e Counter-Strike em quanto tempo?
Ainda posso ter vida social? [não]

Esta série tem por objetivo esclarecer estas dúvidas, sobre o que é programação, como começar, por onde começar, por onde seguir, o que precisa estudar pra fazer isso, aquilo.

Você verá o que deve fazer para atingir seu objetivo, pois desde já adianto que você deve escolher o que quer fazer para seguir em frente, pois é uma área muito ampla e não dá pra estudar tudo.

Sim, estudar. Você vai ler muito essa palavra, se acostume ou vá jogar futebol.

Tem que gostar muito, ou ter um mínimo de interesse na área.
Se for pelo dinheiro ou fama (querendo aparecer no noticiário da globo ['hacker invade site da NASA']) você simplesmente não vai conseguir.

É uma daquelas coisas que, por conta dos percalços, se faz por paixão.

Não é difícil, só exige esforço e dedicação. Não é um bicho de sete cabeças, pelo contrário, é a coisa que mais faz sentido na vida.

Se houver erros, foi porque você errou.

Vai depender única e exclusivamente de sua dedicação, raciocínio e criatividade. Você não precisa ser rico, bonito, gostoso(a), branco, negro, magro, gordo ou famoso. É algo bem democrático.

O que é possível fazer com programação é simplesmente fascinante e sem limites.
Olhe ao seu redor e me diga o que é eletrônico e/ou digital. Pronto, tudo isso foi programado.
Quanto mais tecnológico fica o mundo, mais se precisa de programação e programadores.

Não tem mais dúvidas? Então aprenda como programar

Reserve um tempo, um computador. Se puder imprimir, para ler depois, melhor ainda.
Não existe motivo melhor ou pior para programar, cada um com seus meios e fins, seja ĺá qual for, como: criar games, sites, aplicativos pra desktop (programas 'normais'), para mobile ou Apple/Android (iPhone, iPad), trabalhar com redes, segurança ou simplesmente porque acha interessante.
Mostrarei como escolher seus objetivos, suas linguagens, programas para compilar/interpretar seus códigos, editores de textos, IDE's e material para estudo.

Se lembre, você vai aprender uma linguagem.
Lembra quando aprendeu o português? O alfabeto? As vogais? Foi formando as sílabas?
Pois é, é desse mesmo jeito...aos poucos. Mas depois você já vai ser capaz de escrever e criar o que vier a sua mente. Alguns criam coisas de qualidade, outros não. Outros criam coisas criativas, outros só copiam. É o mesmo em programação.

Espero que goste e que toda esta orientação lhe seja útil.
Bons estudos.

Comece a Programar: O que é programação?

De uma maneira simples, programar é criar uma série de instruções.
Todos os dias pela manhã você se programa para ir ao trabalho/escola/faculdade: acorda, escova os dentes, toma o banho, café e sai.
Essa é sua programação, é seu conjunto de instruções.

O computador é da mesma maneira. Para ele fazer uma determinada tarefa e atingir um objetivo, ele precisa de um conjunto de instruções.

Comece a Programar: Introdução

Java: Class Scanner ( a classe Scanner) - Lendo e Recebendo dados de arquivos

Agora que já escrevemos dados em um arquivo, vamos aprender como ler dados de um arquivo existente em disco.

Java: Class Formatter ( a classe Formatter ) - Escrevendo em arquivos

Já vimos como obter informações sobre arquivos e diretórios, através da classe File, agora vamos realmente criar um arquivo que nos permita manipular informações de texto na forma sequencial.

Java: Class File ( a classe File ) - Obtendo informações de arquivos e diretórios

Objetos dessa classe irão servir para objetos de outras classes da java.io package.
Usamos ela para obter informações SOBRE o arquivo ou diretório/pasta, e não sobre seu conteúdo.

Java, Usando Arquivos (Files): Introdução

Até o momento, em nosso curso, armazenamos dados em variáveis e arrays. Porém estes são temporários e se perdem ao término de cada aplicação.
Agora veremos como armazenar e ler dados, que podem ficar permanentemente em dispositivos de armazenamento, como seu HD.

Java: Expressões Regulares (regex) em Java

Também conhecidas como regex (regular expressions), expressões regulares são sentenças com códigos que podem representar uma string, de forma genérica.
Por exemplo, o CEP é da forma: ddddd-ddd
Onde 'd' é um dígito qualquer, entre 0 e 9. Essa expressão representa toda a gama de CEP's em nosso país.

São usadas também para a criação de compiladores, através de expressões regulares bem complexas, que podem representar qualquer trecho de código, e acusar erro de sintaxe, caso o código escrito não case com as expressões regulares.

Em nossos aplicativos, usaremos expressões regulares para garantir que a entrada de dados esteja sob uma forma específica.
Por exemplo, caso necessitemos que o usuário digite um CEP e ele escrever:
dddd*-ddd

O que ele digitou não vai casar com a expressão regular que usamos para validar o CEP, pois o número de CEP não aceita asterisco.
As expressões regulares são uma ferramenta bem antiga, usada desde a época do Unix, e é usada nas mais diversas linguagens de programação, como em Perl, e em programas, como o sed.

Vamos a alguns exemplos:
\d -> representa qualquer dígitos
\D -> representa tudo, menos dígito

\w -> representa qualquer caractere de palavra
\W -> representa tudo que não seja um caractere de palavra

\s -> representa qualquer espaço em branco(" ", tab)
\S -> representa tudo que não seja espaço em branco

[a-z] -> representa qualquer letra minúscula do alfabeto
[A-Z] -> representa qualquer letra maiúscula do alfabeto
[a-zA-Z] -> representa qualquer letra do alfabeto, seja maiúscula ou minúscula
| -> representa o 'ou'. "a|b" casa com 'a' ou com 'b', ou com os dois

Vejamos alguns quantificadores
. -> substitui qualquer caractere
* -> o caractere anterior aparece nenhuma ou mais vezes
+ -> o caractere anterior aparece uma ou mais vezes
{a} -> o caractere anterior se repete 'a' vezes
{a,} -> o caractere anterior se repete pelo menos 'a' vezes
{a,b} -> o caractere anterior se repete entre 'a' e 'b' vezes

A representação de dígito é '\d', mas dentro de strings, para '\' valer, temos que escapá-la.
Logo, podemos representar um CEP como: "\\d\\d\\d\\d\\d-\\d\\d\\d"
Ou "\\d{5}-\\d{3}"
O método ficaria:

meu_cep.matches("\\d{5}-\\d{3}") -> retorna 'true' se o CEP for digitado correto, e 'false' caso errado

Para validar um nome, sabemos que o primeiro caractere é maiúsculo:
nome.matches("[A-Z][a-zA-Z]*") -> retorna 'true' se a primeira letra do nome for maiúscula, e 'false' caso errado

O Java provém alguns métodos para o uso de regex e substituições:
std = std.replaceAll("a", "b") -> substitui todas as ocorrências de 'a' por 'b'

Também podemos usar expressões regulares no método 'replaceAll':
std = std.replaceAll("\\w+","a") -> substitui todas as palavras por 'a'
std = std.replaceFirst("\\d","a") -> substitui a primeira ocorrência de um dígito por 'a'
String[] pedacos = std.split("a") -> divide a string 'std' em partes, cujo separador é 'a' e armazena no vetor de strings 'pedacos'. Por exemplo, para separarmos as palavras de uma string, usamos "," ou ",\\s*" como separador

É importante frisar que, nos vários métodos e classes para o tratamento de regex, use a classe String.
Se usar a StringBuilder terá erros.

Caso queira prosseguir no mundo das regex e em Java, esse package possui duas classes que lhe serão bastante úteis:a Pattern, para usar uma expressão regulas e a Matcher, que também usa uma expressão regular mas também uma CharSequence, onde você irá procurar o padrão para casar.
Para expressões regulares que serão usadas somente uma vez, se recomenda usar o método static 'matches' da Pattern. Porém, se for usada mais de uma vez, se aconselha a usar o método static 'compile', que retorna um objeto do tipo Pattern, onde posteriormente se pode chamar o método 'matcher'.

A classe Matcher também provém o método 'matches' e faz a mesma coisa, porém não recebe argumentos. Ela age por encapsulamento no objeto do tipo Matcher.
Essa classe também possui outros métodos bastante úteis, como o 'replaceFirst', 'replaceAll', 'find' , 'lookingAt' etc, que, pelo nome, é possível saber o que cada um faz.

Tenha em mente que as possibilidades das expressões regulares são inúmeras e ilimitadas. Compiladores são feitos usando expressões regulares! Isso por si só já mostra o poder das regex.
Por isso, não entrarei tão afundo no assunto.
Tendo estudado esse artigo, você saberá as possibilidades das Expressões Regulares, e irá se lembrar delas caso um dia necessite delas.

Expressões Regulares são universais. Você pode aprender e usar em vários ramos e linguagens.
Eu mesmo já falei aqui em outros artigos, como no de sed. Lá está até mais completo, se eu falasse mais aqui, estaria simplesmente repetindo o que está escrito lá.
Portanto, dê um pulinho no artigo de Regex da parte de 'sed', é uma continuação daqui:

http://programacaoprogressiva.blogspot.com.br/2012/07/sed-parte-vi-expressoes-regulares.html

Regex é assunto pra livros! E é isso que vou indicar, um site de um brasileiro, o Aurelio Jargas, mestre em Expressões Regulares que publica e divulga GRATUITAMENTE seu material!

http://aurelio.net/regex/

Vale ressalvar que o java possui um pacote (package) voltado para expressões regulares.
Vale uma conferida na documentação:
java.util.regex

LibreOffice Math: Funções, Raiz quadrada, Soma

- Funções

Para escrevermos funções, colocamos 'func' antes de iniciar a função:
func f(x", "y) = {GMm} OVER {r^2}

- Raiz Quadrada

Para aparecer o sinal de raiz quadrada sobre determinada expressão, usamos 'SQRT':
x = {-b +- SQRT %DELTA} OVER {4a^2}

No que somente o que está exatamente a frente de 'SQRT', ou de 'bold' é que terá o efeito.

- Somatório

A sintaxe pro somatório é: sum from a to b
Onde 'a' e 'b' representam o intervalo do somatório
Exemplo:
S_n = sum from x=0 to x=n left( x + 1 right) ^2

- Integral

A sintaxe pra integral é: int from -1 to 1 func f(x)
Exemplo:
int from -1 to 1 func f(x)

Agora você é capaz de entender, facilmente, os demais exemplos do site oficial do LibreOffice Math:

%rho(font sans bold q","%omega) = int func e^{i %omega t}%rho(font sans bold q","t)"d"t
f(t)=int from size*1.5 0 to 1 left[g(t')+sum from i=1 to N h_i(t')right]

LibreOffice Math: Fontes e Matrizes

Nosso objetivo nesse trecho do artigo é escrever uma matriz 'n x n' no Math.
Primeiro, vamos aprender a aumentar o tamanho da fonte

- Fonte

Para definirmos o tamanho de uma fonte, usam 'size', o asterisco e o número. Por exemplo:
size *2 A
size *3 B
size *8 C

Para ela ficar em negrito, escreva 'bold' antes da letra.
Para alterar a fonte escreva 'font' e o nome dela. Testando tudo isso:

font sans bold size *3 M

- Reticências verticais

Estas são amplamente usadas para representar matrizes, e sua sintaxe é 'dotsvert' (dot é ponto e o vet é de vertical)

- Partes de uma Matriz

A sintaxe inicial é 'matrix{}'
Dentro de uma linha, separamos os elementos com '#'. Vamos fazer a primeira linha:
matrix{
M_11#M_22#dotsaxis#M_{1n}}

Para passarmos para a próxima linha, usamos '##' e continuamos na segunda linha, onde vamos inserir o primeiro e o último elemento, com um espaço, representado por {}, entre esses elementos:
matrix{
M_11#M_22#dotsaxis#M_{1n}##
M_21#{}#{} #M_{2n}}

Agora vamos adicionar as reticências verticais na primera coluna e na última, com dois espaços entre esses elementos:
matrix{
M_11#M_22#dotsaxis#M_{1n}##
M_21#{}#{} #M_{2n}##
dotsvert#{}#{}#dotsvert}

Agora vamos colocar os elementos da última linha, que são M_{n1}, M_{n2}, reticências e M_{nn}:
matrix{
M_11#M_22#dotsaxis#M_{1n}##
M_21#{}#{} #M_{2n}##
dotsvert#{}#{}#dotsvert##
M_{n1}#M_{n2}#dotsaxis#M_{nn}}

Vamos colocar entre colchetes, igualar a letra com fonte bem grande e aí sim ficará com cara de matriz:

font sans bold size *2 M = left[
matrix{
M_11#M_22#dotsaxis#M_{1n}##
M_21#{}#{} #M_{2n}##
dotsvert#{}#{}#dotsvert##
M_{n1}#M_{n2}#dotsaxis#M_{nn}} right]

Então, a regra geral para criar matrizes é:
A sintaxe inicial é: matrix{}
Escrever normalmente cada elemento
Usar # para separar os elementos, na linha
Usar ## para ir para a próxima linha
Usar {} para representar espaço
Caso usa uma letra pra representar índice, colocar esse índice entre chaves {}. Ex: M_{1n} e nao M_1n

Exemplo: analise o seguinte código, do site oficial:
func G^{(%alpha" ," %beta)}_{ x_m x_n} = left[ matrix { arctan(%alpha) # arctan(%beta) ## x_m + x_n # x_m - x_n }right]

Caso queiramos inserir uma matriz, mas com chaves grandes, em qualquer lugar usamos
o 'left lbrace' e o 'right rbrace'
g(x," "y)=left lbrace matrix{1 # 2 ## 3 # 4} right rbrace

Note que para que o espaço em branco apareça na fórmula, devemos colocá-lo entre aspas.

Outro detalhe, fazendo:
bold a + b

somente 'a' ficará em negrito. Porém, fazendo:
bold "a + b"

toda a expressão ficará em negrito. É mais uma função das aspas, selecionar o que vai ficar em negrito.
Se usa aspas, também, quando queremos alterar a função de uma letra.
A letra 'd' para a derivada, é representada de forma diferente, para se saber que ela está lá como sinal de derivada, não de somente a letra 'd'.
Veja a diferença
dt
"d"t

Tendo esses conhecimentos, fica fácil entender mais este exemplo do site oficial:

bold { f(x", "y) = left [ stack { x + y over z + left lbrace matrix { 2 # 3 # 4 ## 4 # 5 # 6 ## 6 # 7 # 8} right rbrace # {y + sin (x)} over %alpha # z + y over g } right ]}

LibreOffice Math: Índices

Esse artigo / apostila / tutorial / resumo mostra como usar a poderosíssima ferramenta LibreOffice Math, que serve para escrever fórmulas e símbolos matemáticos em documentos, através de uma sintaxe especial (como se fosse uma linguagem de programação ou o LaTeX), assim não necessitamos ficar indo em 'inserir->símbolos' e procurando pelo símbolo desejado nos processadores de textos mais modernos.

O Math possui uma interface simples: você escreve na metade de baixo da tela e o resultado aparece em cima, como uma linguagem interpretada, tudo em tempo real.
Ele pode ser invocado tanto diretamente, a partir do Start Center do LibreOffice, como a partir das outras ferramentas do Libre.

Esse material foi produzido a partir do site oficial de ajuda do LibreOffice Math:
http://help.libreoffice.org/Math/Math_Examples

De lá, aprendi a usar algumas ferramentas do Math, vendo os exemplos e fazendo algumas alterações, para ver no que dava.
Não usarei de imagens para mostrar o resultado final, por isso é aconselhável que, ao ler, vá testando e vendo os resultados.

- Índices

Antes, uma breve explicaçao sobre o uso de frações:
Escrevendo frações

Para escrever as frações, basta escrever OVER onde seria a barra da fração. Por exemplo, pra escrever '3/2', escreva o comando:

3 OVER 2

Escrevendo entre parêntesis, colchetes e chaves

( → LEFT(
) → RIGHT)

Para usar colchetes e chaves, o modo é análogo, mas com [] e {}

Colocando índices

Índices são aqueles pequenos números/letras que ficam na parte de cima ou de baixo de um símbolo.
Por exemplo, os termos de uma P.A (progressão aritmética), são definidos como a0, a1, a2,...,an
Mas não fica bem escrever assim. Vamos ao LibreOffice Math então:

Para colocar um índice na parte debaixo do símbolo, use o underline '_' após o símbolo.
Experimente:
a_1
a_2
a_n

Para colocar um índice em cima, usamos o circunflexo '^'. Vamos mostrar 'a' elevado a 3, 4 e 5:
a^3
a^4
a^5

Caso queiramos representar as derivadas terceiras e quarta, colocamos o índice entre parêntesis:
a^ LEFT( 3 RIGHT)
a^ LEFT( 4 RIGHT)

Note que em vez de 'LEFT)' e 'RIGHT)', poderíamos ter simplesmente usado '(' e ')' , porém, é um bom hábito usar 'LEFT' e 'RIGHT', pois facilitarão as coisas a medida que as expressões forem ficando mais complexas.

Como ficaria então o terceiro elemento de uma P.A elevado a um terço mais y?
a_3^ LEFT( 1 OVER 3 + y RIGHT)

Porém, os índices também são usados na parte superior esquerda, direita, em cima ou embaixo.
Para isso, usamos as sintaxes:
'l' para left, 'r' para right, 'sup' para superior e 'sub' para inferior.

Teste:
Z_{}lsup 3

Podemos usar 'lsub', 'rsup' etc.

Note que após o '_' ou o '^' deve vir o par de chaves, mesmo que vazios. O uso das chaves será explicado em breve.

- Letras gregas e símbolos matemáticos

É o nome da letra/símbolo precedido de '%'. Veja:
sigma (somatório) : %sigma

Algumas letras gregas usadas na Matemática: omega, alpha, beta, phi, rho
Se usar elas assim, elas aparecerão minúsculas.
Para que elas aparecem maiúscula, escreva em maiúsculo. Por exemplo, o símbolo de somatório é: %SIGMA

- Reticências

Para escrever os 'três pontinhos' use o comando 'dotsaxis'. Por exemplo, o conjunto dos inteiros é:
Z = dotsaxis, -2, -1, 0, 1, 2, dotsaxis

- Chaves

As chaves'{}' também são usados para agrupar uma sequência, pois ao usarmos, elas não aparecem na fórmula, diferente de '( )' e '[ ]'. Teste:
%SIGMA_{a_1 a_2 dotsaxis a_n}^{b_1 b_2 dotsaxis b_n}

Se quiser que as chaves apareçam na fórmula, escape-as
%ALPHA_{\{a_1\}}

Usamos as chaves também para representar alguns símbolos aritméticos. Por exemplo, o conjunto dos inteiros positivos é representado por:
Z^{{}+{}}

Outro exemplo interessante, que é uma foto oficial do site, é obtida com o código:
a OVER b = a OVER {a+b}

Java: A Classe Character

Assim como outros tipos, a Character é uma classe do tipo wrapper. Ou seja, não é apenas um tipo e pronto, como int e float.
Ela já vem com uns métodos e funcionalidades que facilitarão bastante a vida do programador Java.

Java: A Classe StringBuilder

Essa sim é modificável, diferente da classe String.

Com strings dessa classe podemos usar as strings de forma dinâmica, criando, modificando, copiando, anexando, invertendo, adicionando e retirando caracteres, o tanto que desejarmos.

Porém, devemos ainda usar a classe String, especialmente quando os dados contidos na string não necessitarem de mudança (como em Labels, mensagens de erro, de log etc, pois por conta dessa limitação, essa classe é bem otimizada. Mas para strings que se alteram, usamos a StringBuilder.

Existe ainda a StringBuffer, para caso seja utilizado threads.

Vejamos alguns métodos e características destes:

StringBuilder teste = new StringBuilder("123456789");

teste.toString() -> retorna a string 123456789

teste.length() -> o tamanho é 9

teste.capacity() -> a capacidade inicial é 25 (9 + 16, toda StringBuilder inicia com 16, por padrão)

teste.ensureCapacity(100) -> garante uma capacidade pra string, para nao ser necessário crescer dinamicamente ao longo de um programa, o que pode comprometer a performance.

teste.setLength(5) -> agora, teste é somente "12345"

teste.reverse() -> inverte os caracteres da StringBuilder

teste.charAt(int) -> recebe um inteiro e retorna o caractere referente aquele índice

teste.getChars(a, b, char[] c, d) -> copia caracteres da StringBuilder 'teste' a partir do índice 'a' até o índice 'b' para o vetor de caracteres 'c', a partir do índice 'd' neste vetor.

Teste este método, passando a string para o vetor de caracteres e imprimindo-o:

teste.getChars(0, teste.length(), vetorChar, 0);

for( char caractere : vetorChar )

System.out.print(caractere);

teste.setCharAt(a, 'b') -> insere o caractere 'b' na posição de índice 'a'

teste.insert(a, objeto) -> insere, a partir do índice 'a', o 'objeto' na BuildString. Objeto, em Java, representa uma gama enorme de coisas, como String, vetor de caracteres, booleanos, inteiros, float, doubles, chars etc.

teste.deleteCharAt( a ) -> deleta especificamente o caractere da posição de índice 'a'

teste.delete(a, b) -> dele o caractere de índice 'a' até o de índice 'b'

teste.append( variosObjetos ) -> anexa, ao fim da String Builder 'teste' algum 'variosObjetos';

É possível, inclusive, a concatenação:

String teste2 = new StringBuilder().append("Programação").append("\n").append("Progressiva").toString();

Com esses métodos, é possível notar a flexibilidade e utilidade da StringBuilder.

Java: A Classe String

Strings é uma sequência de caracteres. Estes podem ser letras, dígitos ou caracteres especiais, como + _ - * > .<
São tão importantes que o Java possui mais de uma classe só para tratar as strings.

Vejamos, por exemplo, construtores para a classe String:

char[] blog = {'p', 'r' , 'o' , 'g' , ' ' , 'p' , 'r' , 'o' , 'g' , 'r' , 'e' , 's' , 's' , 'i' , 'v' , 'a'};
String stg = new String( "teste" );
String stg1 = new String();
String stg2 = new String( stg );
String stg3 = new String( blog );
String stg4 = new String( blog, 5, 11 );

A saída seria:
stg → teste
stg1 →
stg2 → teste
stg3 → prog progressiva
stg4 → progressiva

Essa classe possui uma série de métodos para formatar strings. No último caso, 'stg4' é iniciada com parte da string 'blog', ela receberá 11 caracteres dessa string, a partir do caractere de índice 4.

Aqui vai uma importante ressalva: String objects são imutáveis! Não é possível mudar seus caracteres depois que você criou!

As strings, por serem da classe String, possuem métodos característicos:

stg.length() -> informa o tamanho da string
stg.charAt(indice) -> mostra determinado caractere da string
stg.getChars(int inicio, int fim, char[] , int inicio2)

Diferente de C/C++, por exemplo, String e Vetor de caracteres são duas coisas diferentes em Java.
No último método, queremos passar os caracteres da String 'stg', a partir do índice 'inicio' até o índice 'fim' para um vetor de caracteres, a partir da posição de índice 'inicio2' nesse vetor

stg.compareTo(stg2) -> 0 se forem iguais; negativo caso stg < stg2 ; positivo caso stg > stg2 , lexicograficamente falando (na forma do dicionário).

A classe String também oferece ferramentas para compararmos strings. Veja alguns desses métodos:

stg.equals(stg2) -> retorna 'true' ou 'false', com case sensitive (maiúsculo/minúsculo importam)
stg.equalsIgnoreCase -> retorna 'true' ou 'false', sem case sensitive (maiúsculo/minúsculo não importam)
stg == "teste" -> retorna 'true' ou 'false' em relação ao fato de serem o mesmo OBJETO, não conteúdo!!! Só retorna 'true' se apontarem pro mesmo endereço de memória!

Se tivéssemos feito:
stg="teste" , o método retornaria 'true', pois o Java trata todos os objetos de string literal de mesmo conteúdo como o mesmo objeto, só com mais de uma referência. Por exemplo:
string1="Programacao Progressiva"
string2="Programacao Progressiva"

Como ambas possuem o mesmo conteúdo, Java trata elas como o mesmo objeto. Ambas apontam pro mesmo endereço de memória.
Porém, com stg = new String("hello") , se cria um novo endereço de memória para a string. O que resultaria em 'false'.

stg.regionMatches(int a, String stg2, int b, int c) -> compara somente certas regiões das strings. Começa a partir do índice 'a' da 'stg', compara com a string 'stg2' a partir do índice 'b' desta, e elas comparam 'c' elementos das strings.

Também existem métodos para a busca, concatenação, alteração maiúsculo/minúsculo, substituição total/parcial e extração de trechos de texto ou caractere em strings, presentes na classe String.
Porém, devido ao grande número e flexibilidade dos métodos oferecidos pela classe String, é inviável mostrar todos aqui, deixamos alguns aqui e outros você pode ver na documentação, conforme sua necessidade. Exemplo:

stg.startsWith()
stg.endsWith()
stg.lastIndexOf()
stg.indexOf()
stg.substring()
stg.concat()
stg.replace()
stg.toUpperCase()
stg.toLowerCase()
stg.toCharArray()

Também existem métodos para 'quebrar' uma determinada string, cujos partes são separadas por um separador, como o espaço " ", por exemplo.

Escreva algo:

String stg= scanner.nextLine();

Receba as 'partes', separadas por espaço:

String[] pedacos = stg.split(" ");
pedacos.length -> retorna o numero de pedaços

Vamos imprimir esses pedaços, que nada mais são que as palavras que voce digitou:

for(String palavra : pedacos)

System.out.println(palavra);

Shell Script Debugging: A arte de encontrar erros

- Mensagens mais comuns

1. syntax error: unexpected end of file
Quando criamos um laço ou condiçao, e não o 'fechamos', ou seja, nao colocamos o 'done' ou 'fi' ao final.

Ou seja, não estava esperando o final do arquivo. Interprete como 'era pra ser outra coisa., não esqueceu nada no caminho?'

2. unexpected EOF while looking for matching `”’
Quantos esquecemos de completar as aspas ", ` ou ', aparece algo parecido.

Nesse caso, ele não informa a linha. Então, se o código for muito grande fica bem difícil de achar o erro.
Um editor de texto com a opçao 'highlighting' ajuda bastante. Indico o vi/vim.

3. command not found

Se viu isso, muito provavelmente digitou algo errado. As vezes é simplesmente um espaço que falta dentro de um 'if', por exemplo.
if[errado ]
if[ certo ]

Isso porque o '[' é um comando, é uma maneira mais simples do comando 'test' e ']' é um argumento pro comando '['.

Lembrando que, caso usemos uma variável, por exemplo: if[$a...]
O shell apontará o erro, mas não como: [$a
E sim usando o valor da variável. Por exemplo, se a=1, o erro será: [1
O que pode vir a confundir um pouco.

Então, o [errado = testerrado , ou seja, voce realmente digitou o comando de forma errada.
Interessante, não?

- Alguns cuidados

Caso vá fazer script importantes, que não serão usados somente por você, tome algumas precauções:

1. Nem todos os sistemas vem com um compilador de C. Se vier, pode ser diferente, pode ser o gcc, cc ou lpicc.

2. Há comandos que não são iguais em sistemas diferents, como o 'ps', pra listar os processos, que usamos as opçoes 'aux' ou 'ef' dependendo do SO.

3. Cuidado com os dispositivos. Pode se deparar com /mnt/cdrom ou /media/cdrom .

4. Quando o shell encontra o erro, ele morre, e o que vem em seguida não é rodado.
Isso é um risco, pois o que viria a seguir seriam ações que complementariam, remendariam ou concluiriam os comandos anteriores, podendo deixar seu sistema instável ou inseguro.

- 'exit' ou 'read' e descubra

Em um script muito longo, é uma boa técnica inserir uns 'exit' no código. Caso o script rode bem, o erro estará depois do exit.
Se acontecer um bug, você sabe que até o 'exit' tem pelo menos um erro.
Coloque sempre no meio do script. Depois no meio da metade que o erro está localizado...é o algoritmo de busca binary search.

Podemos parar o script de uma forma menos agressiva. Em vez de saírmos, vamos dar uma pausa nele para simplesmente para fazer com que ele peça e leia uma variável do usuário. Se até então não tiver ocorrido erros, está ok nessa parte do script. Use 'echo's pra se situar.

- 'function'

Se a dificuldade persistir, divida os blocos do script em funções e execute todas na ordem, como se o script estivesse rodando normalmente. O Shell deve acusar a função com erro.

- 'echo'

Entupa o script de 'echos' do tipo "o comando tal passou", "o looping já era", "a condição nao bugou", etc.

- O mas próximo que podemos chegar de um debugging

Em shell, não existe um debugger propriamente dito, como os de outras linguagens, a quais estamos acostumados.
Mas do artigo de Pipelines, vimos que cada comando tem sua saída de erros (stderr). Ao invés de debuggar, podemos pedir pro shell exibir mais informações a medida que ele analisa o script, através das opções '-n', '-v' e '-x'.

-n

checa a sintaxe, sem executar os comandos do script
sh -n nao_rode

Use sempre que necessitar de segurança.

-v

O 'v' é de verbose, é a mesma técnica de entupir o script com 'echo's.
Aqui, o shell informa que comando vai rodar. Um por um.
sh -v fale_shell

Se você for rodar scripts de fontes duvidosas, uma boa prática é combinar esses dois comandos:
sh -nv sou_cauteloso

-t

Se estiver com problemas de valores de variáveis e quiser checar se elas estão se comportando (mudando) de maneira correta, use o 'execution trace', e vejo o traço de mudanças:
sh -t mude_e_mostre

- Boas práticas

Seja como o Unix.
Pense como o Unix.
Imite o Unix.
Nomeie variáveis de modo a fazer sentido.
Armazene endereços, de arquivous e diretórios, em variáveis. Assim evita a escrita repetida do endereço pelo script.
Use parágrafos para separar trechos [ENTER].
Idente loops e condições.
Comente seus scripts, nem que seja só a primeira linha, dizendo pra que serve o script. Daqui há alguns meses você vai entender porquê isso é importante.
Erros são tão comuns e 'importantes', que o Unix tem mensagem de erro até pra quando as coisas dão certo (?). Faça o mesmo. Forneça erros bem escritos, explicativos e de maneira mais direta possível em seus scripts.
A época das cavernas acabou. Não escreva seu código em forma de códigos (sacou?) incompreensíveis. Seja claro e simples, não use hieróglifos. Se for compartilhar, vale muito mais um código fácil de ler do quê um minimalista.
Projetos grandes e complexos são feitos partes pequenas e simples. A cada etapa de seu código, teste-o. Só vá para o próximo depois de testar completamente o trecho atual. Não deixe nada passar, ou vai virar uma bola de neve invisível.
Escute Rush.

- Uma segunda opinião

Todos já passamos pela situação de ficar minutos, horas ou dias procurando o erro e tentamos suicídio quando descobrimos o quão bobo ele era.
É difícil achar erros em nossos códigos, pra gente, sempre faz sentido.
Simplesmente peça pra outra pessoa dar uma olhada.

Funções em Shell Scripting, parte 4: Para entender recursão, tem que entender recursão

Ao fim dessa parte do capítulo, espero que consiga entender essa famosa frase sobre recursão.
Basicamente, usamos recursão quando, dentro de uma função, chamamos ela mesma. Porém, alteramos o argumento passado a cada chamada. Assim, o processo executa até um determinado ponto. Você vai se confundir se eu falar muito antes de mostrar. Então vamos a um exemplo, que foi usado pela banda Europe para criar sua musica de maior sucesso:
recursao.sh
-----
#!/bin/bash

contagem_regressiva ()
{
if [ $1 -eq 0 ]
then
clear
echo "The Final Countdown !!!"
sleep 1
echo "tam-dam-dam-daaaam"
sleep 1
echo "tam-nam-nam-nam-naaaam"
return 0
fi

echo $1
sleep 1
clear
novo_tempo=`expr $1 - 1`
contagem_regressiva $novo_tempo
}

clear
contagem_regressiva 5
------

Permita e execute:
chmod +x recursao.sh
./recursao.sh

Vamos lá.
Primeiramente, 'clear' limpa a tela do terminal e 'sleep 1' faz o terminal dormir por 1 segundo.
A função recebe um número como argumento, o número 5.
O primeiro 'if' teste se o argumento é 0, se for mostra a letra da música na tela. Como não é, o 'if' não é executado.
Depois, o argumento é impresso na tela. Então é criada uma nova variável a partir do argumento subtraído de 1.
Depois vem o pulo do gato, que é chamar a própria função, mas agora usando o 4 como argumento.
Esse processo é repetido até o argumento ser 0. Quando é 0, a função vai, finalmente, rodar o 'if'.
Note que o 'if' tem o 'return' que irá parar a função. E só para quando atinge 0 e mostra a letra da música do Europe.

Ou seja, os dois pontos obrigatórios da recursão: onde parar (no caso, quando for 0) e chamar a própria função, porém com argumento alterado em relação aquele que foi recebido.

Recursão é algo de extrema utilidade, pois trata casos de forma dinâmica. Ou seja, não importa o argumento, se for positvo, vai sempre executar a contagem regressiva. Recursão é alto de extrema de importância e uma maneira muito bonita de se resolver problemas.
No geral, exibe que bem menos código seja escrito, embora, no começo, pareça ser mais complicado.

Como exercício, sugiro que você crie uma função que calcule o fatorial de um númreo positivo.
Exemplo:
3! = 3x2x1= 6
4! = 4x3x2x1 = 24
5! = 5x4x3x2x1 = 120

Dica: fatorial de n pode ser visto como 'n x fatorial(n-1)', e fatorial de 1 é 1.

Funções em Shell Scripting, parte 3: Passando (argumentos) e Obtendo (return codes) informações

- Passando argumentos para as funções

Como, depois de declaradas, podemos usar as funções assim como usamos os comandos, também podemos passar argumentos para funções, assim como fazemos com os comandos.
Os argumentos são armazenados da mesma forma que os parâmetros, quando usamos comandos.
Ou seja, o nome do script é armazenado na variável '$0', o 1o argumento fica na variável '$1', o 2o na '$2', ..., o número total de argumentos na '$#' e todos são armazenados na '$@'.
Vamos testar criando o script 'args.sh'
-------------
#!/bin/sh

args()
{
echo "Nome: $0"
echo "Total: $#"
echo "Primeiro: $1"
echo "Segundo: $2"
echo "Terceiro: $3"
echo
echo "Todos: $@"
echo
}

args arg1 arg2 arg3
------------------

Permita e execute:
chmod +x args.sh
./args.sh

- Códigos de retorno (return codes)

Como vimos, todo e qualquer comando do Unix retorna algum código. '0' caso tenha dado tudo certo e outro número para mostrar que houve um erro, onde números diferentes são usados para indicar erros diferentes. O bash armazena o código de retorno do último comando na variável '$?'.

Por exemplo, digite no terminal:
comando_inexistente
echo $?

Que exibirá o erro, pro caso do comando não existir.
Agora teste um comando que funcione bem:
ls
echo $?

- return

Como esses códigos de saída são amplamente usados no *Unix, é uma boa prática fazer o mesmo em seus scripts.
Usa-se o comando 'return [|inteiro]' ao invés de 'exit [|inteiro]' nas funções de seu script, pois queremos somente que a função termine, não o script, e retornando um inteiro para o script, fazendo uma comunicação deste com a função.

Se não usarmos um 'return' em uma função, o '$?' armazenará o código de retorno do último comando da função.

Podemos escrever só 'return' sem retornarmos explicitamente um número. Quando a função encontra 'return' ela termina imediatamente (não executa o que vem em seguida) e '$?' armazenará o código de retorno do último comando antes de encontrar da função chegar em 'return'.

Ou retornamos algo específico de nosso propósito. Dentro de condicionais, por exemplo:
if(tudo certo)
return 1
else
return 2

Lembrando que os códigos de retorno vão de 0 até 255

- Variáveis globais

Aqui vai uma pequena e importante ressalva para você que já vem de outra linguagem de programação.

Por padrão, as variáveis em Shell Scripting são globais. Se quiser que elas sejam locais em suas funçõe as declare como 'local':
local variavel='sou local'

Isso, as variáveis que você usou estarão disponíveis por todo o script. Incluindo
Portanto, cuidado. Dẽ nomes únicos para as suas variáveis.

Funções em Shell Scripting, parte 2: Aninhando, Arquivos de funções (source files) e Desdeclarando funções (undeclaring)

- Funções aninhadas

Você também pode chamar uma função dentro de outra função. Nesse caso, a ordem em que as funções foram declaradas não é importante.
Ou seja, você pode invocar uma função que ainda não foi declarada.
Porém, por questão de organização e manutenção de código, declare sempre suas funções no início do script.

- Arquivos de função

Se seu script começar a ficar muito grande e complexo, é uma boa prática criar um arquivo (ou mais), só pra armazenar as funções.
Então, no script, simplesmente carregue esse arquivo (como o 'include', 'import', 'use', etc, de outras linguagens).
Para carregar as funções de um arquivo, caso este esteja no mesmo diretorio do script, use 'source':

source arquivo_de_funcoes

- "Desdeclarando" funções

Nem sei se a palavra "desdeclarar" existe, mas foi o que imaginei de "Undeclaring functions".
Isso é feito através do comando 'unset':
unset listar

Se tentarmos o comando 'listar', teremos mensagem de erro, poiso Shell já 'liberou' ela de sua 'memória'.

Funções em Shell Scripting, parte 1: Introdução e declarando funções

Esse artigo / resumo / matéria / tutorial / apostila tem por objetivo dar uma 'geral' no assunto Funções em Shell Scripting, em sistemas Unix.
Tal assunto é de uma abrangência vasta, sendo impossível explicar tudo em um artigo, mesmo que eu colasse aqui o 'man', ou documentação, de cada arquivo/comando.
Um conhecimento maior só virá com o estudo de várias fontes, leitura de outros scripts e trocando informações com outros programadores.
Portanto, tome este material como referência. Através dele você terá uma noção sobre o assunto Funções em Shell Scripting, para que servem, como usá-las, além de conhecer algumas ferramentas e comandos.

Quem já estudou outra linguagem de programação sabe o que são funções ou, como são muitas vezes chamadas, subrotinas.

Resumidamente, são um bloco de comandos que, geralmente, recebem dados, fazem a manipulação destes através das instruções e devolvem algum resultado.
As vezes não retornam nada, mas fazem algum tipo de mudança no seu script, nem que seja uma simples exibição de texto.

Quem escreve muitos códigos em shell scripting sabe que repetimos muitos comandos e instruções.
Escrevendo, definindo e salvando as funções de maneira que estas sejam bem simples e executem uma tarefa bem específica é uma boa prática para evitar a repetição na escrita de código, pois podemos sempre reutilizar estas funções.
Assim, quando for iniciar um projeto, já terá boa parte deste feito, em forma de funções.

- Declarando funções

Em Shell, as funções tem a cara:

funcao ()
{
#bloco de instruções. Tudo entre {} é executado de uma vez
}

Diferente de algumas linguagens de programação, as variáveis internas a uma função são visíveis fora desta (em suma, por padrão, as variáveis são locais, a menos que as declare como 'local'):

{ texto="Oi, sou uma função anônima" ; }
echo $texto

Note que, após cada comando dentro do escopo das funções, usamos ';'
listar () { texto="listando items" ; echo $texto ; ls ; }

Para declarar a função, digite no terminal:
declare -f listar

Caso deseje expandir os comandos, o bash irá interpretar a quebra de linha, não sendo necessário o ';' :
listar()
{
texto="listando items"
echo $texto
ls
}

*Importante: após a primeira chaves, {, dê espaço!
listar() {ls;} -> ERRADO
listar() { ls;}-> CERTO

Após criar e declarar a função, para chamá-la simplesmente digite o nome dela, como se fosse um comando, no terminal:
listar

Note que isso só funcionará na instância do shell em que você declarou a função.

Como na maioria das linguagens, você precisa declarar a função antes de usá-la (em Perl não, por exemplo, você pode declarar até num pedaço de papel que o Perl reconhece).

Vamos testar no script 'hello':
--------
#!/bin/bash

hello()
{
echo "Hello, World"
}

goodbye()
{
echo "Goodbye, World"
}

hello
goodbye
--------

Execute e sinta a magia no ar:
chmod +x hello
./hello

Leia o artigo "Processos", insira 'exit 0' ao final da função hello(), veja e analise o resultado.

Processos, parte 5: Códigos de retorno (return codes)

parte 1: Introdução
parte 2: Iniciando (launching) e matando (killing) processos
parte 3: Capturando saídas com Backtick, ` (crase)
parte 4: calculadora/comando bc
parte 5: Códigos de retorno (return codes)

Em *Unix, os comandos sempre retornam um valor, um código, que indica alguma informação sobre o funcionamente de tal comando.
O código 0, por exemplo, significa que o comando foi executado com sucesso. É um código universal no sistema.
Qualquer outro valor quer dizer que algo deu errado, variando de comando para comando o significado de cada código de erro.

A variável $? armazena o código de retorno do último processo executado.

Como foi dito no artigo sobre Pipelinas, podemos redirecionar a saída de um comando para '/dev/null' somente para checar se o comando foi executado com sucesso ou não. Iremos fazer um script usando isso, em relação ao comando 'ls'.
Crie o scripe 'return_codes':
----------
ls /usr/bin > /dev/null
echo "Código de retorno do último processo: $?"

#obviamente o diretório fubá (versão cearense do foobar) não existe
ls /fubá > /dev/null
echo "Código de retorno do último processo: $?"
----------

Execute e constate o esperado:
sh return_code

Esses 'return codes', são particularmente importantes quando usamos funções em nossos Shell scripts. Assunto que será abordado em um próximo artigo.

Processos, parte 4: calculadora/comando bc

parte 1: Introdução
parte 2: Iniciando (launching) e matando (killing) processos
parte 3: Capturando saídas com Backtick, ` (crase)
parte 4: calculadora/comando bc
parte 5: Códigos de retorno (return codes)

Como foi possível notar usando 'expr', é um método complicado e expressões simples se tornam muito enfadonhas para serem escritas.
Ao invés disso, usaremos o comando 'bc', que é uma linguagem de cálculo com precisão, onde podemos usar seus resultados, através de pipe, em nossos scripts.

Lembra bastante a sintaxe de C, e não usamos $ para referenciar variáveis.
Vamos criar um script 'imposto' que calcula o valor de um cd do Windows.

Vamos testar alguns valores e ver alguns resultados, para sabermos como funciona.
Abra o bc:
bc
val=250
val = val + 150
print val
juros=0.05
val*juros
quit

Deu pra ver que a sintaxe é simples. Agora vamos usar o bc(a saída dos cálculos) em um script, através de pipe.
Salve o script como 'windows'
---------
echo -n "Insira o valor do cd do Windows: "
read val
taxa_imposto=0.1

valor=$`echo "imposto=$val * $taxa_imposto ; total=$val + imposto ; print total" |bc`
echo "Total do cd, com impostos: $valor reais"
----------

A seguir, rode-o:
sh windows

Note que fizemos 'total=$val + imposto' e não 'total=$val + $imposto', pois dentro do bc não usamos $ nas variáveis.
Nesse caso usamos na $val, pois ela é externa ao bc.
Usamos pipe para conectar a saída do 'echo' com a entrada do 'bc'.

Processos, parte 3: Capturando saídas com Backtick, ` (crase)

parte 1: Introdução
parte 2: Iniciando (launching) e matando (killing) processos
parte 3: Capturando saídas com Backtick, ` (crase)
parte 4: calculadora/comando bc
parte 5: Códigos de retorno (return codes)

Usar a saída de processos, seja para usar o código de retorno do processo, seja para definir ou colocar arquivos inteiros em variáveis, usar a saída deles é de imensa utilidade em Shell Scripting. É usar, de verdade, o sistema.

- Usando a crase (backtick)

Se colocarmos um comando entre crases,``, é a saída do comando que aparecerá. Ou seja, estamos substituindo o comando pela sua saída, parecido com o que o Shell faz ao substituir o valor da $variavel.
Por exemplo, vamos usar a saída do 'ls':

---------
for arquivo in `ls`
do
echo "Arquivo: $arquivo"
done
---------

O uso das backtick vem de longo tempo. Há porém, maneiras mais modernas de fazer isso, como o uso de parêntesis.
$(comando flags argumentos)

Se há diferenças entre `` e $(), desconheço.

* Passando a saída dos comandos para variáveis
Se dá através da crase:
data=`date`
echo $data

Sabemos que $0 armazena o endereço completo do script na forma: /caminho/do/arquivo.log
Porém, usamos geralmente só o 'arquivo.log'. Para pegar so o nome do script, usamos o comado 'basename':
nome_do_script=`basename $0`

Caso queira descartar a extensao:
nome_do_script=`basename $0 .log`

- Usando a crase para fazer cálculos

É possível fazer cálculos com o comando 'expr'. Por exemplo:
expr 2 + 2

Mas, há alguns detalhes. Teste:
expr 2 * 2
expr "2 * 2"

Você deve ter obtido um erro de sintaxe, já que esta expressão não é permitida, pois antes de ser o caractere que representa o produto, é um wildcard, ou seja, é interpretado antes pelo Shell do que pelo 'expr'. O correto seria:
expr 2 \* 2

Outro exemplo, agora usando a crase para armazenar dados:
x=1;
expr $x + 1
x=`expr $x + 1`
echo $x

x=`expr $x + 1`
echo $x

Para backticks aninhados, devemos escapar as backticks de dentro:
a=`b=\`expr 2 \* 2 \`; expr $b + 1 `

Aqui, fazemos b=2*2 e depois a=b+1

- Fazendo variáveis receberem arquivos

É sabido que praticamente tudo em Unix são arquivos, e que estes são, no geral, textos.
Podemos então, fazer com que variáveis em nossos scripts armazenem o conteúdo de um arquivo de uma maneira bem simples:
variavel=`cat /caminho/pro/arquivo`

Ou
variavel=`</caminho/pro/arquivo`

Não é aconselhável carregar uma variável com arquivos de conteúdo muito grande ou que sejam binários.

Processos, parte 2: Iniciando (launching) e matando (killing) processos

parte 1: Introdução
parte 2: Iniciando (launching) e matando (killing) processos
parte 3: Capturando saídas com Backtick, ` (crase)
parte 4: calculadora/comando bc
parte 5: Códigos de retorno (return codes)

- Iniciando processos

Não é somente rodar o processo.
Há várias formas de como rodar o processo, como por exemplo, em background, foreground, em um subshell, invoncando 'exec' (não retorna para seu script) ou em'fork' (criando processos filho).

- foreground
Para rodar em foreground, ou primeiro plano, não tem segredo. Basta rodar o comando normalmente, como sempre fez. Aqui é só nomenclatura, só pra você saber que o nome disso é foreground ;)

- background
Você roda em primeiro plano, porque também pode rodar em segundo (background).
Para rodar em background, usar o caractere ampersand '&', também conhecido como 'e comercial' ou sinal tironiano, ao final de seu comando, como você já deve ter percebido no scipt inicial desse artigo.
O uso do & não funcionará bem, porém, se você usar com comandos que enviam a saída para a stdout (redirecione), em comandos que precisem de entrada fornecida pelo stdin (redirecione) ou caso seus scripts interajam com o comando.

- subshell
Um subshell é uma espécie de 'filho' ou instância do shell 'atual'. Você pode usar para rodar um processo em paralelo, por exemplo, ao passo que faz um processo no shell principal e usar o resultado de um no outro.
Quando rodamos um script, por exemplo, ele é executado em um subshell.

Para rodar um comando em um subshell, simplesmente envolva tal comando entre parêntesis:
echo "Atual: $BASH_SUBSHELL" ; (echo "Subshell: $BASH_SUBSHELL")

- exec
Caso não queira um comando em um subshell, use o comando 'exec' antes dos outros comandos, que ele irá forçar o comando a ser rodado na instância atual do shell. Exemplo:
exec echo "Alguém me lê?"

Porém, o 'exec' é mais útil na forma de script. Crie o script exec:
----------
exec echo "Olá, agora você me lê"
echo "Segredo: as vezes ainda uso Windows, mas tenho vergonha de dizer"
----------
Executando:
sh exec

Nota-se que somente o primeiro 'echo' é exibido (ufa!).

Tenha sempre em mente que, com o exec, a coisa vai, mas não volta. Ele substitui o antigo processo pelo novo, ou seja, seu script termina. Cuidado para não perder suas informações. Sempre que usar, certifique-se de que não precisará mais de nada do script.
Ele é particularmente útil para liberar recursos do seu script, como memória, sendo usado em scripts mais longos, perto do fim destes.

- Killing (matando um processo)

Podemos parar a execução de um processo que desejarmos (geralmente por ter travado, por não ter sido finalizado de maneira correta ou ainda estar rodando por algum motivo obscuro), chamamos carinhosamente isso de kill.

Na verdade, o comando não mata nada. Ele simplesmente envia um sinal para o processo, que decide se termina normalmente ou comete 'suicídio' (a maioria dos comandos são programados para se matarem ao receberem um sinal).

Para finalizarmos um processo, usamos o comando 'kill' e a ID do processo. Usamos a opção '-9' pra enviar o SIGKILL.
Por exemplo, vi que a PID do player Clementine é 30271. Para fechá-lo:
kill -9 30271

Obviamente, se estiver tocando Rush no seu player, você irá fechar outro aplicativo.
No que, caso não seja root, você precisa ter sido a pessoa a ter rodado aquele programa.

Caso 'exit' não seja o suficiente para sua sede de Unix: kill -9 $$

Os comandos para matar algum processo são vários e nem todos enviam sinais.
Como o objetivo desse artigo é somente apresentar as ferramentas e informções existentes à respeito dos processos, não irei entrar em detalhes.
Caso precise saber mais:
man kill
(but woman, more)

Processos, parte 1: Introdução

Esse artigo / resumo / matéria / tutorial / apostila tem por objetivo dar uma 'geral' no assunto Processos, em sistemas Unix.
Tal assunto é de uma abrangência vasta, sendo impossível explicar tudo em um artigo, mesmo que eu colasse aqui o 'man', ou documentação, de cada arquivo/comando.
Um conhecimento maior só virá com o estudo de várias fontes, leitura de outros scripts e trocando informações com outros programadores.
Portanto, tome este material como referência. Através dele você terá uma noção sobre o que são Processos, para que servem, como usá-los, além de conhecer algumas ferramentas e comandos.

parte 1: Introdução
parte 2: Iniciando (launching) e matando (killing) processos
parte 3: Capturando saídas com Backtick, ` (crase)
parte 4: calculadora/comando bc
parte 5: Códigos de retorno (return codes)

Uma maneira, simples, de ver um sistema operacional, é vê-lo como um punhado de processos / programas / comandos rodando no sistema,
fazendo com que tudo funcione. Esses processos tem as mais variadas origens, como por parte do kernel, do usuário, da rede, de outros processos
etc. Logo adiante, ao checar os processos vigentes no seu sistema, entenderá melhor quando vê-los.

Poucos são os scripts em Shell que são isolados, ou seja, que são auto-suficientes em informação, comandos, processamento e armazenagem de dados.
O propósito e uso maior desse tipo de script é interagir com o sistema. Afinal, o Shell é do Unix, e foi criado para trabalharem juntos.

Essa interação se dá por meio da exploração dos processos que estão rodando, ou que você fará rodar ou parar, no sistema.
Isso é feito iniciando e fechando processos, seja em foreground (pro usuário ver) ou em background (sem você ver), usando as variáveis do ambiente e pegando as informações de retorno do processo (códigos), dentre outras maneiras.

- Checando os processos

Vamos iniciar a exploração dos processos com o comando 'ps', que lista os processos ativos:
ps -ef

Ou, para *BSD:
ps -aux

Note os dados exibidos no terminal, principalmente a PID, que mostra a ID (identificação do processo), que é a informação que usaremos para identificar e controlar o processo.

Toda essa sopa de letras tem seu significado. E tais informações estão devidamente armazenadas em variáveis do sistema. Vamos conhecer alguma delas, que são particularmente úteis para serem usadas em scripts.

- $$

Mostra a ID do atual processo. Digite no terminal:
echo $$

Depois procure essa ID na lista de processos exibida no comando 'ps -ef'.
Deve achar /bin/bash ou 'su -', caso esteja como root.
Caso execute esse comando através de script, a ID é a do script.

- $!

Mostra a ID do último processo que rodou em background do seu script.

Vamos criar um script para ver melhor essas variáveis em ação.
O script proc1.sh por si só já é auto-explicativo:
----------------------
echo "O processo atual é: $$"
echo -n "O último processo a ocorrer em background: "

# Note que não iniciamos processo algum no script
if [ "$!" == "" ]
then
echo "inexistente"
else
echo "$!"
fi

echo
echo "Executando um comando em background..."

# Vide meu artigo Pipelines caso não entenda o seguinte comando
ls /usr/bin > /dev/null &

echo "Agora, o último processo a ocorrer em background é $!"
----------------------

Permita e execute para ver o resultado:
chmod +x proc1.sh
./proc1.sh

- /proc

Os processos são tão fundamentais e importantes no sistema que existe um diretório que tem todas as informações dos processos que estão rodando, além de informações do sistem operacional, dos dispositivos USB conectados e do hardware.
Acessando tal diretório você irá notar que cada processo possui seu próprio diretório, cujo nome é a PID do processo:
ls /proc

Na verdade, ele não é bem um diretório, é um sistema de arquivos (File System) virtual, onde o kernel traça as estruturas de dados interna do kernel para que pareçam arquivos e diretórios, pois sendo vistos como tais são mais úteis, já que a maior parte dos comandos (do Unix, na verdade) trabalham com arquivos.

Vamos explorar algum desses diretórios, como o 14297 (no meu).
ls -CFl /proc/14297/fd

fd é de file descriptors (0 para stdin, 1 para stdout e 2 para stderr, por exemplo), que são mostrados antes do '->', além de sockets, pipes e outras informações daquele processo.

Dentro de cada processo existe uma série de arquivos interessantes, como o 'environ'.
Usando o comando 'cat' para olhar o conteúdo desse arquivo você verá que ele, aparentemente, está todo desorganizado.
Use o seguinte comando para ver melhor o conteúdo:
od -a /proc/14297/environ

Note que as variáveis estão separados por um caractere 'nul' (ASCII 0) ou '\000', que só é interpretado pela máquina.
Vamos usar o comando 'tr' (de translate), para transformar esse caractere em nossa quebra de linha visível, '\n':
tr "\000" "\n" < /proc/14297/environ

Agora é possível ver as variáveis do processo.

Assinar: Postagens (Atom)