Lançamento Delphi XE
By tresloukadu
Depois que a Embarcadeiro adquiriu o Delphi uma evolução impressionante vem ocorrendo com esta IDE. E agora mais uma novidade! O Delphi XE (“Delphi 2011″) foi lançado. A partir de agora os produtos da Embarcadeiro estão recebendo o XE no nome. Neste link tem a explicação da mudança no nome da versão. Bom mas o que importa de verdade não é o nome da versão e sim as melhorias, pois muitas pessoas ficam em dúvida na hora de adquirir uma nova versão, pois não sabem se vale à pena ou não.
O Delphi XE é o modo mais rápido para o desenvolvimento de aplicações ricas e de alto desempenho para toda a família Windows inclusive o Windows 7.
O Delphi XE diminui dramaticamente o tempo de desenvolvimento por possibilitar a criação de aplicativos 5 vezes mais rápido por possibilitar desenvolvimento baseado em componentes e uma RAD IDE com um visual totalmente bidirecional. Velocidade no desenvolvimento para todas as versões do Windows e as principais databases do mercado o Delphi XE é excelente para o desenvolvimento de: Aplicativos Desktops, Touch-screen interativos, kiosks, base de dados, computação na nuvem. E mais com o Delphi XE você pode:
- Desenvolver aplicativos mais rápido com componentes pré-construídos e um visual com uma interface super amigável e com drag-and-drop;
- Desenvolvimento de aplicativos que requerem velocidade na visualização dos dados, controle do hardware em tempo real, manipulação de objetos 3D, modelagem financeira, desenvolvimento de games, manipulação de imagens, aplicações para equipamentos hospitalares, sistemas ERP e muito mais!
- Seus aplicativos prontos para o futuro com conexão nativa a 9 tipos de databases e componentes prontos para computação na nuvem;
- Utilize milhares de componentes comerciais e gratuitos para criação da interface de seus programas, aplicativos web, sistemas baseado em databases, ERP e muito mais.
Confira os vídeos totalmente em português:
Muitas novidades estão por vir, confira aqui o site oficial com mais novidades.
Join the forum discussion on this post
dezembro 16th, 2010
Dica : Depurando no Delphi
By tresloukadu
Muitas vezes quando a nossa aplicação apresenta algum comportamento estranho, trava ou algo simplesmente não sai como o esperado temos um erro de lógica. E os erros de lógica são mais sutis pois eles não são acusados pelo compilador. Muitas vezes esses erros são difíceis de achar, pensando nisso a IDE do Delphi apresenta um super conjunto de ferramentas para nos auxiliar a encontrar onde está o erro de lógica.
A técnica de ir linha a linha em uma aplicação procurando onde existe o erro é chamada de depuração. É comum também escutar a expressão debugar, esta expressão é a mesma coisa que depurar, a diferença é que debugar vem da palavra em inglês debugger. Mas tanto depurar quanto debugar são a mesma coisa.
Bom indo direto ao ponto vamos começar com um exemplo prático. Tudo o que precisamos fazer é adicionar um breakpoint no nosso código.
Debugando no Delphi
Como a imagem mostra em 2 (imagem ampliada) tudo o que precisamos fazer é dar um clique com o mouse na linha que queremos e automaticamente uma bolinha vermelha aparece (como na imagem ampliada mostrando o breakpoint).
Agora quando apertarmos F9 para compilar o nosso programa ele vai executar normalmente e no momento em que a execução do programa chegar na linha onde colocamos o nosso breakpoint o Delphi dá uma pausa na nossa aplicação e dá o foco para o ambiente de depuração do dele próprio.
Bom estamos no ambiente de depuração, o que podemos fazer agora? Uma das coisas legais é só deixarmos a seta do mouse sobre alguma variável (como é mostrado em 1) e automaticamente o Delphi exibe um hint como o valor da variável naquele momento da execução da aplicação. Outra opção é usarmos o Watch List onde podemos arrastar qualquer variável para ele e o mesmo fica monitorando cada variável, como é mostrado na seguinte imagem:
Utilizando o Watch List
Fora a chance de trabalharmos com as variáveis o debugger do Delphi permite também depurarmos as procedures. Para isso é só colocarmos um breakpoint onde estamos chamando a nossa procedure e apertar o F9. Quando o Delphi chegar na linha onde está o breakpoint ele vai parar (do mesmo modo que foi feito na variável), ai nesse momento é só apertarmos o F7 e o Delphi nos levará para dentro da procedure que estamos chamando, e como isso podemos ver o que está ocorrendo dentro da procedure.
Para pararmos a depuração e continuar a executar o programa é só apertarmos o F9 e para matar a aplicação é só apertamos o atalho CTRL + F2.
Essas ferramentas fazem toda a diferença quando estamos procurando um bug no nosso aplicativo. Existem outras coisas que são possíveis fazer com o debugger mas a citadas aqui são as mais usuais.
t+
Dica : Teclas de Atalhos no Delphi
By tresloukadu
No Delphi existe muitas teclas de atalhos, mas a maioria nem chegamos a utilizar, principalmente quando estamos começando a aprender. Por isso ao invés de colocar uma lista imensa de teclas de atalhos, vou apresentar quais são as teclas utilizadas com maior frequência. Essas teclas facilitam muito o nosso trabalho pois acabam por tornar a tarefa de programar mais ágil. Bom vamos começar…
A tecla mais importante é o CTRL + S pois é utilizada para salvar o projeto 
. Após que ganhamos uma certa experiência na programação no Delphi o uso desse atalho se torna frequente e automático. Qualquer alteração que fazemos já estamos apertando CTRL + S, assim garantimos que o projeto está salvo, e se por ventura der uma queda de energia, não perderemos nada.
F12 – Chama o Code Editor, se torna mais útil ainda quando o nosso form está ocupando a tela toda.
F11 – Chama o Object Inspector, eu gosto de trabalhar com o Code Editor Full Screen e a mesma coisa se dá com o form, sendo assim quando preciso alterar a propriedade de algum componente no Object Inspector, é só apertar F11.
CTRL + Setas ( as setas para esquerda, cima, baixo, direita) – No form elas ajustam a posição dos dos componentes no form.
Shift + Setas ( as setas para esquerda, cima, baixo, direita) – No form elas alteram o tamanho do componente selecionado.
CTRL + F2 – Quando executamos o nosso aplicativo e por algum motivo ele trava não deixando fechar o mesmo, podemos apertar CTRL + F2 para matar e voltar para o Delphi.
CTRL + Shift + C – Essa tecla é meia complicadinha de apertar mais muito muito útil. Quando estamos na seção interfaces definindo a nossa procedure e apertamos esse atalho o Delphi já gera a procedure certinha para nós na parte do implementation. Como mostra o exemplo:
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, LResources, Forms, Dialogs, StdCtrls;
type
{ TForm1 }
TForm1 = class(TForm)
private
{ private declarations }
//*************************************************************
//Apertando CTRL + SHIFT + C, em cima dessa procedure
//*************************************************************
procedure MinhaProcedure(minha_var : string);
public
{ public declarations }
end;
var
Form1: TForm1;
implementation
{ TForm1 }
//*************************************************************
//Ao apertas o CTRL + SHIT + C essa procedura foi gerada automatica
//*************************************************************
procedure TForm1.MinhaProcedure(minha_var: string);
begin
end;
CTRL + Espaço – Essa tecla server para chamar o code completion, quando estamos digitando alguma procedure, variável, etc… e apertamos CTRL + Espaço ele já tenta completar o resto para gente. Muito útil, principalmente quando estamos em dúvida com o nome de alguma variável, pois assim ele já coloca a variável com o nome certo.
CTRL + Shift + Espaço – Quando estamos digitando alguma procedure e não sabemos o argumento que ela aceita, é só apertarmos esse atalho e o Delphi mostra os paramêtros aceitos pela mesma.
F1 – Essa tecla chama a ajuda do Delphi, muito útil, se estamos no Object Inspector e estamos em dúvida com alguma opção é só clicarmos nela e apertar o F1 e o Delphi traz a ajuda dessa opção. A mesma coisa se dá na edição de código só clicarmos na procedure que temos dúvida e apertar F1 e voila a ajuda aparece na nossa frente =).
CTRL + F – Abre a tela para pesquisar. Quando o nosso código está muito grande e queremos achar algo (uma variável por exemplo) esse atalho se torna super útil.
CTRL + Shift + Seta para cima – Quando estamos em uma procedure e queremos ver a definição da mesma na interface é só apertar esse atalho e o Delphi nos leva até lá, e para retornar para o ponto de onde saímos é só apertar CTRL + Shift + Seta para baixo.
Bom essas são as teclas mais usuais.
t+