Pão de queijo com Java

Módulos em Java 9

2017-10-18T17:23:00.001-02:00

Em 2017 saiu a versão nova do Java - o Java 9. Com esta versão sai um novo sistema de módulos chamado Jigsaw. Os módulos do Java 9 são uma das maiores mudanças na estrutura do java.
Um Módulo é uma coleção auto-descritiva de Código, Dados e Recursos. Um módulo é um conjunto de Pacotes, Tipos (classes, classes abstratas, interfaces, etc.) com Código e Dados e Recursos.

As aplicações escritas em Java 8 ou anteriores não conhecem suas próprias dependências.
Claro que o javac não compilará nosso código se faltarem dependências de tempo de compilação e, claro, temos ferramentas de compilação e IDEs para nos apoiar com esses casos. Contudo, no tempo de execução, a JVM precisa pesquisar classes necessárias no CLASSPTH novamente, em alguns casos, resultando em diferentes classes sendo carregadas pelo classloader. Assim podemos ter problemas em tempo de execução.
A estrutura modular vem para resolver este problema.
Além disto o sistema JDK atual é muito grande. No Java 9, o próprio JDK foi dividido em pequenos módulos. Portanto, é muito fácil reduzir o aplicativo Java para dispositivos pequenos.

O JDK 9 não contém JRE. No JDK 9, o JRE é separado em uma pasta de distribuição separada. O software JDK 9 contém uma nova pasta "jmods", que contém um conjunto de módulos Java 9 como mostrado abaixo.

No Youtube estão 3 vídeos que trazem uma introdução a este tema.

Tratando CTRL-C em python

2017-06-07T08:35:00.001-03:00

Quando pressionamos CTRL-C no teclado e nosso programa está rodando, normalmente isto significa que o programa deverá parar. Quando pressionamos CTRL-C é gerado um sinal para o programa.
Um sinal é uma forma de comunicação entre processos utilizada nos sistemas operacionais compatíveis com POSIX. Um sinal é uma notificação assíncrona enviada para um processo ou para um segmento específico dentro do mesmo processo para notificá-lo de um evento que ocorreu.

Quando um sinal é enviado, o sistema operacional interrompe o fluxo normal de execução do processo alvo para entregar o sinal. A execução pode ser interrompida durante qualquer instrução não atômica. Se o processo já registrou um manipulador de sinal, essa rotina é executada. Caso contrário, o manipulador de sinal padrão é executado.

O python permite que troquemos como os sinais serão tratados, assim dá para capturar o envio do CTRL-C e executar um procedimento de tratamento personalizado. Abaixo a gente pode observar um exemplo de como fazer este tratamento de sinal.
Precisamos importar a biblioteca SIGNAL do Python.
Utilizamos na linha 23 o comando para atribuir uma função de tratamento signal_handler() para o sinal CTRL-C (SIGINT). Nas linhas 11 a 17 criamos o nosso tratador signal_handler().
Note que ele recebe dois parâmetros, o número do sinal (pois a gente pode usar a mesma função para tratar vários sinais) e os dados da pilha.

Você pode obter este módulo em meu repositório python_codes no github.

Referências

Quer saber com mais detalhes como este processo de sinalização ocorre no sistema operacional?

Leia a seção 4.6.2 sobre manipulação de sinais do livro do Silberschatz.

Se quiser ler mais sobre a manipulação de sinais no Pythom, veja em python docs.

Rodando Docker sem sudo

2017-04-14T09:33:00.003-03:00

Quando instalamos o docker, o nosso usuário não fica automaticamente habilitado para rodar o docker sem utilização do comando sudo. Isto acontece porque o daemon do docker sempre é executado como o usuário root. Desde docker versão 0.5.2, o daemon docker se liga a um socket Unix em vez de uma porta TCP. Por padrão, esse socket Unix é propriedade da usuário root e, portanto, por padrão, você pode acessá-lo com o sudo. Se você tentar rodar terá o seguinte erro:

A partir da versão 0.5.3, se você criar um grupo Unix chamado docker e adicionar usuários a ele, então o daemon do docker fará com que o grupo tenha acesso de leitura e escrita neste socket Unix quando o daemon for iniciado .

O daemon do docker deve sempre ser executado como o usuário root, mas se você executar o cliente docker como um usuário no grupo do docker, então você não precisa adicionar o sudo a todos os comandos do cliente.

Então como fazer para rodar. Os passos são:

adicionar o grupo docker, caso ele ainda não exista (no meu caso ele já existe)
adicionar o seu usuário (e qualquer outro que você queira) ao grupo do docker
reiniciar o daemon: no meu caso o processo chama docker, mas em algumas versões de SO o nome é docker.io.

Você precisa carregar nas configurações de seu usuário o novo grupo. Você pode: (1) fazer log out e entrar novamente ou (2) usar o comando "newgrp docker" para carregar estas configurações. No meu exemplo abaixo eu usei a segunda opção. Com isto agora meu usuário consegue carregar o hello-world sem utilizar o sudo.

Docker e Java

2017-03-01T08:14:00.000-03:00

Normalmente eu preciso utilizar o java. Meu sistema operacional preferido é o Ubuntu, mas na Universidade o sistema operacional apesar de ser linux, não é o Ubuntu. A utilização do Docker é ideal neste caso, pois posso utilizar meu ambiente favorito, não necessário um ambiente de virtualização na estação que estou utilizando, bastando ter o docker instalado e meu usuário no grupo docker.

Um jeito de automatizar o processo é utilizar um dockerfile e criar um docker local usando o comando docker build. Se você quiser ter mais informações leia a documentação no site do docker em https://docs.docker.com/engine/reference/builder/.

Vamos então a instalação e criação de um docker com java 9.
São dois passos:

Instale o docker no seu computador
Rode o comando docker build github.com/h3dema/ubuntu_java

Vá tomar um café pois demora um pouco. Será feito o download do programa e seu docker será criado.

Pronto!

PS: Hoje (29/05/2017) este procedimento não está funcionando mais. A Oracle retirou do ar o site java.net que era onde era baixado o JDK. Assim que o pessoal do webupd8 atualizar o script, eu indico aqui também.

Java 9 terminou os testes de unidade

2017-01-03T21:07:00.001-02:00

O Java 9 está começando a sair do forno. Agora em dezembro o desenvolvimento alcançou a marca de "Recurso Completo", ou seja, todos os recursos foram implementados e integrados na floresta principal do Java, inclusive sendo feitos os testes de unidade.
A lista de recursos do JDK 9 incluídos no JDK 9 Early Access Downloads pode ser encontrada na página do Projeto JDK 9.

Para instalação no Ubuntu (funciona em outras variantes do Debian também) basta seguir os passos em um terminal:

$ sudo add-apt-repository ppa:webupd8team/java
$ sudo apt-get update
$ sudo apt-get install oracle-java9-installer

Se você quiser configurar o Oracle Java 9 como padrão, não importa quais outras versões Java estejam instaladas, certifique-se de instalar o pacote oracle-java9-set-default, digitando no terminal:

$sudo apt-get install oracle-java9-set-default

Note que ainda é um release recente para testes.
Não deve ser utilizado hoje em um ambiente de produção!

Alterando o local padrão para as máquinas virtuais no VMware Player

2017-01-03T20:57:00.003-02:00

Eu uso muito os ambientes de virtualização da VMware, Xen e Virtualbox.
Na versão gratuita do VMware, chamada VMware Player, você pode criar diversas máquinas virtuais para uso não comercial. Uma das maiores dificuldades que tive é em organizar onde as máquinas serão criadas. Eu normalmente coloco todas em um subdiretório assim fica fácil fazer backup delas.

Na GUI do VMware Player não existe uma opção para definir onde é a localização default das VMs.
Se você está utilizando linux, procure dentro do HOME do seu usuário o diretório .vmware (note que começa com ponto). Abra o arquivo ~/.vmware/preferences e acrescente a seguinte linha:

prefvmx.defaultvmpath = /<seu diretório>

Salve o arquivo, reinicie o VMware Player. Pronto, agora quando você for criar uma nova VM você será direcionado para o diretório que você definiu.

No Windows é necessário acrescentar a mesma linha, contudo o caminho completo do arquivo de preferências é: %Appdata%\VMware\preferences.ini.

Componentes conectados em Grafos

2016-10-30T07:57:00.000-02:00

Em um grafo não-direcionado G, dois vértices u e v são ditos conectados se G contém um caminho de u para v. Senão, eles são chamados de desconectados. Um grafo orientado (ou direcionado) é chamado de fracamente conectado se a substituição de todas as suas arestas direcionadas por arestas não direcionadas produz um grafo (não-direcionado) conectado. Ele é chamado de conectado se possui um caminho direcionado de u para v ou um caminho direcionado de v para u para cada par de vértices u, v. Ele é fortemente conexo se contém um caminho direto de u para v e um caminho direto v para u para cada par de vértices u, v. Um vértice de corte de um grafo conexo G é um conjunto de vértices que quando removidos torna G desconexo.

Um grafo não direcionado é conectado se cada par de vértices está conectado por um caminho. Os componentes conectados são as porções conectadas de um grafo. Um grafo não direcionado é conectado se ele tem exatamente um componente conectado.
Os componentes fortemente conexos são os subgrafos maximais fortemente conectados.

Os componentes fortemente conectados de um grafo direcionado são conjuntos de vértices sob a relação “são mutuamente alcançáveis”.

Por exemplo {0, 1, 2, 3}, {4} e {5} são os componentes fortemente conectados, {4, 5} não o é, pois o vértice 5 não é alcançável a partir do vértice 4.

O Algoritmo para achar estes componentes é:

Aplicar a busca em profundidade no grafo G para obter os tempos de término t[u] para cada vértice u.
Obter o grafo G', que é o grafo transposto, isto é, são os mesmos vértices mas as arestas são invertidas. Assim existe uma arestas (u,v) em G' se existe uma aresta (v,u) em G.
Aplicar a busca em profundidade no grafo G' realizando a busca a partir do vértice de maior t[u] obtido na linha 1.
Se a busca em profundidade não alcançar todos os vértices, inicie uma nova busca em profundidade a partir do vértice de maior t[u] dentre os vértices restantes.
Retornar os vértices de cada árvore da floresta obtida na busca em profundidade na linha 3 como um componente fortemente conectado separado.

Ativando Wi-Fi no Raspberry PI 2/3 usando a linha de comando

2016-09-22T18:43:00.002-03:00

Para rodar o wifi (contando que o driver da placa wifi tenha sido reconhecida e carregada), você precisa do wpa_supplicant. Ele pode ser instalado usando

sudo apt-get instal wpa_supplicant.

Você pode tentar seguir o guia do site do Raspberry Pi. No meu caso o guia não funcionou pois ele considera a alteração no arquivo /etc/network/interfaces, mas no meu Pi esta alteração não tem efeito.

1) criar o arquivo de configuração do wpa_supplicant
Você terá que editar (criar) o arquivo /etc/wpa_supplicant/wpa_supplicant.conf. Ele deverá ter no mínimo as linhas abaixo.

country=BR
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
ssid="SSID do seu AP"
psk="senha do seu AP"
}

Edite as linhas SSID e psk para conter o nome da sua rede sem fio (ESSID) e a senha da rede.

2) criar um script para rodar o wpa_supplicant. No meu caso eu coloquei em /etc/init.d/wpa_supplicant. Veja no script que está indicado a interface wlan0 onde será feita a conexão. No caso do seu Pi, você tem que configurar para o nome correto da interface.

#! /bin/sh

### BEGIN INIT INFO

# Provides: wpa_supplicant

# Required-Start: $local_fs $syslog $remote_fs dbus

# Required-Stop: $local_fs $syslog $remote_fs

# Default-Start: 2 3 4 5

# Default-Stop: 0 1 6

# Short-Description: Start wpa_supplicant daemon

### END INIT INFO

# este script não estava rodando nos diretorios rcX.d

# ele deveria ficar ativo usando

# update_rc.d wpa_supplicant enable

# contudo apesar de criar os links ele não funcionou

# para ativá-lo eu tive que chamar o script em /etc/rc.local

DAEMON=/sbin/wpa_supplicant

DESC="wpa_supplicant wlan0"

CONF=/etc/wpa_supplicant/wpa_supplicant.conf

test -f $DAEMON || exit 0

# FIXME: any of the sourced files may fail if/with syntax errors

test -f $CONF

case $1 in

start)

echo "Starting $DESC"

$DAEMON -i wlan0 -c $CONF -B

;;

stop)

echo "Stopping $DESC"

pkill wpa_supplicant

;;

restart|force-reload)

$0 stop

sleep 1

$0 start

;;

echo "Usage: $0 {start|stop|restart}" >&2

exit 1

;;

esac

exit 0

3) alterar o arquivo /etc/rc.local para chamar o script criado no passo (2). No meu caso eu simplesmente inseri a linha abaixo

/etc/init.d/wpa_supplicant start

Não é necessária nenhuma outra configuração. Meu arquivo /etc/network/interfaces possui 3 linhas relacionadas com wlan0, contudo elas não fazem efeito real. Reproduzo abaixo somente para vocês verem o que são.

allow-hotplug wlan0

iface wlan0 inet manual

wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

Bug PCManFM - Não abre o terminal

2016-09-06T14:24:00.001-03:00

Se você é como eu e usa bastante o terminal no linux, tem uma característica interessante que é abrir o terminal no diretório corrente dentro do navegador. O Ubuntu é possível adicional ao menu de contexto uma opção "Abrir no terminal". Para isto basta instalar esta opção ao Nautilus:

sudo apt-get install nautilus-open-terminal

Basta reiniciar o nautilus com (nautilus -q) para que a opção já esteja ativa.

Contudo se você utiliza o LUbuntu, o navegador é o PCManFM. Ele tem está opção no menu de ferramenta que é acionada via teclado usando <F4>. Contudo ela tem um bug.

A instalação padrão não abre diretórios com espaços como no meu exemplo da "Área de Trabalho". Esta opção de menu aciona um script que está no arquivo /usr/bin/

lxsession-default-terminal. Dentro deste script vemos que a variável $PWD não está entre aspas. Basta consertar como na imagem abaixo e pronto. O <F4> funciona.

Instalando owncloud no Raspberry PI 2

2016-07-03T08:29:00.005-03:00

Neste nosso post, vou mostrar como instalar o owncloud no seu raspberry pi 2. Eu já vi alguns locais mostrando a instalação e não achei que estavam completos, sempre faltava alguma coisa que a gente tinha que adivinhar.

Assim vamos começar com uma instalação a partir do zero, isto é, baixamos o raspbian jesse lite do site (https://www.raspberrypi.org/downloads/). Nossa escolha pela versão Lite é que assim temos uma instalação limpa com poucos programas instalados. Esta versão não tem nem mesmo a interface gráfica. Desta forma ganhamos também em desempenho, pois não tem programas que não precisamos rodando no PI2.

Instalando imagem

No nosso caso estamos usando Windows, desta forma precisamos de um aplicativo para copiar o Jesse para dentro do miniSD. O procedimento em raspberry é bastante eficiente. Basicamente você tem que baixar o programa Win32DiskImager do site da Sourceforge e instalá-lo no seu comptuador. Depois de instalado, basta rodar, selecionar a imagem que você fez download (normalmente a iamgem baixada está zipada, portanto você tem que descompactar), selecionar a unidade onde está o miniSD e selecionar a opção de WRITE. Quando acabar a cópia, basta remover o SD e colocá-lo no PI2.

Rodando o PI pela primeira vez

Ligue o seu PI2. Ele dará o boot e você poderá entrar. O usuário padrão é pi com a senha raspberry. Você pode configurar as opções regionais usando o comando sudo raspi-config. O raspi-config apresenta uma tela como a mostrada abaixo:

No meu caso eu começei para trocar as opções de locale para pt-BR.UTF-8, o timezone para São Paulo, o layout para brasileiro e Wifi country para BR. Neste post não mostro o uso do Wifi, fica para uma outra oportunidade. Nossa conexão foi ethernet.

Também aproveitei para trocar o nome do host. Por default o SSH server está habilitado, se no seu caso não estiver também é nesta opção que podemos ativá-lo.

Aparentemente as novas versões do Raspian (a minha é Jesse) já fazem durante a inicialização a expansão do filesystem para ocupar todo o seu cartão SD. O meu por exemplo tem 32GB e já foi totalmente reconhecido pelo PI2. Se no seu caso isto não ocorrer e você quiser aumentar o espaço, use a opção (1) do menu de opções avançadas do raspi-config.

Instalações adicionais e configuração inicial

Para usar o owncloud é necessário ter um servidor web instalado. Iremos usar o NGINX que é bem leve e funciona com o PI2. Iniciamos configurando o usuário:

$ sudo usermod -a -G www-data www-data

Agora precisamos instalar uns pacotes que incluem o nginx, php5, sqlite, certificados, php5-fpm etc. Demora um pouco esta atualização. Pode ser que você tenha um update primeiro.

$ sudo sudo apt-get update

$ sudo sudo apt-get install curl libapr1 libcurl4-openssl-dev libtool memcached nginx openssl php-apc php-pear php5 php5-curl php5-cgi php5-cli php5-dev php5-fpm php5-gd php5-imagick php5-intl php5-json php5-mcrypt php5-sqlite php5-common php5-memcache php-xml-parser sqlite sqlite3 ssl-cert varnish

Vamos criar um certificado SSL. Note que estamos criando um certificado válido por 3 anos (se você quiser mudar o tempo basta alterar 1095 para a quantidade de dias desejada). Você precisará preencher uma perguntas durante a execução da criação do certificado. O comando abaixo irá gerar uma chave RSA de 2048 bits. Você pode dar uma olhada em https://www.openssl.org/docs/manmaster/apps/req.html para mais opções.

$ sudo openssl req $@-new -x509 -days 1095 -nodes -out /etc/nginx/cert.pem -keyout /etc/nginx/cert.key

Modifique as permissões para garantir segurança.

$ sudo chmod 600 /etc/nginx/cert.pem

$ sudo chmod 600 /etc/nginx/cert.key

Eu alterei meu arquivo /etc/hosts para poder chamar o meu PI2 de pi-owncloud.

Altere o arquivo /etc/php5/fpm/php.ini:

Ache upload_max_filesize e troque o valor para 2000M
Ache post_max_size e troque o valor para 2000M

Grave o arquivo alterado. Isto vai permitir transferências de arquivos de 2GB (este é o limite).

Altere o arquivo /etc/php5/fpm/pool.d/www.conf. Ache a linha:

listen = /var/run/php5-fpm.sock

e troque para

listen = 127.0.0.1:9000

Grave o arquivo.

Abra o arquivo /etc/dphys-swapfile e altere a linha contendo:

CONF_SWAPSIZE=100

para

CONF_SWAPSIZE=512

Grave o arquivo.

Vamos ativar o fpm:

$ sudo update-rc.d php5-fpm enable

Altere o arquivo /etc/nginx/site-available/default (este é o conteúdo completo do meu arquivo de configuração):

upstream php-handler {
# para usar php5-fpm
server 127.0.0.1:9000;
#server unix:/var/run/php5-fpm.sock;
}

server {
listen 80;
server_name pi-owncloud;
# garante que será https
# fazendo um redirecionamento
return 301 https://$server_name$request_uri;
}

server {
# SSL configuration (ipv4 e ipv6)
listen 443 ssl ;
listen [::]:443 ssl ;

ssl_certificate /etc/nginx/cert.pem;
ssl_certificate_key /etc/nginx/cert.key;

root /var/www/owncloud;

# Add index.php to the list if you are using PHP
index index.php

server_name _;

add_header X-Content-Type-Options nosniff;
add_header X-Frame-Options "SAMEORIGIN";
  add_header X-XSS-Protection "1; mode=block";
  add_header X-Robots-Tag none;
  add_header X-Download-Options noopen;
add_header X-Permitted-Cross-Domain-Policies none;

location = /robots.txt {
allow all;
  log_not_found off;
  access_log off;
}

# alterar o "max upload size"
client_max_body_size 2000M;
Fastcgi_buffers 64 4K;

# Disable gzip to avoid the removal of the ETag header
gzip off;

location / {
# garante que sempre será chamado o index.php
rewrite ^ /index.php$uri;
}

location ~ ^/(?:build|tests|config|lib|3rdparty|templates|data)/ {
  deny all;
}

location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) {
  deny all;
}

location ~
^/(?:index|remote|public|cron|core/ajax/update|status|ocs/v[12]|updater/.+|ocs-provider/.+|core/templates/40[34])\.php(?:$|/) {

  include fastcgi_params;
  fastcgi_split_path_info ^(.+\.php)(/.+)$;
  fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
  fastcgi_param PATH_INFO $fastcgi_path_info;
  fastcgi_param HTTPS on;
  #Avoid sending the security headers twice
  fastcgi_param modHeadersAvailable true;
  fastcgi_param front_controller_active true;
  fastcgi_pass php-handler;
  fastcgi_intercept_errors on;
}

location ~ ^/(?:updater|ocs-provider)(?:$|/) {
  try_files $uri/ =404;
  index index.php;
}

# Adding the cache control header for js and css files
# Make sure it is BELOW the PHP block
location ~* \.(?:css|js)$ {
  try_files $uri /index.php$uri$is_args$args;
  add_header Cache-Control "public, max-age=7200";
  # Add headers to serve security related headers (It is intended
  # to have those duplicated to the ones above)
# Before enabling Strict-Transport-Security headers please
# read into this topic first.
add_header Strict-Transport-Security "max-age=15768000;
  # includeSubDomains; preload;";
  add_header X-Content-Type-Options nosniff;
  add_header X-Frame-Options "SAMEORIGIN";
  add_header X-XSS-Protection "1; mode=block";
  add_header X-Robots-Tag none;
  add_header X-Download-Options noopen;
  add_header X-Permitted-Cross-Domain-Policies none;

  # Optional: Don't log access to assets
  access_log off;
}

location ~* \.(?:svg|gif|png|html|ttf|woff|ico|jpg|jpeg)$ {
  try_files $uri /index.php$uri$is_args$args;
  # Optional: Don't log access to other assets
  access_log off;
}
}

Note que na minha configuração o owncloud ficará em /var/www/owncloud.
Se você quiser mais informações olhe em na documentação do owncloud, ela é bastante precisa.

Instalando owncloud

Faça o download do ownload no site https://owncloud.org/install/.
O meu caso estou utilizando a versão 9.0.3.
As linhas abaixo copiam o owncloud zipado do site para dentro do diretório tmp, descompactam os arquivos no diretório owncloud. Move este diretório para dentro do diretório onde ele irá rodar e acerta as permissões. No meu caso o diretório final será /var/www/owncloud. E por fim apaga o download.

$ cd /tmp

$ wget https://download.owncloud.org/community/owncloud-9.0.3.tar.bz2

$ tar xvf owncloud-9.0.3.tar.bz2

$ sudo mv owncloud/ /var/www/

$ sudo chown -R www-data:www-data /var/www

$ rm -rf owncloud*

$ sudo mkdir -p /var/owncloud/data

$ sudo chown -R www-data:www-data /var/owncloud/data

É necessário fazer uma alteração do arquivo /etc/php5/fpm/pool.d/www.conf. Localize as linhas abaixo de descomente. A linha contendo env[PATH] deve conter o resultado de echo $PATH no shell.

; Pass environment variables like LD_LIBRARY_PATH.
; All $VARIABLEs are taken from
; the current environment.
; Default Value: clean env
env[HOSTNAME] = $HOSTNAME

env[PATH] = /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/games:/usr/games

env[TMP] = /tmp
env[TMPDIR] = /tmp
env[TEMP] = /tmp

Reinicie o PI2.

A configuração agora é feita via web. No meu caso https://192.168.10.12.
Se você tentar acessar via http, você será redirecionado para https. O meu navegador (chrome) apresenta a seguinte tela ao tentar acesso:

É necessário aceitar a exceção para entrar o owncloud:

Você deve preencher o nome do primeiro usuário (e que será o administrador) do owncloud. Digite a senha (tem um bug que às vezes indica que sua senha é fraca mesmo quando não é - veja meu exemplo). Você pode escolher qualquer senha. Você precisa clicar em "Armazenamento & Banco de dados" para poder indicar onde os dados do owncloud ficarão. No meu caso usei o diretório que criamos no passo inicial (/var/owncloud/data).

Se você quiser criar seu armazenamento em um pendrive sugiro dar uma olhada neste tutorial. Ele tem um passo a passo da instalação do owncloud (com apenas uns passos faltando), mas tem uma parte bacana sobre como montar automaticamente o pendrive (e com NTFS). Se você for utilizar fat, basta trocar a opção ntfs-3g do fstab que ele mostra para vfat.

Após clicar em "Concluir configuração", será aberta a tela inicial do owncloud.

No menu no alto à esquerda, onde está escrito "pi" na minha tela abaixo, você encontrará a opção de administração que permite criar novos usuários.

Aproveite...

Instalando Hadoop

2016-01-28T15:58:00.001-02:00

Recentemente tive que instalar o Hadoop para um projeto de computação. O Hadoop é uma plataforma de software em Java de computação distribuída voltada para clusters e processamento de grandes massas de dados desenvolvida pelo Apache.

Hadoop possui diversos módulos. Hadoop Common contém as bibliotecas e arquivos comuns utiizados pelos outros os módulos Hadoop. Neste exemplo utilizaremos um sistema de arquivos distribuído que armazena dados em máquinas dentro do cluster, sob demanda, denominado Hadoop Distributed File System ou HDFS.

Hadoop fornece uma plataforma de gerenciamento de recursos responsável pelo gerenciamento dos recursos computacionais do cluster e pelo agendamento dos recursos, denominado Hadoop Yarn. O framework YARN no Hadoop permite utilizar o MapReduce para processsamento de grandes quantidades de dados.

A documentação do Hadoop pode ser achada aqui.

No nosso exemplo fazemos a instalação de 3 máquinas virtuais: uma computador mestre e dois escravos.

DP - Problema das k curvas

2015-12-21T14:58:00.002-02:00

Este problema consiste em contar o número de caminhos para chegar iniciando até parte inferior direita em uma matriz MxN realizando no máximo k curvas como mostrado na figura.

O que é uma curva?
Cada movimento que altera a direção é considerado uma curva, isto é,

se nós estávamos nos movendo ao longo da linha e passamos a nos mover ao longo da coluna
ou se estávamos nos movendo ao longo da coluna e agora passamos a mover ao longo da linha.

Podemos resolver este problema em tempo polinomial, utilizando uma matriz multidimensional com 4 dimensões para guardar a quantidade de caminho nas células considerando a quantidade de curvas e mudanças de direção.

O vídeo mostra como implementar a solução deste problema.

DP - Problema de mochila

2015-12-21T12:37:00.000-02:00

O problema da mochila é um problema de otimização combinatória. Isto que dizer que temos que trabalhar com diversas combinações e obter uma combinação que é ótima, ou seja, é a melhor segundo algum critério. O problema da mochila é um dos 21 problemas NP-completos de Richard Karp.

Este tipo de problema queremos preencher uma mochila com objetos de diferentes pesos e valores. O objetivo é preencher a mochila com o maior valor possível, contudo não podemos ultrapassar o peso máximo. Vemos portanto que formulação do problema é extremamente simples, porém sua solução é mais complexa.

No vídeo apresentamos como resolver esta versão da mochila.

Existem diversas variações do problema da mochila. Se você estiver curioso dê uma olhada na wikipedia.

DP - Sequência de Fibonacci

2015-12-21T11:05:00.003-02:00

A sequência de Fibonacci é uma sucessão de números que, misteriosamente, aparece em muitos fenômenos da natureza. Ela foi descrita no final do século 12 pelo italiano Leonardo Fibonacci. É uma sequência infinita que começa com 0 e 1 ou 1 e 1 (depende de onde você está lendo a informação). Os números seguintes são sempre a soma dos dois números anteriores. Portanto, depois de 0 e 1, vêm 1, 2, 3, 5, 8, 13, 21, 34…

Logo

F[1] = 1
F[2] = 1
F[n] = F[n-1] + F[n-2], para n > 3

Esta definição mostra claramente como podemos implementar a sequência usando recursividade, isto é, podemos criar uma função e chamá-la recursivamente para obter os valores F[n-1] e F[n-2] até chegar nos casos base que são F[1] e F[2].

Contudo podemos ver na figura abaixo que existe muito trabalho repetido. Podemos usar os recursos da programação dinâmica para melhorar o desempenho deste cálculo.

No vídeo vemos como implementar a sequência de Fibonacci usando recursividade e usando programação dinâmica.

DP - Problema do Troco em Moedas

2015-10-25T21:02:00.001-02:00

Este problema pode ser enunciado como:

Dado um valor de troco N (um número inteiro no nosso exemplo).
Nós temos suprimento infinito de cada tipo de moeda do conjunto S = {S1, S2, .., SM}.
Note que temos portanto M tipos de moedas e teoricamente temos infinitas delas.
Quantas maneiras podemos combinar as moedas para obter um troco exato?
A ordem das moedas não importa.

Por exemplo temos que dar um troco de N = 4 dinheiros.
O conjunto de moedas que temos é S = {1,2,3}.
Podemos ver que existem quatro soluções: {1,1,1,1}, {1,1,2}, {2,2}, {1, 3}.
Assim a resposta do programa deve ser 4.

Este problema pode ser resolvido por DP. Identificamos as duas características:

1) Subestrutura ótima

Para contar soluções, podemos dividir todas as soluções em dois subconjuntos:
a) Todas as soluções que não contêm moeda "i" (ou seja Si).
b) As soluções que contêm pelo menos uma moeda Si.
Desta forma podemos escrever o problema de contagem como

C(S, n) = C(S', n) + C(S, N-Si)

Onde S' = S - {Si}

Desta forma vemos que o problema tem a propriedade subestrutura ótima como o problema pode ser resolvido usando soluções de subproblemas. A equação e as condições abaixa deixam claro também que os problemas são sobrepostos.

Temos que notar que existem algumas condições:

a) C(S,0) = 1, pois se n=0 existe uma solução que não precisa de mais moedas
b) C(S,n) = 0, se n<0, pois n negativo, não há uma solução do problema (subtraiu demais)
c) C(S,n) = 0, se S = {} e n > 0, pois se não temos moedas para dar um troco "n" (já que n é maior que zero), não tem como acharmos uma solução.

O que falta no exemplo acima? Se você falou a memorização dos dados... acertou!

A memorização aumenta bastante a velocidade, uma vez que não precisamos recalcular.

Programação Dinâmica

2015-10-25T20:54:00.002-02:00

Em computação a programação dinâmica é um método utilizado para a construção de algoritmos capazes de resolver problemas computacionais. Este método é aplicável aos problemas cuja solução ótima pode ser computada a partir da solução ótima previamente calculada e memorizada.
A solução anterior é memorizada para evitar recálculo.
Desta forma a programação dinâmica ou DP (Dynamic Programming) resolve um problema a partir de subproblemas que sobrepostos compõem o problema original.

Um problema computacional pode ser resolvido por DP se possuir duas características denominadas (1) subestrutura ótima e (2) superposição de subproblemas. Um problema apresenta uma subestrutura ótima quando uma solução para o problema contém em seu interior soluções para subproblemas - isto é temos a mesma fórmula de recorrência. A superposição de subproblemas acontece quando um algoritmo recursivo reexamina o mesmo problema muitas vezes - é aí que entra a memorização.

A DP não é uma forma intuitiva de pensar, portanto temos que ver diversos exemplos para conseguir compreender e assimilar como ela trabalha. Vou criar a partir de agora um conjunto de posts que mostram como solucionar alguns problemas usado DP. Estes posts virão com uma implementação completa em Java para o problema. O primeiro da série busca descobrir de quantas maneiras é possível dar um troco (N) utilizando um determinado conjunto de moedas.

Versão inicial do livro Padrões em Java está disponível para download

2015-07-29T12:32:00.004-03:00

Um versão inicial do livro sobre uso de Padrões em Java está disponível para download no endereço https://goo.gl/smbjtX. Este livro mostra alguns padrões de projeto que eu utilizei com mais frequência neste Blog. O livro está sendo distribuído com a licença Creative Commons.

Aproveitem a leitura e mandem sugestões. ;-)))

Lançamento da primeira versão do livro Introdução ao Java

2015-07-29T12:30:00.002-03:00

Um versão inicial do livro Introdução ao Java está disponível para download no endereço https://goo.gl/paqpmv. Neste livro faço um apanhado condensado das informações e vídeos que posto neste Blog sobre a utilização da linguagem Java. O livro está sendo distribuído com a licença Creative Commons.

O material ainda não está completo. Vocês verão dois grandes capítulos ainda não escritos. Este livro também não foi sujeito a revisão, portanto cuidado com os erros de português. Toda sugestão será bem vinda.

Boa leitura!!!

Melhorando o mergesort

2015-07-24T17:23:00.002-03:00

Apresentamos em um post antigo denominado Recursividade - Parte 2 ou MergeSort como implementar um algoritmo bastante eficiente de ordenação. Este algoritmo é o mergesort que usa o método de dividir para conquistar. Como o mergesort dividi a lista de elementos que devem ser ordenados em sublistas, podemos melhorar um pouco o desempenho em ambientes de multiprocessamento. Como? Fazendo que as sublistas sejam processadas em paralelo pelos diversos processadores que possuímos.

Vamos ver no vídeo como podemos implementar threads com mergesort para torná-lo mais rápido via paralelismo. Note que não estamos alterando o número de operações, portanto a complexidade do algoritmo é a mesma.

Usando sua webcam com Java

2015-07-06T16:03:00.001-03:00

Neste post veremos como criar um programa capaz de acessar sua webcam.

Criando um cronometro simples em Java

2015-07-06T16:01:00.000-03:00

Recentemente precisei de um cronômetro e (para variar) o Windows não tinha. Então resolvi fazer uma classe em Java que implementasse o cronômetro na tela. Precisava somente de um cronômetro simples, que ao clicar em "Iniciar" começasse a contar o tempo (em segundos) e que eu pudesse parar.

A classe que implementa o cronômetro pode ser vista no vídeo. É interessante perceber que é necessário mobilizar um monte de coisas para fazer o cronômetro funcionar:

precisamos criar uma interface gráfica que utiliza JFrame, JPanel, JLabel e JButton para permitir a comunicação com o usuário
para criar os tratadores dos botões, isto é, os procedimentos que devem ser executados quando clicamos nos botões utilizamos uma classe ActionListener anônima na qual alteramos o método actionPerformed
precisamos criar uma thread de timer capaz de ser disparada a cada "x" segundos, ou no nosso caso milissegundos
para o timer funcionar temos que criar outra classe anônima que implementa TimerTask.

Redução de Dimensões - Parte B

2015-04-19T21:21:00.002-03:00

No post anterior sobre Redução de Dimensionalidade apresentamos somente os conceitos teóricos para realizar da redução. Neste novo post apresentamos um código em Java que faz SVD (Singular Value Decomposition).

O desenvolvimento deste exemplo foi bastante simplificado ao usarmos o pacote JAMA, desenvolvido pelo NIST, que permite a realização de diversas operações sobre matrizes em Java. Mais informações sobre o pacote veja no site do Jama.

Introdução da Programação de Computadores - Capítulo 6

2015-03-10T18:01:00.002-03:00

Vimos no post anterior (do capítulo 5) como utilizar vetores, que são arranjos como um conjunto de n valores de um mesmo tipo. Podemos expandir este conceito considerando que estes valores podem ser arranjados em diversas dimensões, sendo a mais comum o arranjo bidimensional ou matriz bidimensional. Uma matriz bidimensional pode ser utilizada por exemplo para representar um conjunto de valores de uma tabela por exemplo.

Como veremos no vídeo, uma matriz é basicamente um vetor onde cada elemento é por sua vez um vetor, desta forma podemos obter uma matriz retangular como em

int[][] retangular = new int[3][4]; // matriz com 3 linhas e 4 colunas

mas também podemos criar uma matriz irregular como

int[][] retangular = new int[3]; //
retangular[0] = new int[5];
retangular[1] = new int[10];

retangular[2] = new int[2];

A primeira linha gera uma matriz com 3 linhas, porém as colunas ainda não estão definidas. As três linhas seguintes geram as colunas de cada linha - na segunda linha de código a primeira linha é configurada para possuir 5 colunas, depois a segunda com 10 e na última linha de código a terceira linha terá 2 elementos.

Introdução da Programação de Computadores - Capítulo 5

2015-03-10T17:51:00.001-03:00

Um vetor (array) é um objeto que contém um número fixo de valores de um único tipo. O tamanho de um vetor é estabelecido quando o array é criado. Após a criação, este tamanho é fixo e não pode ser mudado. Cada item em um vetor é denominado elemento. Cada elemento pode ser acessado por um índice numérico. A numeração de um vetor começa com 0.

Veja o vídeo a seguir:

Exemplo 01

Exemplo 02

Vamos fazer uma variação deste exemplo para mostrar que é possível criar um array não somente dos tipos primitivos (int, double, char...), mas de qualquer classe de desejarmos. Veja o Exemplo 02-a.

Exemplo 03

Exemplo 04

Exemplo 05

Introdução da Programação de Computadores - Capítulo 4

2015-01-08T08:14:00.001-02:00

Estruturas de repetição

Neste post trataremos de 3 estruturas de repetição em Java. Um problema com estruturas de repetição é o que chamamos de looping infinito, isto ocorre devido ao fato do bloco de programa desta estrutura fica repetindo a mesma sequência de códigos esperando por um resultado que nunca irá acontecer. Por isto devemos garantir que a variável que controla o loop seja alterada.

A primeira estrutura que veremos é for. Esta é a instrução mais comum e tem o formato apresentado abaixo. A expressão de inicialização inicializa o laço for; ele é executado uma vez, antes da primeira execução do bloco de comandos. A expressão de incremento é chamada após cada iteração do loop for. É perfeitamente aceitável esta expressão aumentar ou diminuir a variável de controle. O bloco de comandos será executado enquanto a condição de comparação for verdadeira. Quando a expressão avaliada na comparação for falsa, o loop termina.

for(inicialização; comparação; incremento) {
bloco de comandos;
}

for(inicialização; comparação; incremento)
instrução;

Outra estrutura de repetição é while. While executa uma comparação com a variável. Se a comparação for verdadeira, ele executa o bloco de instruções ( entre { } ) ou apenas a próxima linha de código logo abaixo (se não houver o bloco entre {} ). O bloco de comandos será executado enquanto a condição de comparação for verdadeira.

while (comparação) {
bloco de comandos;
}

while (comparação)
  instrução;

A terceira estrutura é denominado do ... while. É similar ao while, porém a comparação é realizada somente no final, desta forma o bloco será executado pelo menos uma vez. O bloco de comandos será executado enquanto a condição de comparação for verdadeira.

do {
  bloco de comandos;
} while (comparação);

do
  instrução;
while (comparação);