Django – Primeiros passos

Após instalar o Django, o mysql e o driver do mysql, chegou a hora de criar o projeto. Todos os passos citados estão bem explicados nesse link http://www.djangobook.com/en/2.0/chapter02/, então não reescreverei esse monte de coisas.

Achei muito rápido e fácil instalar e deixar tudo rodando. Ainda não estou usando nenhuma IDE para programar ou criar os projetos, então seguindo o material que citei acima, fui criando tudo apenas pela linha de comando.

A primeira coisa que me deixou feliz foi o fato de que, assim como outros frameworks de linguagens dinâmicas, o Django já trás consigo um Development Server onde se pode executar/testar o projeto. Então, não há todo aquele martirio que é criar um projeto Java por exemplo. Sair configurando o App Server, gerar alguns xmls, etc, etc, etc.

Eu realmente gosto desse tipo de agilidade. Ganha-se muito tempo no começo do projeto.

E para subir esse server, basta executar o comando “python manage.py runserver” de dentro do projeto criado nos passos anteriores. Então basta acessar http://127.0.0.1:8000/ e conferir e mensagem “It worked! Congratulations on your first Django-powered page”!

Simples, rápido e indolor!

Caso queira mudar a porta do server, é só rodar o comando “python manage.py runserver XXXX“, onde XXXX é a nova porta que o servidor vai ‘escutar’. Ainda, se quiser que o seu projeto fique acessível por toda sua rede, ou seja, não somente localmente, você pode digitar o comando: “python manage.py runserver 0.0.0.0:8000” .

Desse modo, qualquer pessoa em sua rede poderá acessar o seu projeto (você só precisará informá-los o seu IP )

Ref: http://www.djangobook.com/

CommonJ: Usando threads gerenciadas pelo container

Com a relativa baixa de preço dos computadores multiprocessados, tem-se tornado mais comum a construção de aplicações concorrentes ou multi-threads para aproveitar todo o poder que esse tipo de hardware tem. Mas não vou falar sobre os benéficos ou malefícios de programação concorrente, ou da linha do tempo dos processadores, mas sim falarei de um assunto mais específico: uma API que permite usar managed threads, ou seja, threads que são gerenciadas pelo container.

A tal API que me refiro é a CommonJ.

CommonJ é uma especificação criada em conjunto pela IBM e BEA para permitir o uso de programação concorrente em aplicações rodando sob seus respectivos Applications Servers (ou qualquer outro que implemente a especificação), de maneira que o container tenhavisibilidade dessas threads, sendo possível oferecer para elas todos os serviços oferecidos para componentes gerenciados, como controle de transações, segurança, etc.

Em 2003, essa especificação foi submetida ao JCP pela IBM e BEA para se tornar parte do JEE. O processo pode ser acompanhado em http://jcp.org/en/jsr/detail?id=237

O CommonJ é também conhecida como ‘The Timer and Work Manager API’. Mas a parte que nos interessa por enquanto é apenas a ‘Work Manager’.

As principais interfaces

Essa API é muito simples e muito fácil de utilizar. Para um breve entendimento, citarei suas principais interfaces e seu propósito principal. Serei breve pois uma descrição mais detalhada pode ser encontrada nos Javadocs da mesma.

Vamos lá:

WorkManager

É uma das principais interfaces e oferece uma séria de métodos para schedule de threads (aqui chamada de Work).

Caso use Spring Framework, o mesmo possui uma boa abstração para o uso dessa interface. Com isso, a aplicação cliente nem mesmo tem ciência da existencia de uma API chamada CommonJ.

Caso não esteja usando o Spring, você pode obter uma instância do WorkManager programaticamente através de JNDI.

Em ambos os casos, é preciso que o administrador do Application Server configure o WorkManager antes de sua utilização.

Work

Essa interface extende a interface Runnable do Java, então na prática ela será ’sua thread’*.

WorkItem

Esse objeto é usado para se determinar o status de uma determinada thread (Work). Quando se submente um Work para um WorkManager, este último sempre retorna um WorkItem.

Existem ainda outras interfaces que não citarei por enquanto, para nosso propósito essas são suficientes.

Na próxima parte começarei a parte mais legal: códigos! Mostrarei exemplos de como utilizar essa API e mostrarei também como configurá-la no Spring Framework.

Ref:

http://e-docs.bea.com/wls/docs92/commonj/commonj.html

Python on the desk

A idéia inicial com esse blog era escrever um pouco sobre meu aprendizado em Ruby (e Rails). Porém, o tempo passou e acabei não dando a atenção/tempo que eu planejava para esse fim – aprender e escrever.

Já que agora estou com um pouco mais de tempo livre no trabalho, vou prosseguir com meus estudos, porém, não mais focados apenas em Ruby.

Vou começar a estudar algumas linguagens dinâmicas, como Python, Groovy, Scala e o próprio Ruby, porém vou mudar um pouco a ordem de estudo. Vou começar a estudar Python, por duas razões: a primeira é que tenho amigos que programam e gostam da linguagem e a segunda é por causa de famoso Django (pretendo falar dele em posts futuros).

Comecei essa semana a dar uma estudada na estrutura da linguagem, brincar um pouco no prompt, etc. Achei a sintaxe muito simples e ‘limpa’. Não vou escrever detalhes sobre comandos/sintaxe, porque existem milhares de tutoriais na internet, estou deixando apenas minha primeira impressão aqui.

Bom, por enquanto é isso, aos poucos posto coisas mais uteis.

Print Screen com Java

Outro dia precisei fazer um print screen com java, e demorei alguns minutos para achar no Google um exemplinho bacana. Então, resolvi postar aqui o que fiz. Não vou explicar o código, apenas deixarei alguns likns para o javadoc. Espero que ajude alguém apressado como eu.

Bom, vamos ao código:

public void takeAPrint() throws Exception{

Toolkit toolkit = Toolkit.getDefaultToolkit();
//Definindo a dimensão que quer capturar
//pode ser definido o tamanho que desejar
Dimension screenSize = toolkit.getScreenSize();
Rectangle screenRect = new Rectangle(screenSize);
// criando o print screen
Robot robot = new Robot();
BufferedImage screenCapturedImage = robot.createScreenCapture(screenRect);

//depois disso é só procurar a imagem no local indicado abaixo, no meu caso em:
// /Users/rodrigogomes/printScreen.png
//Aqui você pode alterar o formato da imagem para, por exemplo, JPG
//É só mudar o “png” para “jpg” e pronto
ImageIO.write(screenCapturedImage, “png”, new File(”/Users/rodrigogomes/printScreen.png”));

}

Espero que ajude alguém.

Refs:

http://java.sun.com/j2se/1.5.0/docs/api/java/awt/Rectangle.html

http://java.sun.com/j2se/1.5.0/docs/api/java/awt/image/BufferedImage.html

http://java.sun.com/j2se/1.5.0/docs/api/javax/imageio/ImageIO.html

http://java.sun.com/j2se/1.5.0/docs/api/java/awt/Robot.html#createScreenCapture(java.awt.Rectangle)

ps:ainda não descobri como colocar o código bonitinho nesse troço. Assim que descobrir eu deixo mais bonitinho rs

Ruby On Rails Executando

Há algum tempo venho lendo sobre Ruby e sobre Rails também mas nunca parei para fuçar mais a fundo. Entretando, porem, todavia, essa semana comecei a ler um livrinho sobre Rails. Esse aqui
(Sim, é a versão traduzida deste. Não ia gastar o dobro só porque o outro é o original. Ainda mais que é um livro que vai ter uma vida curta).

O legal e o que me chamou atenção nesse livro foram os dizeres:

“Você já ouviu tudo sobre Ruby on Rails e quer começar a aprende-lo. Aqui está o livro que você precisa: uma introdução rápida e sem papo-furado que mostra como criar aplicações reais”.

Eu não ouvir falar tudo sobre Rails mas gostei bastante da parte que diz “sem papo-furado”.
Era isso que eu queria, ver logo a coisa funcionando sem lenga lenga. Pelo menos por enquanto é isso que preciso.

Já quase terminei de ler o dito cujo, e não achei a tradução tão ruim. Pelo menos não traduziram Active Record para Registro Ativo como o outro aqui fez.

Enfim, o que tenho para falar é: Rails é show de bola! Para quem não está acostumando com linguagens dinamicas é uma forma bem diferente (e legal!!!) de se desenvolver.

Mas deixando a embromação de lado e indo direto ao ponto, o que pretendo fazer nos proximos posts é mostrar a quantidade de código criado/escrito para desenvolver uma aplicaçãozinha CRUD com Rails e com Java + alguns frameworks.

Tá bom, tá bom, não se deve comparar bananas com laranjas, mas quero mostrar essa comparação porque Java é o meu dia-a-dia e não conheço outros frameworks parecidos com o Rails. E, além disso, quero mostrar que em vez de ficarperdendo tempo com pequenas aplicações em Java, tendo que usar 216 frameworks só pra fazer um CRUD, pode-se ganharmuito usando uma abordagem mais simples e dinamica.

Então, até os proximos posts.

Olha eu ae!

Bom, como primeiro post, acho que nada mais justo do que uma breve apresentação.
Meu nome é Rodrigo de Paiva Gomes, moro em São Paulo e trabalho como Programador Java faz algum tempo.
Pronto, me apresentei .
O que pretendo com esse blog é compartilhar minhas experiencias e meu aprendizado (em tudo quanto é coisa). Vou falar um pouco sobre Java, minhas aventuras com Ruby (e Rails), entre outras coisas, e espero filosofar um pouco também.

Acho que por enquanto é só.