BDS 2006 & Javascript - Intraweb 8.0

O Intraweb ainda continua presente nas versões mais recentes o Delphi. Ao que parece, a versão do framework que acompanha o no BDS 2006 apresenta alguma novidade. Contudo, muita coisa importante parece não ter mudado. Por exemplo, o fonte dos componentes ainda não é acessível aos desenvolvedores. Confesso que vejo com grande antipatia essa característica proprietária da Atozed. Postura incompatível com a demonstrada por grandes fornecedores de tecnologias que se destacam atualmente. Isso me remete ao sentimento de que ao usar um produto da Atozed o desenvolvedor está lhe dando com uma empresa cujo a mentalidade reflete uma postura feudal, própria da miserável e subdesenvolvida América latina.
Pretendo criar alguns exemplos (nandjares de mirolands) para experimentar como se comporta o Intraweb 8.0.1, que esta presente no DBS 2006. (Veja: Intraweb e Delphi 7)

Iniciando nosso primeiro exemplo

No BDS 2006, para iniciar um novo projeto selecione no menu: File ► New ► Other. Em
seguida, selecione no diálogo seguinte (caixa de dialogo) IntraWeb Application Wizard. A partir da Treeview (Item Categories) conforme ilustrado na figura abaixo:

No diálogo seguinte definiremos algumas configurações importantes para nossa aplicação web.

StandAlone Application: Essa opção permite desenvolver o aplicativo Intraweb sem a necessidade de deploy em servidor web (IIS por exemplo). Isso traz algum conforto, visto que, assim é dispensável configurações obrigatórias para desenvolvimento que exija deploy e sincronismo com o servidor. Outra vantagem é que essa opção oferece um recurso de “Debug” idêntico o experimentado pelo desenvolvedor quando trabalha na IDE do Delphi com aplicações desk top. A partir dessa configuração seu aplicativo Intraweb, quando o F9 é pressionado, é “executado” pelo Browser, contudo para debuggar basta marcar o brack point (F5) na linha desejada e prosseguir como se você estivesse desenvolvendo um aplicativo convencional.
Pool Data Connection: Como o próprio título indica, refere-se a pool de conexões. Bem, tenho que confiar no que está indicando essa propriedade pois no momento não tenho como testar quase nada sobre ela.

Create User Session: Cria uma declaração, automaticamente, no seu novo projeto, de um obejto da classe TUserSession. Esse objeto, também conhecido desde a versão 5.0, tem o objetivo de ser um gerenciador de seção.
Durante muito tempo o gerenciamento de seção sempre foi uma parte sensível, bastante trabalhosa, nos primórdios do desenvolvimento para web. Na época do Delphi 7, esta estratégia de gerenciamento de seção foi uma feature que fez o Intraweb dar coro em nas tecnologias web vigentes naquela época.

Project Name: Define o nome do projeto.

Project Directory: O Framework Intraweb tem a particularidade de solicitar o path do diretório onde ficará o projeto. No contexto web isso tem uma particular importância por causa de obrigatoriedade da dependência de um servidor web. Porque ele é responsável pela interpretação e disponibilização do seu programa em forma de serviço web. Você pode estar se perguntando: “Ora, definimos o exemplo como ‘Stand Alone Application’, logo não tem servidor web. Correto?”. Errado meu caro, o Intraweb no módulo Stand Alone Application possui uma funcionalidade que simula um servidor web. O simples fato desse detalhe ficar transparente para o desenvolvedor não é a prova de que não exista a necessidade do servidor web.

Outra coisa sobre “Project Directory” ele não usa a API do windows para selecionar um diretório, isso é tosco. Em compensação, você pode digitar um diretório que não exista ainda, ele cria pra você.

Main Form: Define se o aplicativo suportará tecnologia para dispositivos móveis

De cara já percebemos novidades, pretendo verificar até que ponto elas nos representarão vantagem efetivas ou não.

Após essas configurações iniciais, click no botão “OK” e o BDS vai criar pra você as seguintes Units:

Unit1: Este é o formulário Intraweb principal do seu projeto. Esta está nomeado de “IWForm1”.

DatamoduleUnit: Como o próprio nome indica, trata-se do Datamodule (TDatamodule).

unit DataModuleUnit;

interface

uses
  {$IFDEF Linux}QForms, {$ELSE}Forms, {$ENDIF}
  SysUtils, Classes;

type
  TDataModule1 = class(TDataModule)
  private
  public
  end;


implementation

{$R *.dfm}

end.

ServerController: Onde está definido a classe que faz a interface com o servidor web. TIWServerController (IWServerController). Esta classe é também onde definimos muitas propriedades importantes do aplicativo web que estamos construindo.

UserSessionUnit: Gerenciador de seções do Intraweb. Nas versões anteriores, o UserSession era uma classe definida na unit do ServerController.Veja um exemplo de uma Unit “ServerController” do Delphi 7 (Intraweb 5.0):

unit ServerController;
{PUBDIST}

interface

uses
  Classes,
  UDm,
  IWServerControllerBase, IWAppForm, IWApplication,
  SysUtils;

type
  TIWServerController = class(TIWServerControllerBase)
    procedure IWServerControllerBaseNewSession(ASession: TIWApplication;
      var VMainForm: TIWAppForm);
  private
  public
  end;

  // This is a class which you can add variables to that are specific to the user. Add variables
  // to this class instead of creating global variables. This object can references by using:
  //   UserSession
  // So if a variable named UserName of type string is added, it can be referenced by using:
  //   UserSession.UserName
  // Such variables are similar to globals in a normal application, however these variables are
  // specific to each user.
  //
  // See the IntraWeb Manual for more details.
  TUserSession = class(TComponent)
  public
    FrmDm: TFrmDm;
    //
    constructor Create(AOwner: TComponent); override;
  end;

// Procs
  function UserSession: TUserSession;

implementation
{$R *.dfm}

uses
  IWInit;

function UserSession: TUserSession;
begin
  Result := TUserSession(RWebApplication.Data);
end;

{ TUserSession }

constructor TUserSession.Create(AOwner: TComponent);
begin
  inherited;
  FrmDm := TFrmDm.Create(AOwner);
end;

procedure TIWServerController.IWServerControllerBaseNewSession(
  ASession: TIWApplication; var VMainForm: TIWAppForm);
begin
  ASession.Data := TUserSession.Create(ASession);
end;

end.

Dando uma olhada rápida nessas units em termos de arquitetura o Intraweb mudou um pouco a organização entre as classes TServerController e TUserSession, porém ainda continua trabalhando com serialização de objetos. Veja que neste trecho de código do ServerController as classes são acessadas não por uma variável mas por uma função:

 function UserSession: TIWUserSession;
 function IWServerController: TIWServerController;
 function LockDataModule: TDataModule1;
 procedure UnlockDataModule(ADataModule: TDataModule1);

Observamos também que TUserSession agora herda de “TIWUserSessionBase”. Mas isso nos deixa muito pouca informação porque não temos acesso a definição desse ancestral.

Javascript no Intraweb 8.0.1

Pretendo testar um pouco como um IWForm está se comportando quando usamos processamento do lado cliente.

Propriedade “HiddenFields”

Aqui podemos criar inputs hidden dinamicamente para nossas páginas (Isso é novidade). No String List Editor digite:

  GMottaZn=VariaveisOuConstates_PraQuemGosta_do_InputHidden
  CoisasLoucas=Bla

Propriedade “ExtraHeader” do IWForm1

Digite o código Javascript na propriedade do IWForm1 conforme ilustrado abaixo:

  <SCRIPT LANGUAGE="JavaScript">
  <!-- Exibindo informações sobre o browser ...
  document.write("<HR>");
  document.write("<H1><center><font color=#0080C0 size=5 face=Geneva, 
  Arial, Helvetica, sans-serif>Estação ZN - Client Side Scripting 
  </font></center></H1>");
  document.write("<HR>");
  document.write(" <br>A versão do browser: " + navigator.appVersion);
  document.write(" <br>Marca: <B>" + navigator.appName + 
  "</B>.");
  // end script hiding -->
  </SCRIPT>

Propriedade JavaScript do IWForm1
Vou criar algumas funções JavaScript e veremos o que vai acontecer. A propriedade JavaScript declaramos apenas funções porque a tag “script type” é definida pelo framework. Diferente do que experimentamos da propriedade “ExtraHeader”.

// Percorre o objeto HTML "form". O Intraweb cria todos os objetos HTMLs
a partir do seu form "Delphi"
function ZnShowObjects(){
  for (var j = 0; j < document.forms[0].elements.length; j++) {
    alert("Loop volta = "+j);
    alert(document.forms[0].elements[j].name + ": " +document.forms[0].elements[j].value);
    ZnInput = document.forms[0].elements[j];
    alert("Bla");
    alert(ZnInput.getAttribute("type"));
    if (ZnInput.getAttribute("type").toLowerCase() == "hidden"){
      alert(ZnInput.getAttribute("type"));
     }
  }
};

//função para exibir o input hidden que criamos na propriedade "HiddenFields"

function ExibeHidden(){
  MyZn = document.getElementById("GMottaZn");
  alert(MyZn.type + "|" + MyZn.name + " = "+ MyZn.value);
 };

 //Exemplificando uma estrutura de repetição "while" em JavaScript
function ExibeEscondido(){
  MyZn = document.getElementById("GMottaZn");
  alert("Veja o input hidden que criamos:" + MyZn.value);
  ZnInputs = document.forms[0].getElementsByTagName('input');
  Achei = 0;
  i = 0;
  // exemplificando o método "getElementsByTagName", ele retorna uma lista de objetos HTML
  while (AZnInput = ZnInputs[i]){
    alert("while");
    // Procurando o hidden na lista retornada pelo "getElementsByTagName"
    if (AZnInput.getAttribute('type').toLowerCase() == 'hidden'){
      alert("Achei um escondido!! :" + AZnInput.name + " - "+
      AZnInput.value);
      Achei = Achei++;
       }
    else {
      // Não encontrou o hidden
      alert("Não é hidden: " + AZnInput.name + " - "+
      AZnInput.value);
      };
    i++;
  };
  if (Achei == 0) {
    alert("Não encontra os escondidos, mas eles estão lá!!!");
   }
  else {
    alert(Achei);
  };
};

Agora vamos adiciona os controles no IWF3orm1:
Adicione da plaheta IWStandard um TIWEdit, e três TIWButtons.



Testei a propriedade “ExtraTagParams” dos controles, sem sucesso por enquanto. Vou tentar mais posteriormente.

Na propriedade “ScriptEvents” da cada um dos IWButtons fiz a chamada a cada uma das funções que definimos na propriedade “JavaScript” do IWForm1. Veja as imagens abaixo e codifique igual:

IWButton1 - OnClick


IWButton2 - OnClick


IWButton3 - OnClick

Para executar a aplicação pressione F9. Vai aparecer o diálogo do simulador de servidor web, pressione F9 novamente.

Artigo completo (View Full Post)

Linq to SQL - Working with Databases

Clique aqui para ver a versão em português deste post

In this post I continue to show the Linq technology. This tiime we'll see how it's used to access and manipulate data in relational database tables.

In order to use Linq with databases we need to establish a relationship between the business objects in our software and the database tables. To achieve this we use the class/attributes mapping.

This mapping is simple: We create a class that represent a database table and in this class we set which table it is mapped to. In the attributes we set to which database fields they're mapped.

In the current version, Linq only supports the MS SQL Server, but there are already many developers out there working on solutions to cover other RDBMSs too.

To begin let's show a table in the database: Produtos

CREATE TABLE [dbo].[Produtos](
 [ProdutoID] [uniqueidentifier] ROWGUIDCOL
        NOT NULL CONSTRAINT [DF_Produtos_ProdutoID]  DEFAULT (newid()),
 [Descricao] [nvarchar](100) COLLATE Latin1_General_CI_AS NOT NULL,
 [Preco] [decimal](10, 2) NOT NULL,
 [Saldo] [int] NOT NULL,
 [Versao] [timestamp] NOT NULL
)

Let's pay close attention at the column Versao, type timestamp. This datatype stores the record version. This is very useful to work with optimistic updates and concurrency issues and Linq makes good use of it.

Before we advance, insert some records in this table.

Now let's create a class that uses this table. In order to use Linq to SQL we need to add reference to the assembly System.Data.Linq to the project. Here is the code:

using System;
using System.Data.Linq.Mapping;

[Table(Name="Produtos")]
class Produto {

    [Column(IsPrimaryKey = true,
            IsDbGenerated = true,
            AutoSync = AutoSync.OnInsert)]
    public Guid ProdutoID { get; set; }

    [Column(CanBeNull = false)]
    public string Descricao { get; set; }

    [Column(CanBeNull = false)]
    public decimal Preco { get; set; }

    [Column(CanBeNull = false)]
    public int Saldo { get; set; }

    [Column(IsDbGenerated = true,
            IsVersion = true, AutoSync = AutoSync.Always)]
    public System.Data.Linq.Binary Versao { get; set; }
}

Now let's create a Linq query in this database table. Up until here we just defined the entity and attributes mapping, but we didn't define anything about the database itself. How do we do that?

There is an object in Linq called DataContext. We can think of it more like a database connection in other technologies, but it hardly acts like. It does so much more! It's responsible for the database connection, making and the exectution of the queries, mapping, record updates and even transactions and record concurrency!

We just need to create a instance and it does everything on its own. In other words, we don't need to make code to open or close connection, build string queries and treat results anymore. Let's see the code:

using System;
using System.Data.Linq;
using System.Linq;

class Program {
    static void Main(string[] args) {

        var connStr = @"Data Source=.\SQLEXPRESS;Initial Catalog=DadosSql;User ID=felipe;Password=123";

        using (var db = new DataContext(connStr)) {
            var Produtos = db.GetTable<Produto>();

            var qry =
                from p in Produtos
                orderby p.Descricao
                select p;

            foreach (var prod in qry) {
                Console.WriteLine("{0}, {1}, {2}", prod.Descricao,
                                                   prod.Preco,
                                                   prod.Saldo);
            }
        }
    }
}

What we've done:

- Created a DataContext to connect to the database;
- Created a local variable to represent our mapped table;
- Built the query;
- Display the results;

The wonder of wonders is: Will the DataContext retrieve the entire Produtos table when we create the local variable Produtos? Answer is no! Then, will it occur when we create the qry? Nope. So, where is it?

One of the coolest things in Linq is the ability to send the query to the database only at the moment its data is actually required. In our case, in the foreach loop. That query returned an instance of IOrderedQueryable that seems like a List. But it isn't quite a common list. When its data is required the DataContext build a query based on its definition and send the query to the database and then convert the resultset in an object list, thanks to the mapping features. This technique is called Deferred execution.

How would we do in order to open connection, build a parametrized query and convert the resultset in a list of instances of our business object? And all other tables?

I'll change the code a bit and add some verbose. The DataContext has a property called Log that allows us to view the DataContext's log:

using System;
using System.Data.Linq;
using System.Linq;

class Program {
    static void Main(string[] args) {

        var connStr = @"Data Source=.\SQLEXPRESS;Initial Catalog=DadosSql;User ID=felipe;Password=123";

        using (var db = new DataContext(connStr)) {
            db.Log = Console.Out;

            Console.WriteLine("** Pegando a tabela Produtos");
            var Produtos = db.GetTable<Produto>();

            Console.WriteLine("** Criando a query");
            var qry =
                from p in Produtos
                where p.Descricao.Contains("a")
                orderby p.Descricao
                select p;

            Console.WriteLine("** Começando a iteração");
            foreach (var prod in qry) {
                Console.WriteLine("{0}, {1}, {2}", prod.Descricao,
                                                   prod.Preco,
                                                   prod.Saldo);
            }
        }
    }
}

Here's the console output:

** Pegando a tabela Produtos
** Criando a query
** Começando a iteração
SELECT [t0].[ProdutoID], [t0].[Descricao], [t0].[Preco], [t0].[Saldo], [t0].[Ver
sao]
FROM [Produtos] AS [t0]
WHERE [t0].[Descricao] LIKE @p0
ORDER BY [t0].[Descricao]
-- @p0: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [%a%]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.21022.8

Caderno Universitário 500 folhas, 7,90, 50
Caneta BIC, 1,99, 25
Lapiseira 0,7mm, 5,00, 10
Pasta polionda A4, 2,40, 6

The DataContext produces a query with parameters, instead of concatenate the criteria and build one simple query string. This is very nice, because the RDBMS can make an execution plan for this query and use the same play every time we run this query, even with different parameter values. It means better performance.

Well, that's it for this post, but Linq to SQL goes way further than this. In the next issue I'll write about CRUD operations with Linq to SQL. Thnnk you and take care.

Artigo completo (View Full Post)

Linq to SQL - Trabalhando com bancos de dados

Click here to see this post in English

Neste post vou continuar a mostrar sobre a tecnologia Linq. Desta vez veremos como ela é usada para acessar e manipular dados em tabelas de bancos de dados relacionais.

Para habilitar Linq para acessar bancos de dados nós precisamos primeiro estabelecer relações entre os objetos de negócio do nosso software e as tabelas do banco de dados. Para isso usamos mapeamento de classe/abtributos.

Este mapeamento é simples: Nós criamos uma classe que representa uma tabela do banco de dados e nesta classe nós indicamos qual tabela do banco de dados ela representa. Nas propriedades desta classe nós marcamos quais propriedades representam quais campos da tabela.

Na versão atual Linq suporta apenas o MS SQL Server, mas há desenvolvedores por aí que já estão trabalhando no suporte a outros bancos também.

Para começar vamos mostrar uma tabela no banco de dados: Produtos

CREATE TABLE [dbo].[Produtos](
 [ProdutoID] [uniqueidentifier] ROWGUIDCOL
        NOT NULL CONSTRAINT [DF_Produtos_ProdutoID]  DEFAULT (newid()),
 [Descricao] [nvarchar](100) COLLATE Latin1_General_CI_AS NOT NULL,
 [Preco] [decimal](10, 2) NOT NULL,
 [Saldo] [int] NOT NULL,
 [Versao] [timestamp] NOT NULL
)

Atenção especial à coluna Versao, do tipo timestamp. Esta coluna armazena a versão do registro. Ela é útil para efeitos de atualizações otimistas e concorrência e Linq faz ótimo uso dela.

Antes de continuar insira alguns registros nesta tabela.

Agora vamos codificar uma classe que faça uso desta tabela. Para utilizar Linq devemos adicionar referência no projeto para o assembly System.Data.Linq. Abaixo segue o código da classe:

using System;
using System.Data.Linq.Mapping;

[Table(Name="Produtos")]
class Produto {

    [Column(IsPrimaryKey = true,
            IsDbGenerated = true,
            AutoSync = AutoSync.OnInsert)]
    public Guid ProdutoID { get; set; }

    [Column(CanBeNull = false)]
    public string Descricao { get; set; }

    [Column(CanBeNull = false)]
    public decimal Preco { get; set; }

    [Column(CanBeNull = false)]
    public int Saldo { get; set; }

    [Column(IsDbGenerated = true,
            IsVersion = true, AutoSync = AutoSync.Always)]
    public System.Data.Linq.Binary Versao { get; set; }
}

Agora vamos criar uma query Linq nesta tabela do banco. Até aqui nós definimos o mapeamento da entidade e dos campos, mas nós não definimos nada sobre o banco de dados. Como faremos isso?

Há uma classe em Linq chamada DataContext. Podemos pensar nela como se fosse um objeto de conexão com um banco de dados, mas o DataContext vai além disso. Ele é responsável pela conexão com o banco de dados, montagem e execução das queries, tratamento dos resultados, cuida das operações de atualização dos registros e até cuida de transações e concorrência de registros!

Para isso só devemos instanciá-lo e ele faz tudo automaticamente! Ou seja, nós não precisamos mais criar códigos para abrir conexão, fechar conexão, montar queries em string, tratar resultados... Vamos ver na prática:

using System;
using System.Data.Linq;
using System.Linq;

class Program {
    static void Main(string[] args) {

        var connStr = @"Data Source=.\SQLEXPRESS;Initial Catalog=DadosSql;User ID=felipe;Password=123";

        using (var db = new DataContext(connStr)) {
            var Produtos = db.GetTable<Produto>();

            var qry =
                from p in Produtos
                orderby p.Descricao
                select p;

            foreach (var prod in qry) {
                Console.WriteLine("{0}, {1}, {2}", prod.Descricao,
                                                   prod.Preco,
                                                   prod.Saldo);
            }
        }
    }
}

Vamos repassar:

- Criamos um DataContext para conectar ao nosso banco de dados;
- Criamos uma variável local para ser a definição da nossa tabela mapeada;
- Fazemos a query extraindo dados desta "tabela";
- Exibimos os resultados.

A parte mais legal é: Será que o DataContext vai trazer a tabela Produtos inteira quando passar pela linha de código onde criamos a variável Produtos? A resposta é não! Então, quando o banco vai na tabela Produtos? Na linha onde criamos a qry? Também não! Ora, então onde é?

Uma das características mais legais do Linq to SQL é a habilidade de executar a query no banco apenas no momento em que seus dados são utilizados. No nosso caso, no loop foreach. Aquela query produziu a variável qry do tipo IOrderedQueryable que, parece, é uma lista. Tem até foreach! Mas ela não guarda as informações nela no momento em que é instanciada. Quando o software "requer" os dados desta "lista", ela produz uma instrução SQL select e traz do banco os resultados, transformando-os em uma coleção de instâncias da classe Produto, através do mapeamento. Isso é chamado Deferred execution.

Como iríamos fazer para abrir conexão com o banco de dados, criar uma query parametrizada e transformar um resultset de datarows em uma lista de instâncias de Produto? E para todas as outras tabelas?

Para reforçar o que foi dito acima, vamos ver o log do DataContext para ver o que ele faz e como faz. Vou adicionar algumas linhas de código ao nosso exemplo anterior e ele vai ficar assim:

using System;
using System.Data.Linq;
using System.Linq;

class Program {
    static void Main(string[] args) {

        var connStr = @"Data Source=.\SQLEXPRESS;Initial Catalog=DadosSql;User ID=felipe;Password=123";

        using (var db = new DataContext(connStr)) {
            db.Log = Console.Out;

            Console.WriteLine("** Pegando a tabela Produtos");
            var Produtos = db.GetTable<Produto>();

            Console.WriteLine("** Criando a query");
            var qry =
                from p in Produtos
                where p.Descricao.Contains("a")
                orderby p.Descricao
                select p;

            Console.WriteLine("** Começando a iteração");
            foreach (var prod in qry) {
                Console.WriteLine("{0}, {1}, {2}", prod.Descricao,
                                                   prod.Preco,
                                                   prod.Saldo);
            }
        }
    }
}

Olha aqui a saída do console:

** Pegando a tabela Produtos
** Criando a query
** Começando a iteração
SELECT [t0].[ProdutoID], [t0].[Descricao], [t0].[Preco], [t0].[Saldo], [t0].[Ver
sao]
FROM [Produtos] AS [t0]
WHERE [t0].[Descricao] LIKE @p0
ORDER BY [t0].[Descricao]
-- @p0: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [%a%]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.21022.8

Caderno Universitário 500 folhas, 7,90, 50
Caneta BIC, 1,99, 25
Lapiseira 0,7mm, 5,00, 10
Pasta polionda A4, 2,40, 6

A query que o DataContext produziu foi parametrizada, em vez de ter os valores concatenados. Isso é muito bom, porque o SGBD faz o plano de execução e deixa ele em cache, para que outras consultas que apenas tenham parâmetros diferentes usem o plano de execução que já foi calculado, trazendo melhor performance.

Com isso chegamos ao fim da nossa primeira visão sobre Linq to SQL e em outros posts vamos ver sobre as oeprações de CRUD com Linq to SQL. Até lá e muito obrigado.

Artigo completo (View Full Post)

Chromazone - Guitar and Bass

Nas horas não vagas, quando preciso zerar a mente, sentir como se ela fosse um papel em branco, encontro na música uma forma rápida e eficiente de atingir este estado. O tema do momento no meu momento é o “ultimate-extreme-hardcore” Choramazone. Sem sombra de dívida uma zona radical, contundentemente adiatônica, paradoxalmente polirrítmica. Essa música da onda .... hehehehhe
Corrigi alguns compassos da partitura que postei anteriormente. Contudo, não está academicamente perfeita, mantive a imperfeição conveniente e agradável, mas com um pouco de boa vontade dá pra entender tudo direitinho que está escrito (hehehhe).
Além disso, escrevi a partitura do baixo (Bass - score). Deu um trabalhinho fazer essa transcrição, estou sem prática. Apesar disso, foi mto prazeroso absorver esse groove (da melhor qualidade). Procurei a rodo na Internet, não achei nenhuma partitura (transcrita) do baixo do Chromazone, as vezes fico abismado como esse tipo de conteúdo é raro na web. Acho lamentável e não consigo entender pq!
O próximo passo será partir para os improvisos. Isso vai ser pedrera, um solo do Stern e um do Brecker!!! Aula de pós-graduação! Bem, se eu sobreviver ... vai ser relatado aqui ... hhehehhe.
Chega de papo ... segue as partituras:

página 1 de 4

página 2 de 4

página 3 de 4

página 4 de 4

Cavadas ...

Bass:

página 1 de 2

página 2 de 2

Guitar:

página 1 de 2

página 2 de 2

Artigo completo (View Full Post)

Finalmente Zerei o Resident Evil 4

Olá olá olá!!!

Desculpem tomar o espaço do blog dessa maneira mas eu finalmente consegui zerar o Resident Evil 4 do PS2! Eu não acreditava mas o jogo é um dos melhores que eu já joguei até hoje. Se existe por aí alguma outra pessoa no mundo (eu acho que sou a única pessoa do mundo que ainda não tinha terminado este jogo hehe) que ainda não tenha jogado, eu recomendo. Ótimas horas de diversão. Não se esqueça de também completar os jogos extras que liberam. Eu joguei o Assignment Ada e o Separate Ways e achei absurdo - muito maneiro.

Veja o que o gamespot fala sobre este jogo.

No mais estou terminando mais um post sobre Linq e vou postar aqui assim que eu terminar. Grande abraço a todos e até a próxima!

Artigo completo (View Full Post)

Delphi & JavaScript - IntraWeb

IntraWeb

Trata-se de um framework, desenvolvido pela Atozed, incorporado ao Delphi na versão 7. É uma suíte de desenvolvimento RAD (Rapid application development – Aplicação de desenvolvimento rápido) para web, na época em que foi lançada se apresentou no mercado, comparativamente com as demais tecnologias, extremamente poderosa. Por volta de 2004 e durante os anos seguintes, o IntraWeb fez do Delphi 7 um marco no desenvolvimento de aplicações sob o protocolo “http”.
Os componentes IW são extendidos da VCL tornando possível que o desenvolvimento com está tecnologia seja semelhante a um projeto desktop. Essa, na minha opinião foi uma característica importante do IntraWeb, visto que sua adoção por um profissional oriundo do ambiente “off-line” minimizou sensivelmente tanto o impacto, quanto a curva de aprendizagem dos novos conceitos concernentes ao ambiente web.
O IntraWeb permite, a partir de um form (web form), adicionar componentes, inclusive dataware, escrever códigos para os eventos dos mesmos e atribuir valores para suas propriedades (da mesma maneira que os desenvolvedores já faziam desde o Delphi 1). Pronto, eis o seu sistema ou site para Intranet, ou Internet! Tudo isso usando o boa e velha Delphi Language.
Esse framework ainda está presente nas novas versões do Delphi, contudo, ao que parece, são raros os projeto hoje que o utilizam. Acredito que a causa mais determinante para isso é o caráter fechado, proprietário, pois a Atozed não disponibilizou nem os fontes, nem mesmo uma documentação adequada do produto. Além disso tentou “arquitetar” um lance “mercadológico genial” de disponibilizar para venda versões supostamente mais estáveis e poderosas que ela havia incorporado ao Delphi. Não preciso gastar muitas linhas para descrever aonde ela chegou com essa estratégia genial.
Apesar disso, é possível conseguir em resultado bastante satisfatório usando o IntraWeb.

Javascript

“Linguagem de script, orientada a objetos, que permite a programação do lado cliente”.
O Javascript permite que haja processamento em resposta a interação do usuário com a página (no chamado “lado cliente”), sem a necessidade de remetê-la para ser processada no servidor. Isso se torna extremamente útil nos casos em que esse processamento não é exclusivamente necessário no servidor, visto que a dinâmica de requisição/resposta tem custos: o próprio processamento, que demanda do servidor recursos, e o fluxo na rede, que é um gargalo pro seu sistema. Por exemplo, a validação de valores digitados nas caixas de texto, como CPF, datas, valores nulos, e-mail e etc., são casos que podem, e devem, ser processados do lado cliente.

CSS

Cascading Style Sheets (Folhas de Estilo em Cascata): Permite controlar a aparência da página. Isso influencia diretamente o design do seu site ou aplicação web. Ao utilizar o CSS você pode especificar o estilo dos elementos que formatam a página (espaçamento, margens, tipo e tamanho de fonte) separadamente da estrutura dela (cabeçalhos de seção, títulos, corpo do texto e links). Essa separação da estrutura do conteúdo permite maior gerenciabilidade tornando, se necessária, qualquer mudança no estilo do site muito mais fácil e rápida.

DHTML

A Dynamic HTML foi projetada para que uma aplicação web possa ser construída de forma que grande parte de suas funcionalidades sejam executadas diretamente no lado cliente, ao invés do lado servidor. Ela faz as páginas web tornarem-se muito mais interativas fornecendo efeitos multimídia que incluem animação, áudio e vídeo. Ora, mas o Javascript não possui o mesmo objetivo? Então, o que é exatamente o DHTM? Basicamente a DHTML permite que os elementos do HTML possam ser tratados como objetos. Logo, torna possível manipular os valores dos atributos desses elementos como propriedades. A manipulação dessas propriedades é feita através do Javascript, ou qualquer outra linguagem de script como o JScript, ou VBScript, por exemplo. A DHTML da Microsoft é incompatível com a da Netscape, portanto, saiba que a utilização desta técnica pode lhe trazer problemas. Por isso é imprescindível que testes sejam realizados nos diferentes navegadores, pelo menos nos mais usados, se você optar por utilizar a DHTML.

Criando a plicação web para teste

Começaremos nosso primeiro exemplo criando um novo projeto IntraWeb no Delphi. Antes de Qualquer coisa crie um diretório para salvarmos nosso exemplo em: C:\Exemplo_1.

Agora podemos voltar ao Delphi, no menu "File" - "New" click em "Other". Em seguida, no repositório de objetos escolha, na aba IntraWeb, Stand Alone Aplication.

O próximo passo será salvar a aplicação iniciada em “c: Exemplo_1”.



Aperte “Ctrl + F12”, selecione IWUnit1 e click “OK” para chamarmos o form Intraweb.





Form IntraWeb (TWIForm)

O TIWForm é o componente IntraWeb similar ao TForm da VCL, através deste componente o Delphi gera páginas web. Nele podemos definir o estilo CSS que será usado para o design da página, também podemos programar scripts do lado cliente e desta forma extrair o máximo do paradigma web.

ExtraHeader

Começaremos pela propriedade do ExtraHeader do TIWForm, nela podemos adicionar qualquer tag com código dentro da seção Head (que é definida pela tag “<head> </head>” de uma página HTML). O browser interpreta o conteúdo da tag head antes da tag body , deste modo podemos tanto escrever programas em Javascript para serem executados imediatamente no momento em que a página é renderisada pelo navegador, quanto podemos codificar funções que serão executadas mediante uma determinada interação do usuário com o browser. Você pode usar o editor do
DreamWeaver para lhe auxiliar a criar as funções em Javascript.

O código na anterior deve ser colocado na propriedade ExtraHead do TformMain. Para isso, com o TIWForm selecionado, vá ao Object inspector e click na propriedade ExtraHeader.



StringList Editor



Segue o código:

<script type="text/javascript">
  document.writeln("<center> <h1> <font face= 'Australian Sunrise' color=#220099> Javascript no Itraweb - powered by Delphi</font> </h1> </center>");
  var shadowDirection = 0;
  function iniciar(){
    window.setInterval("demostrar()",500); 
   }

  function demostrar(){
    shadowText.filters("shadow").direction = (shadowDirection % 360); 
    shadowDirection += 15;
    }
</script>

Para executarmos a função iniciar adicionaremos ao Form um TIWButton e um IWLabel da palheta IWStandard. Na tabela a baixo veja como configura-los.



Configuraçao dos Componentes

TIWButton: Name = BtConfirmar, Top = 360, Left = 350, Caption = Confirmar

TIWLabel: RawText = True, Caption = <h2 id = "shadowText" style= "position:absolute; top:120px; left:340px; filter: shadow(direction = 0, color = #220099)"><font face="Australian Sunrise" color="#FF6633"> DHTM - Dynamic HTML </font></h2>


Depois de adicionar o código que vai definir o texto animado na propriedade caption do IWLabel1 a aparência fo IWForm ficará semelhante a figura abaixo:



Codifique a unit “IWUnit1” conforma exemplificado abaixo:

Crie uma procedure na seção public para validar campos vazios em JavaScript. Essa função criará uma critica dinamicamente para cada componente que possuir um valor na propriedade FriendlyName iniciando por “v_”.

procedure TformMain.Validacao;
var i: Integer;
 Funcoes: array of TStringList;
 EditAtual: TIWCustomEdit;
begin
{esta funçao monta o java script na página. Lembre-se de, no FriendlyName do Edite ou memo, iniciar com "V_" .
Depois no evento scripEvent do IWbutton chamar a função   ValidaEmBranco() }
 Self.JavaScript.Add('function ValidaEmBranco() {');
 SetLength(Funcoes, Self.ComponentCount);
 for i := 0 to Pred(Self.ComponentCount) do
 begin
   if (Self.Components[i] is TIWCustomEdit) then
   begin
     EditAtual := TIWCustomEdit(Self.Components[i]);
     if Copy(EditAtual.FriendlyName, 1, 2) = 'v_' then
     begin
       Funcoes[EditAtual.TabOrder] := TStringList.Create;
       with Funcoes[EditAtual.TabOrder] do
       begin
         Add(#13#10);
         Add('  if (document.forms[0].' + UpperCase(EditAtual.Name) + '.value == "") {');
         Add('    alert("Preencha o campo ' + Copy(EditAtual.FriendlyName, 3,
           Length(EditAtual.FriendlyName)) + '");');
         Add('    document.forms[0].' + UpperCase(EditAtual.Name) + '.select();');
         Add('    return false;');
         Add('  }');
       end;
     end;
   end
 end;

 for i := 0 to Pred(Length(Funcoes)) do
   if not (Funcoes[i] = nil) then
     Self.JavaScript.Add(Funcoes[i].Text);

 Self.JavaScript.Add('    return true;');
 Self.JavaScript.Add('}');
end;

No evento "OnCreate" do formMain digite:

procedure TformMain.IWAppFormCreate(Sender: TObject);
begin
 Validacao;
end;
 

Na propriedade ExtraTagParams do BtConfirmar digite:

onClick=ValidaEmBranco();

Adicione ao formMain um TIWEdit da palheta IWStandard. Apague o valor da propriedade Text, em seguida altere o valor da propriedade "FriendlyName" para v_IWEdit1. Para que nossa função para efetuar a crítica conforme espera a procedue "Validacao" que criamos anteriormente.

Para executar a plicação basta apertar o F9, ou no menu "Run" selecionar "Run".

Artigo completo (View Full Post)

Identificadores e Palavras Reservadas - Java

Identificadores e Palavras Reservadas

Identificadores é o que usamos para nomear variáveis, instâncias de classe (que também são variáveis), constantes, métodos e propriedades. Em outras palavras, identificador é tudo que não seja um literal, nem símbolos ou números, nem palavras reservadas. Existem regras que determinam como devem ser declarados os identificadores permitidos em Java (igualmente como em qualquer outra linguagem de programação. Pelo menos, até os dias de hoje). Além dessas regras de sintaxe, a Sun define uma convenção para nomeação de métodos, variáveis e classes. Semelhantemente as demais linguagens de programação, em Java existe um conjunto de palavras reservadas para a linguagem. Isso implica que não é possível usá-las para nomearmos identificadores. Mais tarde falarei detalhadamente sobre a convenção para criação de identificadores para métodos, propriedades e classes em Java.

Obs: Ok, anteriormente escrevi sobre a mesma coisa com uma outra abordagem acho que se vc ainda tem alguma dúvida sobre esse tema pode encontrar ....

Cabe destacar que a adoção de uma padronização quanto a codificação é comum em muitas linguagens de programação, falaremos sobre isso mais tarde.

Regras para nomeação de Identificadores

A sintaxe da linguagem Java define as seguintes regras para se declarar identificadores:

Os identificadores devem começar com uma letra, ou cifrão ($), ou Underscore ( _ ). Não é permitido caracteres numéricos para iniciar um identificador.

Palavras reservadas não podem ser usadas como identificadores.

A linguagem Java é case sensitive (sensível a caixa) para identificadores. Exemplo: Cliente e cliente são, para o compilador, identificadores diferentes.

Não há limite para o número de caracteres usados para compor um identificador.

Exemplo de identificadores grafados de forma correta:

  int _a; 
  String $Coisas;
  double _$;
  double um_Exemplo_de_nome_bastanteZn_Prolixo_para_um_identificadorZn;

Em seguida veja exemplos de identificadores declarados de forma não aceitável para o compilador.

  int  :b;
  int  -di
  int  e#;
  int  .f;
  int  79;

Exemplo de um programa em Java para testarmos as regras sobre identificadores citadas:
Primeiro veremos um programa “dummy” cujo os identificadores criaremos de forma convencional.

import javax.swing.JOptionPane;
/**
*
* @author Gerson
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
String znSaida = "";
int EstacaoZn = 2;

for (int i = 1; i <= 10; i++){           if (i == 5) continue;           znSaida += i + " ";       }        znSaida += "\n bleng Zn! Skip -->  5";
JOptionPane.showMessageDialog(null, znSaida);
System.exit(0);
}

}

Segundo veremos o mesmo programa “dummy”, contudo alteraremos os nomes dos identificadores para as situações específicas definidas pelo Java 5.

Criando um novo projeto no NetBeans

Definindo o diretório onde o projeto seja salvo

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package exemploidentificadoreszn2;

import javax.swing.JOptionPane;
/**
*
* @author GMottaZn
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
String _znSaida = "";
int $EstacaoZn = 2;
String um_Exemplo_de_nome_bastanteZn_Prolixo_para_um_identificadorZn;
for (int i = 1; i <= 10; i++){           if (i == 5) {               $EstacaoZn = (4 + $EstacaoZn);               continue;               }           else{             $EstacaoZn = (10 + $EstacaoZn);             um_Exemplo_de_nome_bastanteZn_Prolixo_para_um_identificadorZn = "Estaçao ZN = ";           }               ;             _znSaida += i + " " + um_Exemplo_de_nome_bastanteZn_Prolixo_para_um_identificadorZn;       }       _znSaida += "\n bleng Zn! Skip -->  5 - $EstacaoZn = " + $EstacaoZn;
JOptionPane.showMessageDialog(null, _znSaida);
System.exit(0);
}

}

Artigo completo (View Full Post)

Abordagem OO Java - Introdução

Recorrentemente temos abordado POO aqui no blog. Nosso foco maior tem sido Delphi e C#, contudo sempre que podemos procuramos ampliar nossos exemplos experimentando outras linguagens. Vamos falar um pouco desse contexto no mundo Java.

Breve revisão sobre Java

Um programa em Java é sempre uma coleção de objetos comunicando-se com outros. Comunicação essa que acontece mediante a chamada de métodos (evocação de métodos) uns dos outros. Nunca esquecendo, de ter sempre em mente que cada objeto é de um determinado tipo, definido por uma classe ou interface. Não desprezado o fato dessa coleção de objetos, a qual mencionei anteriormente, ser quase sempre composta por objetos de uma variedade diferente de tipos. Vejamos as seguintes definições sobre OO (Estou usando como referência para este artigo o livro da Kathy Sierra, certificação Sun (Java 5), primeiro capítulo):

Classe:
Um modelo que descreve os tipos, de estado e de comportamento, que os objetos do seu tipo podem ter.

Permita-me um comentário: Particularmente, eu acho essa definição satisfatória para quem já conhece bem orientação a objetos. Contudo, para quem esta aprendendo programação ou vem de uma cultura de programação estruturada, duvido que o parágrafo anterior agregue algum valor, no que tange o processo cognitivo de quem o está lendo. Em outros artigos eu e o Felipe usamos outras abordagens para este conceito. Sugiro que você complemente o entendimento lendo as demais definições, principalmente se você ainda esta dando os primeiros passos em OO.

Objeto:
No momento da execução do programa, quando a JVM (Java Virtual Machine) encontra a palavra reservada “new” ela cria uma instância da classe, referenciada no trecho de código corrente. A isso chamamos de criar um objeto (em outras palavras: instanciar um objeto). Esse objeto recém criado terá seu próprio estado, bem como um comportamento. O qual será expressado como reflexo de todas as funcionalidades, definidas por métodos na classe, que são dinamicamente acessíveis ao objeto.
Quem são essas classes acessíveis ao objeto??? Isso se refere a herança. Um objeto cujo tipo é, por exemplo, uma classe “X” terá acesso ao comportamento de todos os ancestrais dela. Ou seja, ele poderá se comportar como a classe “X”, a classe “XPai”, bem como a classe “XAvo” e assim sucessivamente até o ancestral mais alto (o qual chamamos de super classe). Falaremos mais sobre herança adiante.

Estado:
Variáveis de instância – Cada objeto (que por sua vez é uma instância de uma classe) terá seu conjunto único de variáveis de instância conforme definido na classe (definidos pelos atributos da classe). Em contra partida, coletivamente os valores atribuídos as variáveis de instância de um objeto, expressam o estado do mesmo. Ou, os valores persistidos pelas propriedades do objeto, expressam o estado do mesmo.
Ou seja, o conjunto de atributos do objeto definirá, a partir dos valores definidos neles, o estado desse objeto. Por exemplo: Suponha que temos um objeto “Lâmpada”, esse objeto é possuidor de um conjunto de atributos: Potência, Voltagem, Cor e etc. Devemos considerar que este objeto, além desses, possua outro atributo que definirá se “Lâmpada” esta acesa ou não. Esse atributo pode se chamar “Ativa”, ele indica se ela está acessa (ou seja, ativa) ou não. Logo, quando todos esses atributos possuírem valor, exemplo: Lâmpada.Cor = Amarela, Lâmpada.Voltagem = 110, Lâmpada.Potência = 100W e Lâmpada.Activa = Verdadeiro. Posso agora então conhecer o estado desse objeto.

Comportamento:
Quando codificamos uma classe, e implementamos os métodos dela, estamos definido a lógica da classe. “É nos métodos que a lógica da classe é armazenada” (Achei essa definição muito apropriada). Através dos métodos, o verdadeiro trabalho da classe é realizado. Ou seja, a razão de ser da classe, onde seu principal objetivo é definido. Neles e por meio deles, algoritmos são executados e os dados são manipulados.

Herança:

Característica da orientação a objetos que permite o reaproveitamento do código de uma classe por outra. Em Java é possível definir uma superclasse “genérica” (mais abstrata) e em seguida estendê-la criando outras classes mais específicas. A superclasse não tem conhecimento algum sobre as classes que descendem dela. Em contra partida, essas classes herdeiras precisam declarar explicitamente a relação de herança. Como efeito disso, uma subclasse que herda de uma superclasse “recebe automaticamente”, digamos assim, as variáveis de instância acessíveis, bem como os métodos definidos na superclasse. Além disso possui autonomia para redefinir os métodos herdados da superclasse, a fim de expressar um comportamento mais específico (este fenômeno chamamos de sobrescrita de método. Ou seja uma subclasse pode sobrescrever os métodos herdados).

Identificando Classes (Análise)

Em concordância com o que mencionei anteriormente, é extremamente importante ser obstinado em alcançar um grau de coesão alto na classe que você está definindo. Isso implica diretamente que toda classe deve ter muito bem definido o conjunto de responsabilidades pertinentes ao conceito do mundo real o qual ela representará para um sistema. Por exemplo, imagine um programa cujo objetivo principal é simular uma orquestra: Certamente encontraremos a representação de instrumentos musicais por algumas classes, bem como músicos, partituras e composição musical por outras tantas. Concluir isso é bastante elementar. Contudo, um erro fatal (e na minha opinião muito freqüente) seria definir, em virtude de um equívoco de análise, o comportamento (ou parte dele) de uma classe em outra, ou vice-versa. Por exemplo: A classe instrumentista possuir um método que retorne o compasso corrente. Creeeeeddddooooo!??!?!?!? Visto que, compasso é um atributo da classe partitura. Um programa em Java é constituído tanto por classes construídas pelo programador, quanto por e outras que não (por exemplo, classes Java API). Em Java as classes são organizadas em pacotes, os quais devemos referenciar mediante a palavra reservada “import” a fim de usarmos suas classes em nossos programas. Dessa forma a linguagem fornece uma forma consistente do desenvolvedor nomear, bem como obter acesso, as classes que necessitar. No exame de certificação Java a avaliação aborda muitos dos conceitos relacionados aos pacotes e acesso a classes. Posteriormente detalharemos mais esses temas.

Interfaces:
É uma espécie de superclasse cem por cento abstrata que define os métodos que uma subclasse deve suportar, mas não define como esse método deve se comportar (ou seja, não define come deve ser implementado). Exemplificando, uma interface "Instrumento Musical" pode declarar que todas as as classes de implementação de "Instrumento Musical" (estendidas dela) possuirão um método "reproduzirSom()". Contudo, a interface "Instrumento Musical" não fornece nenhuma lógica para para este método. Isso implica que a classe que implementar "Instrumento Musical" terá a responsabilidade de definir o comportamento dos métodos definidos na interface. Determinando então, desta forma, como cada instrumento irá se comportar particularmente.
Venho sentindo a necessidade de escrever sobre interface não é de hoje, entretanto ainda não consegui preparar um material que me agrade. Esse assunto esta na fila e considero extremamente pertinente.

Artigo completo (View Full Post)

Donwload Day 2008 - Firefox 3

No dia 17 de Junho de 2008 estaremos presente, com certeza. Inclusive, Eu já confirmei minha participação.
Trata-se da data oficial do lançamento do Firefox 3. Nós do Estação ZN estamos participando, torcendo, apoiando e convocando todos os leitores à esta iniciativa.
Acredito que essa ação vai além de uma brincadeira cujo objetivo é um Record irrelevante. Sua participação consciente é muito importante. O Mozilla Foundation faz o apelo com essas palavras:
“Tudo o que você precisa fazer é baixar o Firefox 3 durante o Download Day - é fácil assim. Não estamos pedindo que você engula uma espada ou equilibre 30 colheres no rosto ao mesmo tempo - apesar de que isso seria incrível. inscrevendo-se hoje para baixar o Firefox 3”.

Use a cabeça, pense. Pois quando a cabeça não pensa o corpo e o bolso é que pagam.
Saiba mais em:

• Mozilla.org
• Outros projetos Mozilla

Artigo completo (View Full Post)

NetBeans 6.1

A Sun Microsystems não brinca em serviço, o projeto NetBeans (fundado a aproximadamente oito anos), do qual é a principal patrocinadora, é um bom exemplo disso. Neste projeto, ao logo de sua trajetória, mostra de forma incontestável o investimento dessa organização em ser uma referencia no mercado também na área de desenvolvimento.

O ambiente de desenvolvimento NetBeans (IDE) - é completamente escrito em Java, está na versão 6.1 e pode suportar qualquer linguagem de programação. Com um grande diferencial: A IDE NetBeans é um produto livre, sem restrições comerciais de como ela pode ser usada. Ela é open source, livre para uso comercial e não comercial. O código fonte está disponível para ser usado através da licença Common Development and Distribution License (CDDL). O Netbeans 6.1 está disponível para download em: Download NetBeans 6.1
Siga as instruções para instalação: Instalação

Para quem desejar se aprofundar nesse caminho, aconselho conhecer o netbeans.org. É o endereço da comunidade NetBeans, cujo o objetivo é construir uma IDE de nível mundial, e disseminar esse produto. O foco dessa tribo é Java, mas, não se engane, lá você pode aprender muito sobre C++, Ruby, XML, tecnologias para web (Javascript, Ájax e etc..). Através do netbeans.org é possível, de forma democrática, ter acesso a pessoas e recursos da comunidade NetBeans.

Tanto para baixar as últimas versões da IDE, ver a documentação on-line, aumentar seu conhecimento sobre Java, quanto acompanhar notícias, ou participar de listas de discussão. Em outras palavras expandir seu universo, tudo isso é possível na comunidade. A própria comunidade incentiva a participação ativa dos seus, digamos, usuários/leitores. Lembrando que, uma boa parte dos tutorias possui tradução para o Português. Isso certamente é relevante para quem encontra dificuldade com o Inglês. Faça download da IDE e experimente o quick start em Português.

Existe uma variedade considerável de listas de discussão, a comunicação entre os usuários do NetBeans é fator positivo a mais a favor da ferramenta. Click e confira, a página de listas é: http://www.netbeans.org/community/lists/index.html

Notícias semanais e mensais: Inscreva-se Inscreva-se na lista nbannounce.
Converse com outros usuários NetBeans, troque dicas aumentando de forma efetiva seu conhecimento (saiba mais).

Artigo completo (View Full Post)