A simple demo using some techniques described in the post JavaFX side scrolling gaming.

Original ogg video: blackdot.ogg
Source (NetBeans project): BlackDot.tar.gz
Source (one file only): blackdot.fx
Java Web Start: launch.jnlp

Sim , mais um patch de correções do netBeans 6.1 está prestes a ser lançado... olhei a lista de bugs corrigidos e não vi nada MUITO grave, bem diferente do patch 2 que corrigiu coisas que deixavam o NetBeans simplesmente inutilizavel...

A lista de correções pode ser obtida aqui e aqui

Existe uma versão "beta" deste Patch... voce só precisa adicionar ao seu UpdateCenter este repositório: http://bits.netbeans.org/6.1/fixes/2008-08-12_03-59-31/uc/catalog.xml.gz

Este Patch está em fase final de testes e estará disponivel em breve, a data é 27 de agosto, isso se ninguem reportar algo a mais para o mesmo :)

ps: existe um bug conhecido na aplicação de patches em geral para que você não caia nisso de uma olhada aqui:  "Bubble can install different set of update than via Plugins."

 

 

I started to make several small JavaFX game demos. I’m doing that to fell where JavaFX is good to make this sort of game and what patterns would be frequently needed to implement, where I will place a little framework for fast development of simple casual games. What I’m calling now just ‘GameFX’. My first experiment was to creating a side scrolling animation that’s is usefull to create the parallax effect in side scrolling games. For that I created the class Slidding. You create an Slidding with a set of nodes and they will slide from right to left and when a node reaches the left side it back to the right side.

Example:

Slidding {
    content: [
       Circle {
           centerX: 100, centerY: 100, radius: 40
           fill: Color.RED
       },
       Circle {
           centerX: 300, centerY: 100, radius: 40
           fill: Color.BLUE
       }
    ]
    clock: 0.05s
 }

That produces:

You create a Slidding with a list of Nodes at content, a clock (that will determine the speed of that animation) and a width. If you don’t provide a width, the slidding will do the best effort to determine one. You can use this approach to create more complex scenarios, using more Slidding groups.

This is a example of that:

import javafx.application.*;
import javafx.animation.*;
import javafx.scene.geometry.*;
import javafx.scene.paint.*;
import javafx.scene.*;

import gamefx.Slidding;

var SCREENW = 500;
var SCREENH = 400;

/* the sky is a light blue rectangle */
var sky = Rectangle {
    width: SCREENW, height: SCREENH
    fill: LinearGradient {
        startX: 0.0 , startY: 0.0
        endX: 0.0, endY: 1.0
        proportional: true
        stops: [
            Stop { offset: 0.0 color: Color.LIGHTBLUE },
            Stop { offset: 0.7 color: Color.LIGHTYELLOW },
            Stop { offset: 1.0 color: Color.YELLOW }
        ]
    }
}

/* the ground is a olive rectangle */
var ground = Rectangle {
    translateY: 300
    width: 500, height: 100
    fill: LinearGradient {
        startX: 0.0 , startY: 0.0
        endX: 0.0, endY: 1.0
        proportional: true
        stops: [
            Stop { offset: 0.2 color: Color.OLIVE },
            Stop { offset: 1.0 color: Color.DARKOLIVEGREEN }
        ]
    }
}

/* a clod cloud is like an ellipse */
class Cloud extends Ellipse {
    override attribute radiusX = 50;
    override attribute radiusY = 25;
    override attribute fill = Color.WHITESMOKE;
    override attribute opacity = 0.5;
}

/* we create a slidding of clouds */
var clouds = Slidding {
    content: [
        Cloud{centerX: 100, centerY: 100},
        Cloud{centerX: 150, centerY:  20},
        Cloud{centerX: 220, centerY: 150},
        Cloud{centerX: 260, centerY: 200},
        Cloud{centerX: 310, centerY:  40},
        Cloud{centerX: 390, centerY: 150},
        Cloud{centerX: 450, centerY:  30},
        Cloud{centerX: 550, centerY: 100},
    ]
    clock: 0.2s
}

var SUNX = 100;
var SUNY = 300;
var rotation = 0;

/* the sun, with it's corona */
var sun = Group {
    rotate: bind rotation
    anchorX: SUNX, anchorY: SUNY
    content: [
        for (i in [0..11]) {
            Arc {
                centerX: SUNX, centerY: SUNY
                radiusX: 500, radiusY: 500
                startAngle: 2 * i * (360 / 24), length: 360 / 24
                type: ArcType.ROUND
                fill: Color.YELLOW
                opacity: 0.3
            }
        },
        Circle {
            centerX: SUNX, centerY: SUNY, radius: 60
            fill: Color.YELLOW
        },
    ]
}

/* animate the corona changing the it rotation angle */
var anim = Timeline {
    repeatCount: Timeline.INDEFINITE
    keyFrames : [
        KeyFrame {
            time : 0s
            values: rotation => 0.0 tween Interpolator.LINEAR
        },
        KeyFrame {
            time : 2s
            values: rotation => (360.0/12) tween Interpolator.LINEAR
        },
    ]
}
anim.start();

/* a tree is a simple polygon */
class Tree extends Polygon{
    public attribute x = 0;
    public attribute y = 0;
    override attribute points = [0,0, 10,30, -10,30];
    override attribute fill = Color.DARKOLIVEGREEN;
    init{
        translateX = x;
        translateY = y;
    }
}

/* a forest is a lot of trees */
var forest = Slidding{
    content: [
        Tree{x: 20, y: 320}, Tree{x: 80, y: 280}, Tree{x:120, y: 330},
        Tree{x:140, y: 280}, Tree{x:180, y: 310}, Tree{x:220, y: 320},
        Tree{x:260, y: 280}, Tree{x:280, y: 320}, Tree{x:300, y: 300},
        Tree{x:400, y: 320}, Tree{x:500, y: 280}, Tree{x:500, y: 320}
    ]
    clock: 0.1s
    width: SCREENW
}

Frame {
    title: "Side Scrolling"
    width: SCREENW
    height: SCREENH
    closeAction: function() {
        java.lang.System.exit( 0 );
    }
    visible: true

    stage: Stage {
        content: [sky, sun, clouds, ground, forest]
    }
}

Producing:

If you want to try these examples, place this Slidding implementation as Slidding.fx in a directory named gamefx, or grab here the NetBeans project.

package gamefx;

import javafx.scene.CustomNode;
import javafx.scene.Node;
import javafx.scene.Group;
import javafx.animation.Timeline;
import javafx.animation.KeyFrame;

/*
 * The slidding group of nodes for side scrolling animations.
 *
 * @example
 * Slidding {
 *    width: 300
 *    content: [
 *       Circle { centerX: 100, centerY: 100, radius: 40, fill: Color.RED },
 *       Circle { centerX: 200, centerY: 100, radius: 40, fill: Color.BLUE },
 *    ]
 *    clock: 0.05s
 * }
 */
public class Slidding extends CustomNode {
    public attribute content: Node[];
    public attribute clock = 0.1s;
    public attribute width: Number;

    public attribute autostart = true;
    public attribute cycle = true;

    public attribute anim = Timeline {
        repeatCount: Timeline.INDEFINITE
        keyFrames : [
            KeyFrame {
                time : clock
                action: function() {
                    for(node in content){
                        node.translateX--;
                        if (node.getX() + node.translateX + node.getWidth() <= 0){
                            if(cycle){
                                node.translateX = width - node.getX();
                            } else {
                                delete node from content;
                            }
                        }
                    }
                } // action
            } // keyframe
        ]
    } // timeline 

    public function create(): Node {
        // if width is not setted, we try to figure out
        if(width == 0) {
            for(node in content) {
                if(node.getX() + node.getWidth() > width) {
                    width = node.getX() + node.getWidth();
                }
            }
        }

        // normaly the slidding will start automaticaly
        if(autostart){
            anim.start();
        }

        // just a Group of Nodes
        return Group {
            content: content
        };
    }
}

Is not the final implementation but it’s a idea. Soon I’ll show a demo game I did using theses codes.

O Netbeans.org anunciou a disponibilidade do NetBeans IDE 6.5 Beta. Abaixo a tradução do anúncio:

O NetBeans IDE 6.5 introduz várias novas funcionalidades, incluindo uma IDE robusta para PHP, deputação de JavaScript para o Firefox e IE, e suporte a Groovy e Grails. Esse lançamento também inclui várias melhorias para o desenvolvimento em Java, Ruby e Rails, e C/C++. Dentre as melhorias no Java destacam-se: suporte nativo ao Hibernate, importação de projetos do Eclipse, e compilação no salvamento.

Links:

• Faça o Download
• Saiba Mais
• Tutoriais & Documentação

Outros destaques:

• PHP
  • Completação de código
  • Consertos rápidos e checagem semântica
  • Suporte a FTP
  • Depuração com Xdebug
  • Suporte a Web Services populares
• Ajax/JavaScript
  • Suporte a depuração no Firefox e IE
  • Monitoramento cliente de HTTP
  • Vêm com as bibliotecas mais populares de JavaScript
• Java
  • Suporte a Groovy/Grails
  • Compilação/Deploy no momento do salvamento
  • Importação e sincronização de projetos do Eclipse
  • Suporte nativo a Hibernate
  • Gerador de CRUD JSF agora com Ajax
• Banco de Dados
  • Melhorias no editor
• C/C++
  • Melhorias na completação de código e destaque de erros
  • Desenvolvimento remoto
• Ruby
  • Suporte aos Testes Ruby
  • Melhoria no suporte a Rake
• GlassFish V3 “Prelude”
  • Menor tamanho, inicialização e deployment mais rápido
  • Suporte a scripting, inclusive jRuby

O Beta Oficial do NetBeans 6.5 está disponível para Download :)

Baixe diretamente por aqui ! e veja as novidades aqui !

Bons Downloads !

 

 

 

One thing that I like a lot to do with JavaFX is draggable objects. Due to some recent changes in the JavaFX syntax my old codes for that are no longer working. Joshua Marinacci from Sun’s JavaFX engineering team and other guys from the JavaFX community gave me some tips. Here some strategies I’m using for making draggable nodes in JavaFX.

In this first example, a simple draggable ellipse.

video url: http://www.youtube.com/watch?v=pAJHH-mPLaQ

import javafx.application.*;
import javafx.scene.paint.*;
import javafx.scene.geometry.*;
import javafx.input.*;

Frame {
    width: 300, height: 300, visible: true
    stage: Stage {
        content: [
            Ellipse {
                var endX = 0.0; var endY = 0.0
                var startX = 0.0; var startY = 0.0
                centerX: 150, centerY: 150
                radiusX: 80, radiusY: 40
                fill: Color.ORANGE
                translateX: bind endX
                translateY: bind endY
                onMousePressed: function(e:MouseEvent):Void {
                    startX = e.getDragX()-endX;
                    startY = e.getDragY()-endY;
                }
                onMouseDragged: function(e:MouseEvent):Void {
                    endX = e.getDragX()-startX;
                    endY = e.getDragY()-startY;
                }
            }
        ]

    }
}

When you need to create a group of draggable objects, you can try thie approach of a draggable group like this. Inside on it, you can put whatever you want.

Video url: http://www.youtube.com/watch?v=mHOcPRrgQCQ

import javafx.application.*;
import javafx.scene.paint.*;
import javafx.scene.geometry.*;
import javafx.input.*;
import javafx.scene.*;
import javafx.scene.effect.*;
import javafx.scene.image.*;
import javafx.animation.*;

// a graggable group
public class DragGroup extends CustomNode{
    public attribute content: Node[];

    private attribute endX = 0.0;
    private attribute endY = 0.0;

    private attribute startX = 0.0;
    private attribute startY = 0.0;

    public function create(): Node {
        return Group{
            translateX: bind endX
            translateY: bind endY
            content: bind content
        }
    }

    override attribute onMousePressed = function(e:MouseEvent):Void {
        startX = e.getDragX()-endX;
        startY = e.getDragY()-endY;
    }

    override attribute onMouseDragged = function(e:MouseEvent):Void {
        endX = e.getDragX()-startX;
        endY = e.getDragY()-startY;
    }
}

// angle animation, cycles between 0 to 360 in 36 seconds
var angle = 0.0;
var angleAnimation = Timeline {
    repeatCount: Timeline.INDEFINITE
    keyFrames : [
        KeyFrame {
            time: 0s
            values:
                    angle => 0.0
        },
        KeyFrame{
            time: 36s
            values :
                    angle => 360.0 tween Interpolator.LINEAR
        }
    ]
}

// some pictures from my Flickr albums
var me    = "http://farm4.static.flickr.com/3042/2746737338_aa3041f283_m.jpg";

var dog   = "http://farm4.static.flickr.com/3184/2717290793_ec14c26a85_m.jpg";
var plant = "http://farm4.static.flickr.com/3014/2731177705_bed6d6b8fa_m.jpg";
var bird  = "http://farm4.static.flickr.com/3190/2734919599_a0110e7ce0_m.jpg";
var me_89  = "http://farm3.static.flickr.com/2138/2308085138_7b296cc5d0_m.jpg";

Frame {
    width: 640, height: 480, visible: true
    stage: Stage {
        fill: Color.BLACK
        content: [
            DragGroup{
                content: ImageView {
                    anchorX: 120, anchorY: 90
                    rotate: bind 30 + angle
                    image: Image { backgroundLoading: true, url: me }
                }
            },
            DragGroup {
                translateX: 300, translateY: 50
                content: ImageView {
                    anchorX: 120, anchorY: 90
                    rotate: bind -30 + angle
                    image: Image { backgroundLoading: true, url: dog }
                }
            },
            DragGroup {
                translateX: 300, translateY: 300
                content: ImageView {
                    anchorX: 120, anchorY: 90
                    rotate: bind 90 + angle
                    image: Image { backgroundLoading: true, url: plant }
                }
            },
            DragGroup {
                translateX: 200
                translateY: 200
                content: ImageView {
                    anchorX: 120, anchorY: 90
                    rotate: bind 90 + angle
                    image: Image { backgroundLoading: true, url: bird }
                }
            },
            DragGroup {
                translateX: 30
                translateY: 200
                content: ImageView {
                    anchorX: 85, anchorY: 120
                    rotate: bind angle + 180
                    image: Image { backgroundLoading: true, url: me_89 }
                }
            },
        ]

    }

    closeAction: function() {
        java.lang.System.exit( 0 );
    }
}

angleAnimation.start();

One more example, using the same class DragGroup, we can put multiple nodes using lists.

Video url: http://www.youtube.com/watch?v=gJqy7EdtEqs

import javafx.application.*;
import javafx.scene.*;
import javafx.scene.geometry.*;
import javafx.scene.paint.*;
import javafx.input.*;
import javafx.animation.*;
import java.lang.Math;

// Class to create a draggable group of objects
public class DragGroup extends CustomNode{
    public attribute content: Node[];

    private attribute endX = 0.0;
    private attribute endY = 0.0;

    private attribute startX = 0.0;
    private attribute startY = 0.0;

    override attribute onMousePressed = function(e:MouseEvent):Void {
        startX = e.getDragX()-endX;
        startY = e.getDragY()-endY;
    }

    override attribute onMouseDragged = function(e:MouseEvent):Void {
        endX = e.getDragX()-startX;
        endY = e.getDragY()-startY;
    }

    public function create(): Node {
        return Group{
            translateX: bind endX
            translateY: bind endY
            content: bind content
        }
    }
}

// angle animation, cycles between 0 to 360 in 10 seconds
var angle = 0.0;
var angleAnimation = Timeline {
    repeatCount: Timeline.INDEFINITE
    keyFrames : [
        KeyFrame {
            time: 0s
            values: angle => 0.0
        },
        KeyFrame{
            time: 10s
            values :  angle => 360.0 tween Interpolator.LINEAR
        }
    ]
}

// breath animation, go and back from 0.0 to 10.0 in 2 seconds
var breath = 0.0;
var breathAnimation = Timeline {
    repeatCount: Timeline.INDEFINITE
    autoReverse: true
    keyFrames : [
        KeyFrame {
            time: 0s
            values: breath => 0.0
        },
        KeyFrame{
            time: 1s
            values :  breath => 10.0 tween Interpolator.LINEAR
        }
    ]
}

// Creates n multi colored floating circles around a bigger circle
var n = 12;
var colors = [
    Color.BLUE, Color.AQUA, Color.MAGENTA, Color.RED,
    Color.YELLOW, Color.ORANGE, Color.HOTPINK, Color.LIME
];
var chosen = Color.YELLOW;
var floatingCircles = Group{
    rotate: bind angle
    content: for (i in [1..n])
    Circle {
        fill: colors[i mod sizeof colors]
        radius: 10
        centerX: Math.cos(i * 2 * Math.PI/n) * 70
        centerY: Math.sin(i * 2 * Math.PI/n) * 70
        onMouseClicked: function( e: MouseEvent ):Void {
            chosen = colors[i mod sizeof colors];
        }
    }
}
var circle = Circle{
    radius: bind 50 + breath
    fill: bind chosen
}

Frame {
    width: 400, height: 400, visible: true
    stage: Stage {
        fill: Color.BLACK
        content: [
            DragGroup{
                translateX: 200, translateY: 200
                content: [circle, floatingCircles]
            }
        ]
    }

    closeAction: function() {
        java.lang.System.exit( 0 );
    }
}

// starts all animations
angleAnimation.start();
breathAnimation.start();

Disponível apenas aos curiosos.... download do Beta que vai sair essa semana pode ser feito por aqui.

As novidades desta versão estão aqui :)

Bom download !!!!

 

 

Finalmente ! Fui incluído no Feed do site PlanetNetbeans, muito bom ! Faz algum tempo que venho enviando email mas finalmente fui atendido :P

Até !

 

 

A new feature coming with NetBeans 6.5 is the Go To Symbol search tool which can find Java symbols, as class, method or field. To open this search go to Navigate > Go To Symbol (Ctrl + Shift + Alt + O) and enjoy it! See below how it looks.

[Click to enlarge]

You will can see more details at NetBeans IDE 6.5 -- New and Noteworthy in Milestone2 page.

Happy coding!

Here is a problem I faced those days while programming with JavaFX.
When you perform a click in a JavaFX area, mouse events are called to all nodes through that position. You can see this behavior in this video.

Example 1.

Here is the code.

import javafx.application.*;
import javafx.scene.geometry.*;
import javafx.scene.geometry.Rectangle;
import javafx.scene.paint.Color;
import javafx.input.MouseEvent;

Frame {
    width: 200
    height: 200
    visible: true
    stage: Stage {
        content: [
            Rectangle {
                var color1 = Color.BLUE;
                x: 10, y: 10, width: 140, height: 90, fill: bind color1
                onMouseClicked: function( e: MouseEvent ):Void {
                    if (color1==Color.BLUE){
                        color1 = Color.GREEN;
                    } else {
                        color1 = Color.BLUE
                    }
                }
            },
            Circle {
                var color2 = Color.RED
                centerX: 100, centerY: 100, radius: 40, fill: bind color2
                onMouseClicked: function( e: MouseEvent ):Void {
                    if (color2==Color.YELLOW){
                        color2 = Color.RED;
                    } else {
                        color2 = Color.YELLOW
                    }
                }
            }
        ]
    }
}

This is the default behavior. All node are called with a mouse event. Is a expected and robust behavior but sometimes we just don’t want that. We want events called to just one node or a set of nodes.

Example 2.

Is exactly the same code but with blocksMouse: true in the circle node. When blocksMouse is true the mouse event will not be called to others node behind it.

package overlapping;

import javafx.application.*;
import javafx.scene.geometry.*;
import javafx.scene.geometry.Rectangle;
import javafx.scene.paint.Color;
import javafx.input.MouseEvent;

Frame {
    width: 200
    height: 200
    visible: true
    stage: Stage {
        content: [
            Rectangle {
                var color1 = Color.BLUE;
                x: 10, y: 10, width: 140, height: 90, fill: bind color1
                onMouseClicked: function( e: MouseEvent ):Void {
                    if (color1==Color.BLUE){
                        color1 = Color.GREEN;
                    } else {
                        color1 = Color.BLUE
                    }
                }
            },
            Circle {
                var color2 = Color.RED
                centerX: 100, centerY: 100, radius: 40, fill: bind color2
                blocksMouse: true
                onMouseClicked: function( e: MouseEvent ):Void {
                    if (color2==Color.YELLOW){
                        color2 = Color.RED;
                    } else {
                        color2 = Color.YELLOW
                    }
                }
            }
        ]
    }
}

Thanks guys on the OpenJDK user mail list and at OpenJFX Forum, specially this thread.

The main NetBeans 6.5 feature I have been looking forward to is the new database support. For details about what is coming, look here for details.
For now, we already can use code completion, some features as editable queries result, quick column info on result table and another really cool features. Another interestig feature is the SQL History. You can see below an image about what is coming...

[Click to enlarge]

BTW, the execution plan will be implemented just for feature versions. If it is important to you, vote for it now here!

Happy coding!

10 a 12 de Setembro de 2008
São Paulo - SP
Chamada de Trabalhos
http://www.sucesusp.org.br/justjava2008/

Eu participei de todos os eventos JustJava, foi muito legal assistir ao 1o em 2000, na av. Pompéia, com John Gage como keynote speaker.

Hoje o JustJava já está em sua 7a edição. E desde 2003, faço palestra no evento, onde consigo convidar a galera e mostrar o que considero importante no tema.

Alguns pontos altos de todos os eventos

* Muitas palestras técnicas e de boa qualidade (ok, já teve algumas ruins também)
* Muita troca de experiência e cultura de trabalho
* Discussões sobre um tema nas muvucas, onde tinhamos até uma cerveja para acompanhar (hoje vai ser difícil com a nova lei de transito)
* Aprender novidades, com outros feras no assunto

Então veja abaixo, um pouco mais sobre um PR do evento e o convite para submeter palestra.

O Evento

O JustJava é um evento técnico, feito por brasileiros, para brasileiros, e apresentado por desenvolvedores, para desenvolvedores!

O objetivo do evento é mostrar o que esta está acontecendo no mercado Java no Brasil, quais são os projetos Java mais importantes, como o desenvolvedor brasileiro tem usado a tecnologia, e principalmente, incentivar a integração daqueles que fazem a tecnologia Java crescer no Brasil - os desenvolvedores.

Você não pode ficar de fora do JustJava - o Evento Java da Comunidade Brasileira, e o grande evento de Java do ano no Brasil.

O JustJava, já na sua sétima edição, é o principal evento técnico realizado pela Sociedade de Usuários Java, um dos mais ativos grupos de usuarios Java do Brasil. Na primeira edição, o JustJava foi o maior
evento de Java realizado ate então no Brasil!

Venha ser um palestrante

Se você quer apresentar uma palestra no JustJava, o momento de submissao é agora. Ate o dia 18 de julho, estaremos recebendo e avaliando as palestras para compor e montar um evento técnico de alta qualidade.

Se você tem um projeto inovador e quer mostrar suas soluções criativas para os problemas encontrados, se você quer aprofundar as discussões sobre a tecnologia Java, seja um palestrante no JustJava.

Para submeter sua palestra, preencha o formulário que se encontra no site abaixo, na opção "Chamada de Trabalhos"

http://www.sucesusp.org.br/justjava2008/

Outras informações

http://www.soujava.org.br/display/v/JustJava+2008

Now I am using NetBeans 6.5 M1 for my day by day work and it is really stable...
BTW, during the normal work I face a new feature which I haven't seen any documentation yet. The new feature is the ability to diff a file directly to another one in a easy way, by Tools > Diff menu or contextual menu, as the image below.

It is a simple enhancement but that save precious time for the day by day needs.

Happy coding!

The test time is back! With NetBeans 6.5 M1 and beta coming soon, is time to make this version available with a as good as possible QA. To help this happen, I just known I was accepted as a NetCAT member, what give me more chance to make these things happen.
BTW, I am really happy about the enhancements proposals in database support and editor/refactoring areas. During this time I will try to make the blog updated about the new features always as possible, and to start it I will just link a post from Geertjan about a really interesting new option for Swing development - how to make the generated code doesn't use FQN.

Happy coding!

Isso mesmo ! Graças ao bom Deus o patch2 do NetBeans 6.1 com a correção do maldito bug #132662 está disponivel para download via Update Center, atualizem suas IDE's e vejao se realmente funcionou...

Aqui eu to usando o Patch2 Beta e funcionou ;)

Valeu !

 

Eleita como melhor ferramenta para desenvolver com Ruby pela InfoWorld, o NetBeans 6.1 vem se tornando uma alternativa muito atraente para outras linguagens que não apenas Java...

Para PHP, para Ruby, para Groovy, para C++, para JavaScript , E segundo a Sun, será a melhor IDE para desenvolver em Jython tambem...

Baixem e deem uma brincada... e quem tiver algum comentario (especialmente sobre a parte da IDE que diz respeito ao Ruby) por favor poste :) Será muito bem vindo !

Quem estiver com vontade de testar as novidades do NetBeans 6.5 M1 pode fazer download aqui ! Uma coisa que vi que eles vão incorporar no 6.5 é o "Background compilation" aka CompileOnSave , sabe ... aquele esquema do eclipse compilar a classe quando vc salva o arquivo....

Hoje o netbeans deixa isso para o Ant... porem existe uma proposta para que o mesmo seja feito em Background estilo JDT :)

Achei outra coisa legal, o suporte a PHP dele está cada vez mais maduro e realmente tentando se tornar uma opção para desenvolvimento desta linguagem... duvida ? veja este demo :)

Eu fiz download e o mesmo me pareceu bastante rapido... mais que o 6.1 (que já teve bons ganhos nesta area) , porem eu não recomendo para producao nem de longe ehhehe...

 

Meu deus... acho que encontrei a camiseta que eu sempre desejei... ela expressa um pensamento que tenho todo dia demanhã... toda vez que tenho que arrumar os componentes em tela me lembro dessa frase... VEJA !

1. Suporte a várias configurações Java EE ( já dipsonivel em JSE)
2. Suporte a sincronização na importação de projetos Eclipse
3. Suporte a PHP melhorado ( o que começa a tornar NetBeans uma alternativa interessante para IDE PHP)
4. Suporte SaaS em php
5. Suporte a deub de JavaScript no cliente (utilziando Firebug)
6. CSS Code Completion
7. Formatação de código por projeto (ufa, essa faz tempo que precisava hein ?)
8. Melhorias em Refactoring de propriedades
9. Suporte a Groovy/Grails
10. Suporte a SQL melhorado
11. Suporte a EJBQL/HQL e JPA melhorado
12. Suporte ao GlassFish v3
13. Suporte a JSF e JSP melhorado ( mas ainda sem preview , que desespero :( ! )
14. Reestrutura do motor de reenderização do UML Pack ( finalmente ! aquela desgraça trava demais )
15. Suporte melhorado a SVG (JME)
16. Suporte a preview de aplicações JSE com o Nimbus LAF
17. Melhorias no Code Completion do C/C++

Entre outras é claro, mas tem duas melhiras que achei fantasticas:


Suporte a Debug Multithread:


















CamelCase Code Completion:

Estamos contratando ! Se você tem o perfil descrito abaixo e tem interesse na tecnologia Java envie um currículo com sua pretenção salarial para mim. O regime de trabalho é CLT e a empresa localiza-se em Curitiba/PR

• Experiência de 2 anos no desenvolvimento de aplicações WEB
  
• Experiência com frameworks como JavaServer Faces e Struts
• Experiência no desenvolvimento utilizando Hibernate 3
• Desejavel experiência utilizando a plataforma Java EE 5

A vaga é para inicio imediato :)

O blog ficou meio fora do ar por motivos de ordem tecnica heheh...

Antes de mais nada gostaria de agradecer a todos que foram até a pagina da issue 132662 e votaram nela para ser corrigida... TENHO UMA OTIMA NOTICIA....

Corrigiram... porem apenas estará disponivel na versão 6.5, porque segundo eles a alteração feita pode impactar negativamente na performance e eles não tem certeza de que realmente ela vai resolver de cara...

O legal é que estão estudando para o 6.1 Patch3 (eu sei , eu sei , nem saiu o Patch2)

Aqueles que querem mais algumas correções de bug do 6.1 , peguem o Preview do patch2:

Adicionem mais uma fonte de atualização no seu Plugin Manager e aponte para:

http://bits.netbeans.org/6.1/fixes/2008-06-18_03-01-08/uc/catalog.xml.gz

Valeu !

Rafael Carneiro, Tarso Bersa, Rafael Ponte and me, after 8 hours of bus travel, arrived in Juazeiro do Norte to talk at the first JavaDay there.

• Rafael Carneiro talked about Java Certification.
• Tarso Bersa talked about Spring Framework for JEE applications.
• I talked about NetBeans 6.
• Rafael Ponte talked about JavaServer Faces.

We answered a lot of questions and gave lot of gifts. I also showed the Sun Academic Initiative, which they are already subscribed. We also showed several opportunities they can participate with CEJUG like free vouchers or a free travel for Belgium.

Some pictures we took. These ones during the bus travel. We saw a nice sunrise through beautiful landscapes.

We playing guitar hero. The city have their own shopping with games, restaurant and cinema.

The main atraction at Juazeiro is a statue of Padre (Priest) Cícero with 7 meters itself and more 8 meters of base. Pilgrimage to this statue takes place in his honour every November, attracting thousands of followers. The city’s economy is highly influenced by those travelers devotes.

There’s a museum with several personal objects from Padre Cicero. People go there in order to thanks for miracles. If you got your a part of your body cured, of place there a wooden replica of that part of your body. If you got a car, you place a wooden car or a photo, and so on. There is thousands, maybe millions, of objects theres.

You can see all photos at Carneiro’s album or in my album.

Então , estou aqui pedindo para que todos os que realmente tem visto o NetBeans como uma ferramenta boa de trabalho ajudem o mesmo a corrigir um terrivel e CHATO bug em seu Editor JSP que o torna INVIAVEL para utilização na versão 6.1 ...

Isso é uma pena , pois a versão 6.1 vem com uma serie de melhorias... e deixar de usar ela para voltar ao 6.0 por causa de um bug que classifico como EXTREMAMENTE GRAVE seria muito chato...

Se voce tem um BLOG... ajude a propagar este "APELO" hehehe...

Qual o meu pedido ? Simples, vá até este site do bug e VOTE nele para correção... se você nao tem login... CRIE UM LOGIN e VOTE... para que o pessoal do netBeans de mais atenção...

Valeu a ajuda :)

Esse fim de semana o CEJUG vai colocar o pé na estrada e partir rumo a Juazeiro do Norte para realizar, no dia 31 de Maio, um JavaDay, ciclo de palestras sobre tecnologia Java.

Essa é a grade de palestras:

Horário	Palestra	Palestrante
08:30	Certificação Java. A palestra tem o intuito de apresentar as Certificações da Tecnologia Java, os programas de estudos para obtenção destas certificações, como o mercado de trabalho local avalia os profissionais certificados e as estatísticas referentes a remuneração dos profissionais certificados.	Rafael Carneiro é JUG Leader do CEJUG (Ceará Java Users Group) e também coordenador do PortalJava. Trabalha na IVIA, gosta de ler diversos blogs sobre Java e possui algumas certificações da Sun. Mantém um blog sobre desenvolvimento de software no endereço www.rafaelcarneiro.org.
09:30	Utilizando o Spring Framework em Aplicações JEE. Desenvolver aplicações na plataforma JEE pode tornar-se difícil dependendo das tecnologias escolhidas. Esta palestra tem o objetivo de mostrar como o Spring Framework pode simplificar o desenvolvimento de software nessa plataforma, mantendo a solução leve e com serviços avançados, tais como gerenciamento de transações, acesso remoto a Web-Services ou RMI, e transparência no uso de AOP.	Tarso Bessa é um entusiasta Java e atua no desenvolvimento na plataforma há 5 anos. Possui foco em tecnologias Web e gosta de ler bastante sobre novas tecnologias, tendências de mercado e computação distribuída. Atualmente trabalha na IVIA como Arquiteto Java, é formado em Informática pela UNIFOR e possui algumas certificações da Sun, entre elas a SCEA.
10:30	Conhecendo o NetBeans 6. O NetBeans é uma plataforma de desenvolvimento gratuita, livre, multiplataforma e multilinguagem. A palestra apresenta os recursos básicos do NetBeans 6, focando a facilidade de seu aprendizado, seus recursos de produtividade e usabilidade, além da inclusão de linguagens como Ruby, JavaScript e PHP.	Silveira Neto é estudante de Computação na Universidade Federal do Ceará, Embaixador de Campus da Sun Microsystems, participa do grupo de pesquisa ParGO (Paralelismo, Grafos e Otimização combinatória) e é membro do CEJUG (Ceará Java Users Group). Tem como hobbies os blogs (silveiraento.net e eupodiatamatando.com), o desenho e o desenvolvimento de Softwares Livres.
11:30	JavaServer Faces, desenvolvendo aplicações web com produtividade. JSF é um framework que auxilia o desenvolvimento de sistemas para a Web, fornecendo recursos avançados e dinâmicos. A palestra aborda os principais conceitos da tecnologia, como ciclo de vida, características, mercado de trabalho e integração com outros frameworks do mercado.	Rafael Ponte atua com desenvolvimento de software há mais de 3 anos, atualmente é analista pogramador na IVIA, com foco no desenvolvimento de aplicações web, entusiasta Java, JSF e Domain Driven Design, moderador da lista de discussão JavaServer Faces International Group e sócio fundador da empresa de consultoria Triadworks. Mantém um blog no endereço www.rponte.com.br.

Vai acontecer na Faculdade de Juazeiro do Norte (Rua São Francisco 1224 A São Miguel, Juazeiro do Norte, Ceará), no dia 31 de Maio a partir das 8:30. Além das palestras também vão haver sorteios de vários brindes.

O evento é uma promoção do CEJUG e da Coordenação do Curso de Sistemas de Informação da Faculdade de Juazeiro do Norte.

Este mês saiu nas bancas a revista Mundo Java nº29, um artigo meu sobre a plataforma NetBeans, expliquei as principais classes e funcionalidades, e no final apresentei um tutorial prático de como extender o NetBeans e criar poderosos plugins..
Ainda nesta edição na seção "Eu uso" teve a participação mais que especial do Tim Boudreau, um dos engenheiros e pioneiro na criação das primeiras versões do IDE e do nosso querido Bruno Souza o JavaMan..
Eu mesmo traduzi o artigo do Tim, espero que quem leu tenha gostado.
Com a autorização do Tim, vou publicar o artigo dele na seção "Eu uso", claro, em inglês !!!

I work on the NetBeans Platform. Probably the most gratifying thing about that work is to see how it is used - anybody who creates software wants to see it used - it is what gives our work meaning. In the simplest view, what the NetBeans Platform does is solve problems. I believe in writing software that can be finished. That is, you write something that is solid and right and works and then you can leave it alone and move on to the next problem. The modular nature of NetBeans - indeed, the module system itself - makes it easier to build software out of a lot of libraries each of which does one thing well - and guarantee system integrity at runtime. It solves the DLL hell problem for once and for all, and in the process creates design patterns that are ideal for distributed development - how do you build software created by a large community and minimize the risks that changes to one part of the system will break another? The core beauty of NetBeans is the module system.

But what amazes me more is what people do on top of it. Let's take one case-in-point: Nokia. If you are a mobile service provider, such as Tim in Brazil (no relation :-)), and you buy your hardware from Nokia (your transmitters, the things that make a mobile phone network work), you will need some software to manage that network. If you are buying that hardware from Nokia, you get an application for managing your network. But it's not just one applications - it is many applications and one at the same time. They have used the NetBeans Platform plus Java WebStart technology together in an incredibly innovative way - and because Nokia contributed WebStart support to NetBeans, you can do the same thing for your applications.

Java WebStart is a technology that lets you launch a Java desktop application by clicking a URL. Anybody who has installed Sun's Java has Java WebStart. It's not wildly popular yet, but it is an incredible technology for improving the experience people have with internet-based applications. Why? Because there is only one copy of the software. I once visited a company - actually a software development organization for a state in the U.S. They asked us: "Can you please release new versions less often? Every time you have a new version, some guy has to walk around with a CD-ROM and visit 350 workstations and install it!"

That's crazy, and Java WebStart offers the solution. You click a URL and a desktop application starts - all the benefits of centralized management that you get from web applications, but it's a real desktop application. And when you download a new version, you don't download all the bits - only a diff between what was and what is. It's a darned cool technology.

Now put that together with a modular system like NetBeans, where an application discovers its parts during startup.

With Nokia's NetBeans-based software, it works like this: Imagine you work for a telecom in the mobile phone space. There are a lot of different jobs you might be doing: Some people monitor the network for problems. Some people dispatch physical repair trucks to go fix things. So, if you are using this software, well, you start it by clicking a link on the web. And to even see the link, you had to log in, so the system knows who you are and what you need.

So what happens? You click the link. The server knows who you are and what your job is. The result is that you start up one application - but it is an application with many faces. The server gives you an application which contains those modules you need to do your job - it will be a different set of modules depending on what you do and what you need access to.

Now think about what this does for the people who write this software! In a modular system, you usually do UI in one module and back-end logic in another. The result of all this is that the users have a better experience - they get a UI tailored for their job; and the developers get a better experience: 1. They can write back end logic once and share it for all possible cases, and 2. They don't have to write multiple applications that do variations on the same thing, and that saves a lot of time.

Anybody who is doing a large-scale desktop application should consider the NetBeans Platform; anybody who is considering a suite of related programs that share some logic and diverge in UI would be insane not to consider using it.

I am, of course, biased - I have worked on the NetBeans Platform. The criteria for people who could benefit from it are clear and hard to argue with:
- Anybody doing a multi-window desktop application
- Anybody writing a desktop application that needs to save state on shutdown
- Anybody writing an application with a concept of selection that determines action enablement or similar
- Particularly anybody writing several related applications that share some logic

We've worked very hard to make it easy to try the NetBeans Platform for your application. If you fit, even remotely, into any of the categories above, you could save time, money and effort with it - give it a look.

-Tim Boudreau, 16/12/07

Um agradecimento especial para o Bruno Souza por ter aceitado o convite, para o Tim Boudreau, para o Guapo e o Eduardo Guerra da Mundo Java que vem lutando para manter esta revista com um alto padrão, e claro para você leitor !!!

Se você se interessa por aplicações desktop e tem interesse em saber como funciona a arquitetura por trás do IDE NetBeans, compre essa revista, além deste artigo você vai encontrar nesta edição os seguintes temas..

• Desenvolvendo aplicações desktop ricas na Plataforma NetBeans.
• Animações 2D em JavaFX na prática.
• Binding, Componentes, Customizados e Template de Telas no SwingBeans 1.2.
• Click Framework.
• Acesso a Serviços Multimídia em Java ME com SIP-API e IMS.
• Tendências em foco: Java e o Mundo Web.
• RSS dinâmico, rápido e fácil com ROME e STRUTS 2
• Escolhendo uma ferramenta Case Gratuita para modelagem UML.
• Modelando Transações de Facade a AspectJ.
• De olho no mercado: Educação continuada de um Desenvolvedor
• Mundo OO: O Ciclo Ágil de um Dia

E mais , você leva de graça um Poster Mundo Java: Resumão SCJP- Parte III

Diversão Garantida !!!

Bom , minha motivação para escrever este post é a quantidade de "bugs" virtuais atribuidos ao NetBeans 6.x e que na realidade é um problema de cache...

Não sei por que, mas tem horas que o netbeans (ou algum de seus plugins) se "perde" e grava coisas erradas no cache.... gerando informacoes erroneas ou lentidão em alguns pontos... pois bem... antes de "reclamar" e pensar "é ruim assim mesmo" , experimente limpar o cache... COMO ???

Pois é... digamos que não é uma tarefa "user like"...

1. Saia do NetBeans e tenha certeza que ele não esta rodando em background
2. Apague o diretorio c:\Documents and Settings\NOME_DO_SEU_USUARIO\.netbeans\6.1\var\cache ( no linux esta no .netbeans do home do usuario)
3. Re-Inicie o NetBeans

Ele vai recriar todo o cache e fazer re-indexação das classes... e isso pode demorar um pouco... ou seja... não bote um "bat" para zerar toda vez que vc inicia o netbeans prq vai virar um pandemonio...


Um amigo meu teve problemas com o CVS , e na realidade era apenas o CACHE do plugin do cvs que estava "corrompido"... vai que o seu problema é este tmb :P


Tá aí a dica :)

Use por sua propria conta e risco... aqui tem 16 fixes para NetBeans 6.1 hehehe... COISA DE LOUCO...

Adicione um novo Update Center e bote:

Nome: 6.1 Fixes
Endereco: http://bits.netbeans.org/netbeans/6.1/fixes/2008-05-16_03-01-27/uc/catalog.xml.gz

Agora voce pode estar se perguntando... "Porque não está em netbeans.org ?"

Simples, ai estão os nbm's da arvore de "correções" do NetBeans 6.1... ou seja... vc está atualizando seus plugins para uma "COISA" entre a 6.1 e a 6.1 + SP1...

Para quem não aguenta alguns bugs irritantes do 6.1 deve ajudar em algo :)

A propósito, testem por sua propria conta e risco... se der algum erro... poupem a coitada da minha mãe hehehe...

Aos desesperados por novos plguins... existe um plugin que fornece acesso a todo "Plugin Portal" do NetBeans... é só instalar
http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=1616

This post continues a serie of posts I’m writing about 2D game development in Java.
A simple example of an JPanel that implements KeyListener (and a little trick) to handle KeyEvents to move a white square.

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class KeyPanel extends JPanel implements KeyListener{
    private int x=50,y=50;
    public KeyPanel() {
        JTextField textfield = new JTextField();
        textfield.addKeyListener(this);
        add(textfield);
        textfield.setPreferredSize(new Dimension(0,0));
    }

    public void keyTyped(KeyEvent e) {}

    public void keyReleased(KeyEvent e) {}

    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_LEFT)
            x-=5;
        if (e.getKeyCode() == KeyEvent.VK_RIGHT)
            x+=5;
        if (e.getKeyCode() == KeyEvent.VK_DOWN)
            y+=5;
        if (e.getKeyCode() == KeyEvent.VK_UP)
            y-=5;
        this.repaint();
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.setColor(Color.black);
        g.fillRect(0, 0, 500, 500);
        g.setColor(Color.white);
        g.fillRect(x, y, 50, 50);
    }
}

Download the complete NetBeans source project files: KeyTest.tar.bz2.

A partir da versão 5.0 foi iniciado um projeto de tradução do NetBeans para diversos idiomas, entre eles o Português do Brasil (pt_Br). Foi neste momento que a comunidade de desenvolvedores brasileiros mostrou todo seu potencial, onde a partir da versão 5.5, em tempo invejável, sob a coordenação de Michel Graciano nossa equipe conseguiu um grande destaque dentro os outros projetos, pois foi o primeiro a finalizar toda a internacionalização para esta versão, tornando-se modelo para os demais times de outros idiomas.
O NetBeans 5.5 foi a primeira versão totalmente internacionalizada e organizada pela comunidade disponibilizada pela Sun Microsystems (Sun), até então apenas as versões em japonês e chinês estavam disponíveis, ambas patrocinadas pela própria empresa. Não há como deixar de destacar vários benefícios de ter-se uma ferramenta livre em português, entre os principais incentivadores está em motivar e reduzir os obstáculos que os acadêmicos enfrentam nos bancos escolares em nossas universidades e cursos técnicos, onde muitas vezes o idioma inglês é apenas mais um dos inúmeros obstáculos e uma ferramenta na sua língua nativa ajuda muito a entender suas funcionalidades. Outro motivo não menos relevante é o fato dos governos e seus órgãos fazerem uso preferencial de softwares no idioma oficial, até porque muitas vezes o uso de sistemas em idioma estrangeiro é vetado. Desta forma softwares traduzidos ganham mais popularidade aos não traduzidos, sendo essa a intenção do projeto, fazer o NetBeans ser o mais popular possível. Não podendo deixar de destacar, a internacionalização reflete diretamente em produtos desenvolvidos sobre o NetBeans Platform, onde estas tradução saem de graça para a empresa ou desenvolvedor do projeto.

Todo o projeto teve o acompanhamento do pessoal interno da Sun bem como do projeto NetBeans, em particular Janice Campbell e Masaki Katakai, os quais coordenam e ajudam os projetos de internacionalização. Este tipo de iniciativa é bastante importante pois reduz as distâncias entre os desenvolvedores independentes e a própria Sun. A versão 6.0 do Netbeans ainda não está disponível em português, mas o projeto de tradução já esta se preparando para esta próxima etapa, e você pode participar, quanto mais colabordores melhor. Para participar acesse o site oficial do projeto (ver Referências), inscreva-se na lista de discussão e quaisquer dúvidas o pessoal estará pronto para respondê-las. Na última edição do Sun Tech Days em São Paulo (Figura abaixo), aconteceu uma apresentação do projeto e a entrega dos certificados de participação.

Só agora que na nova versão do NetBeans 6.0 é que é possível na IDE criar os métodos equals() e hashCode(Object), o que na verdade é uma mão na roda para muitos desenvolvedores, encontrei alguns desenvolvedores como Vinicius Senger da Globalcode e Jefferson Prestes do time de tradução que me disserem que abriam o eclipse apenas para utilizar o recurso de criação destes métodos....
Pensando nisso, como fazia um tempo que não mexia na plataforma netBeans, decidi criar um plugin para a comunidade e de quebra relembrar as APIs da plataforma.
E o plugin faz justamente isto, gera os métodos equals e hashCode baseados nos campos da classe que esta em foco no editor, o método criar os métodos respeitando o contrato de implementação.

Onde o contrato nos diz que para implementar uma relação equivalente em referencias de objetos não nulo o método:

• É reflexivo: para qualquer valor de referencia not null para x, x.equals(x) deve retornar true.
• É simétrico: para qualquer valor de referencia not null para x e y, x.equals(y) deve retornar true se e somente se y.equals(x) retornar true.
• É transitivo: para qualquer valor de referencia not null para x, y, e z, se x.equals(y) retornar true e y.equals(z) retornar true, então x.equals(z) deve retornar true.
• É consistente: para qualquer valor de referencia not null para x e y, multiplas invocações de x.equals(y) consistentemente retornarão true ou consistentemente retornarão false.
• Para qualquer valor de referencia not null para x, x.equals(null) deve retonar false.

Como não poderia deixar de ser, temos que seguir um contrato para seguir hashCode que é:

• Sempre que for invocado no mesmo objeto mais de uma vez durante a execução de uma aplicação Java, o método hashCode deve sempre retornar o mesmo integer.
• Se dois objetos são iguais de acordo com a execução do método equals(Object), então chamar o método hashCode em cada um dos dois objetos deve produzir o mesmo resultado inteiro.
• Não é obrigado que se dois objetos são diferentes de acordo com a execução do método equals(Object) que chamando o método hashCode em cada um dos dois objetos deve produzir resultados inteiros distintos. Entretanto, o programador deve ter cautela, pois produzir resultados inteiros distintos para objetos diferentes podeve causar problemas de performance ao utilizar hashtables.

Essas são as regras para se implementar equals(Object) e hashCode(), além de seguir estas regras o plugin segue a espeficação de Joshua Bloch para a implementação destes métodos no livro Effective Java. Portanto talvez você pode achar a implementação bem similar a forma do eclipse produzir estes métodos.
Segue abaixo alguns screenshots do plugin. O plugin esta internacionalizado, disponivel para inglês e português.
Para instalar o plugin efetue o download do arquivo nbm no portal de plugin do netbeans clicando aqui.
Após instalar o nbm espere enquanto o netBeans faz um "hot deploy", após a instalação, para utilizar o plugin, no editor de um arquivo java basta acessar o menu Refatorar > Implementar hashCode() e equals(Object) ou clicando com o botão direito do mouse e acessando o menu pop up Refatorar > Implementar hashCode() e equals(Object).

Após pressionar o botão será apresentado uma JDialog disponibilizando as fields que você deseja implementar nos métodos.



Após pressionar ok, pronto o código esta pronto =) ,, fácil não.. Eclipse para que ? hehe

E ele até que é esperto, se você tentar criar os métodos em uma classe que já possui os métodos, o plugin dá mensagem.


Se sua classe tiver só a classe equals e quiser só o hashCode por exemplo, ele é bem compreensivo..

Bom é isso, esse é um plugin bem simples, mas que ajuda muito no dia a dia.. peço aos meus queridos amigos que baixem este plugin e testem, se tiver dúvidas ou sugestões, é só avisar.

Com quase um mês de atraso foi lançado oficialmente no dia 03/12/2007 a versão final do NetBeans 6.0, com várias melhorias, para aqueles que serem falaram mal do editor e da performance um recado.. Seus problemas acabaram !!
As mudanças mais significativas foram no editor de texto do IDE, onde podemos destacar.
* Code Completion Inteligente
* Coloração Semântica
* Refactoração Instantânea
* Preview com antes - depois de alteração
* Geração de código como sobrescrita de construtores, equals e hashCode
* Suporte a várias linguagens como Java, Ruby, C/C++, XML, HTML, RHTML, JavaScript, e JSP.

São muitas as novidades no novo IDE, não teria como destacar todas as novas funcs neste post, proponho a você desenvolvedor efetuar o download no site netbeans.org, que agora vem disponível em várias opções de download (figura abaixo).


e explore os tutoriais disponiveis no próprio site em tutoriais.

Ainda falando de NetBeans 6, a última edição da revista mundo java nº 26, foi publicada um artigo meu sobre as novas funcionalidades do NetBeans 6 com enfânse nas mudanças do editor e no desenvolvimento de aplicações Swing com as JSRs 295 e 296 (Beans Binding e Swing Application Framework) a revista ainda possui diversas máterias interessantes com foco em SOA.. sem dúvida uma ótima pedida..

Segunda Feira (05/12/2007) esteve em São Paulo Tim Boudreau o engenheiro senior da Sun e um dos criadores NetBeans, ele esteve em um Mini curso exclusivo da Globalcode, esteve falando sobre as mais recentes funcionalidades do NetBeans 6.0 tais como: Melhorias no editor; Suporte a Ruby/JRuby/Ruby on Rails; Instalação e atualização mais fáceis; Desenvolvimento de GUI Swing; Profiling; Web e Java EE; Mobilidade; SOA; UML; Melhorias na API da plataforma NetBeans.

Mauricio Leal da Sun fez uma demo das novas funcionalidades do NetBeans 6 para o desenvolvimento de aplicativos JavaME.













Nos próximos dias a Globalcode irá promover outro mini curso sobre Web Semântica com Henry Story, fiquem ligados pois as vagas se esgotam rapidamente...
Para quem não sabe Web Semântica é o rumo atual que a Web tem tomado e em um sentido mais amplo permitirá que homem e máquina trabalhem em cooperação. Hoje o grande desafio é desenvolver tecnologias e linguagens que tornem a informação legível para as máquinas, essa integração hoje em dia é possível graças ao XML (eXtensible Markup Language), ao RDF (Resource Description Framework) e arquiteturas de metadados..
A Web Semântica é associada ao Web 3.0 como um próximo passo na evolução da rede mundial de computadores. Ela tem como objetivo imediato de categorizar as informações aumentando assim a eficiência em mecanismos de ferramentas de busca como Google, Altavista, etc...


E no fim do mini curso, fui gentilmente convidade pela familia Senger para um jantar com os ilustres visitantes..

Jorge Diz, Henry Story, Vinicius Senger, Yara Senger, Tim Boudreau, Mauricio Leal e Wagner Santos


Para maiores informações sobre Web Semântica acesse http://www.w3.org/2001/sw/ da W3C.

A Sun esta lançando o programa "NetBeans Innovators Grants", é a grande chance de tirar aquele projeto engavetado é ganhar uma graninha extra..
Na verdade, NetBeans Grant é um processo que fornece grants para desenvolvedores que desejam trabalhar em seu projeto open source. Como isso funciona ? Um total de 10 grandes projetos serão escolhidos e premiados com um grant de US$ 11,500 dólares, e outros 10 projetos de pequeno porte serão escolhidos e receberão um grant de US$ 2,000 com a possibilidade de receber até US$ 5,000 dólares se o seu projeto for um bom projeto..

O que eu preciso fazer ?
Fácil, é só submeter uma proposta de um projeto qualquer, contanto que seja relacionado ao desenvolvimento do NEtBeans (claro !!!) , e demonstrar como suas idéias irão ajudar a melhorar o Projeto NetBeans, e um grupo de experts (talvez o Dream Team do NetBeans) irão avaliar as melhores idéias e serão selecionados os melhores projetos. Se o seu projeto for aprovado você irá receber o grant de acordo com o tamanho do seu projeto. Mas espera aí, isso não quer dizer que você vai sair com a grana toda no mão, para receber a grana é preciso terminar e entregar o projeto até o prazo final

Prazos

Abertura de submissões	1 de Fevereiro 2008
Fim da entrega das submissões	3 de Março 2008
Anúncio dos juízes dos projetos aprovados que irão receber os grants	1 de Abril 2008
Entrega final do projeto - o dinheiro do grant é pago para projetos finalizados	4 de Agosto 2008
Juízes anunciam possíveis prêmios extras em dinheiro - Prêmios Ouro e Prata - e o pagamento dos projetos finalizados	1 de Setembro 2008

Link e fonte http://www.netbeans.org/grant/

Diversão garantida !!!!

No dia 10 de Abril tive o prazer de dar uma palestra no auditório da Globalcode sobre o projeto de L10N que significa Localization, o 10 se refere as dez letras que existe entre a letra L e N.. Jefferson Prestes um dos colaboradores do Projeto e tradução da lista de notícias (newsletter) acabou ajudando bastante nesta apresentação.
No mesmo dia Greg Sporar, deu uma palestra sobre as novidades do NetBeans 6.1 (ainda Beta), sobre performance, sobre um plugin do NetBeans para o IReports, entre outras coisas..
Janice Campbell a Gerente Mundial de programas de tradução escreveu sobre a palestra neste link.
O material da apresentação se encontra no java.net, no projeto do soujava, e pode ser baixado neste link.
Sobre a palestra:
Falamos sobre o projeto de tradução IDE, que desde a versão 5.5 do NetBeans tupiniquim liderada por Michel Graciano, foi totalmente internacionalizada e organizada pela comunidade, ganhando um destaque no cenário internacional sendo considerado um padrão para os outros países em termos de organização e postura.

Benefícios

• Ambiente Acadêmico.

Facilidade no aprendizado para os iniciantes cuja língua nativa seja diferente do inglês.

• Software Governamental

Preferência por ferramentas no idioma oficial.
Muitas vezes sistemas com idioma estrangeiro é vetado.

• NetBeans Platform

Impacto direto, pois a ferramenta traduzida é disponibilizada de graça para as empresas e desenvolvedores da plataforma.

Falamos sobre a tradução da Newsletter e da lista de discussão (nbdiscuss_pt@netbeans.org)

Como Participar

1. Cadastre-se na lista de discussão pt_br@netbeans.org
2. Apresente-se
3. Colabore
4. A Versão 6.1 em breve estará disponível
5. Estamos ansiosos por sua contribuição!

Segue algumas fotos do evento.




No inicio da palestra.


















Sobre o projeto de tradução.



















Jefferson Prestes.




















E Greg Sporar.














As fotos foram cortesia da minha grande amiga Valéria Guimarães Mendonca vulgo "JavaGirl"...

Foi lançado recentemente o Release Candidate 1 do novo NetBeans 6.1, ao terminar e instalação, a primeira coisa que pude observar foi o aumento extraordinário de performance em comparação com a versão 6.0, esta aproximadamente 40% mais rápido em performance..

Desempenho

Abaixo segue dois prints mostrando o gerenciador de tarefas com o consumo do NetBeans 6.0 (203.736 K) e o NetBeans RC 1 (170.248 K), ainda o consumo é grande, mas com certeza já é uma grande melhoria.

Entre as melhorias foram feitas diversas otimizações para redução do I/O e acesso ao disco, essa é a grande mágica que tornou a resposta muito mais rápida, principalmente em ambientes de rede. Foi alterado também o algoritmo para o parsing incremental no editor Java e JSP, aumentando a velocidade na resposta do auto completion, para este último foram feitas alteração no caching, gerenciamento de memória e nos algoritmos de alteração.
Outro recurso que consumia muito recurso da máquina era o pacote Visual Web, quem baixar a nova versão
irá notar uma grande diferença na abertura das páginas, menor consumo de memórias entre outras melhorias...


Biblioteca Compartilhada

Outra novidade bacana são as novas bibliotecas compartilhadas, antes se eu tinha que compartilhar bibliotecas em um ambiente multi usuário, isso só seria possível se eu criasse um projeto NetBeans Platform e "amarrasse" a biblioteca que criei a um Java SE Library Descriptor, e distruibui-se como um nbm, mas como poucos conhecem as funcionalidades do NetBeans Platform, isso se tornou uma prática pouco comum, na nova versão para utilizar uma biblioteca compartilhada basta no momento da criação do projeto (web, enterprise, java desktop) utilizar a opção "Use Dedicated Folder for Storing Libraries" ao clicar nessa opção, o projeto irá incluir as libraries no classpath.
















Para projetos antigos, é possível incluir as bibliotecas compartilhadas, para isso entre nas propriedades de um projeto, na categoria "Libraries" e clique no botão Browse... em Libraries Folder, basta escolher a pasta onde estão armazenadas as libs e clicar em Next, neste passo (Actions) é possível definir o comportamento das libs armazendas, podemos copiar as os arquivos jar para uma nova pasta de libraries (opção default), podemos utilizar o caminho relativo para os arquivos Jar, podemos utilizar o caminho absoluto para os arquivos Jar, ou utilizar a pasta selecionada mesmo.










































JavaDoc


Outra boa novidade é o suporte as tags do JavaDoc, quem é que nunca tentou o auto complete em um comentário, pois bem , agora isso é possivel.




Suporte ao MySQL

Desde que a Sun comprou a MySQL o suporte a este banco de dados no NetBeans só vem aumentando, na versão 6.1 já existe uma infra pronta para o MySQL, se você já possui um servidor do MySQL instalado basta registrar o servidor acessando a tab services e clicar com o mouse em cima de Database, e selecionar a opção "Register MySQL Server"(foto abaixo),e preencher o formulário, perceba que é só indicar o caminho da ferramenta de administração do MySql, que é possível dentro do NetBeans abrir e acessar a ferramenta de adminstração, mais facilidades na criação de novos bancos, ...






Editor de JavaScript

Outra ótima novidade são as diversas melhorias no editor de JavaScript, na verdade, todos os beneficios do novo editor do NetBeans 6.0 / 6.1 foram implementados no editor JavaScript, ainda de quebra é disponibilizado a documentação baseada no arquivo javascript.. Perfeito !!