Introdução ao C# (CSharp)

Com esse artigo inicio uma série sobre esta linguagem de programação.
C# (pronuncia-se "cê chárp" em português ou "cí charp" em inglês), é uma linguagem de programação orientada a objetos, fortemente tipada, desenvolvida pela Microsoft como parte da plataforma .NET. A sua sintaxe orientada a objetos foi baseada no C++ mas inclui muitas influências de outras linguagens de programação, como Object Pascal e Java.

A criação da linguagem, embora tenha sido feita por vários programadores, é atribuída principalmente a Anders Hejlsberg, hoje um Distinguished Engineer na Microsoft. Ele fora o arquiteto de alguns compiladores da Borland, e entre suas criações mais conhecidas estão o Turbo Pascal e o Delphi.

Características

O C# é, de certa forma, a linguagem de programação que mais diretamente reflete a plataforma .NET sobre a qual todos os programas .NET executam. C# está de tal forma ligado a esta plataforma que não existe o conceito de código não-gerenciado (unmanaged code) em C#. Suas estruturas de dados primitivas são objetos que correspondem a tipos em .NET. A desalocação automática de memória por garbage colletor além de várias de suas abstrações tais como classes, interfaces, delegados e exceções são nada mais que a exposição explicita recursos do ambiente .NET.

Quando comparada com C e C++, a linguagem é restrita e melhorada de várias formas incluindo:

* Ponteiros e aritmética sem checagem só podem ser utilizados em uma modalidade especial chamada modo inseguro (unsafe mode). Normalmente os acessos a objetos são realizados através de referências seguras, as quais não podem ser invalidadas e normalmente as operações aritméticas são checadas contra sobrecarga (overflow).

* Objetos não são liberados explicitamente, mas através de um processo de coleta de lixo (garbage collector) quando não há referências aos mesmos, previnindo assim referências inválidas.

* Destrutores não existem. O equivalente mais próximo é a interface Disposable, que juntamente com a construção using block permitem que recursos alocados por um objeto sejam liberados prontamente. Também existem finalizadores, mas como em Java sua execução não é imediata.

* Como no Java, não é permitida herança múltipla, mas uma classe pode implementar várias interfaces abstratas. O objetivo principal é simplificar a implementação do ambiente de execução.

* C# é mais seguro com tipos que C++. As únicas conversões implícitas por default são conversões seguras, tais como ampliação de inteiros e conversões de um tipo derivado para um tipo base. Não existem conversões implícitas entre inteiros e variáveis lógicas ou enumerações. Não existem ponteiros nulos (void pointers) (apesar de referências para Object serem parecidas). E qualquer conversão implícita definida pelo usuário deve ser marcada explicitamente, diferentemente dos construtores de cópia de C++.

* A sintaxe para a declaração de vetores é diferente ("int[] a = new int[5]" ao invés de "int a[5]").

* Membros de enumeração são colocados em seu próprio espaço de nomes (namespace)

* C# não possui modelos (templates), mas C# 2.0 possui genéricos (generics).

* Propriedades estão disponíveis, as quais permitem que métodos sejam chamados com a mesma sintaxe de acesso a membros de dados.

* Recursos de reflexão completos estão disponíveis

C# Versus Java 

Apesar de C# ser freqüentemente tido como similar a Java, existem uma série de diferenças importantes, tais como:

* Java não implementa propriedades nem sobrecarga de operadores.

* Java não implementa um modo inseguro que permita a manipulação de ponteiros e aritmética sem checagem.

* Java possui exceções checadas, enquanto exceções em C# são não checadas como em C++.

* Java não implementa o goto como estrutura de controle, mas C# sim.

* Java utiliza-se de comentários Javadoc para gerar documentação automática a partir de arquivos fonte. C# utiliza comentários baseados em XML para este propósito.

* C# suporta indexadores e delegados.

Bibliotecas de códigos

Ao contrário das outras linguagens de programação, nenhuma implementação de C# atualmente inclui qualquer conjunto de bibliotecas de classes ou funções. Ao invés disso, C# está muito vinculada ao framework .Net, do qual C# obtém suas classes ou funções de execução. O código é organizado em um conjunto de namespaces que agrupam as classes com funções similares. Por exemplo: System.Drawing para gráficos, System.Collections para estrutura de dados e System.Windows.Forms para o sistema Windows Form.

Um nível de organização superior é fornecido pelo conceito de montador (assembly). Um montador pode ser um simples arquivo ou multiplos arquivos ligados juntos (como em al.exe) que podem conter muitos namespaces ou objetos. Programas que precisam de classes para realizar uma função em particular podem se referenciar a montadores como System.Drawing.dll e System.Windows.Forms.dll assim como a biblioteca core (conhecida como mscorlib.dll na implementação da Microsoft).

Para quem desejar saber mais sobre o assunto seguem alguns links que entre outros serviram de base para este post

wikipedia e Oficina da Net 

O Silverlight morreu?

Na manhã de hoje (23/11/2010), em uma reunião com a equipe de desenvolvimento da empresa onde trabalho, um dos colaboradores afirmou categoricamente: "o Silverlight morreu, foi descontinuado pela Microsoft" ....

A informação de que o Silverlight estaria morto acabou gerando em mim uma curiosidade sobre o fato. Então fui em busca de informações sobre o assunto, pois participei ao longo dos últimos tempos de diversos eventos oficiais da Microsoft onde muito se falou sobre esse produto, e pareceu-me incoerente descontinua-lo.

Pesquisei a Internet e realmente existe uma tendência de que funcionalidades existentes no Silverlight sejam incorporadas pelo HTML5 e isso é admitido pela propria Microsoft.

Porém está longe de dizer-se que ele esteja morto ... tanto que a Microsoft divulgou no seu site de carreiras, vagas para contratação de engenheiros para o Silverlight. Se o "cara" está morto? porque contratar novos engenheiros para manter e evoluir o "defunto"?

http://www.baboo.com.br/conteudo/modelos/Silverlight-no-Xbox_a40445_z345.aspx

Também parece-me estranho que o EcoDevelopers, um evento em parceria com a Comtec, Sebrae e Microsoft que acontece amanhã (24/11/2010), aqui em Goiânia,   tenha em sua agenda uma palestra falando sobre um produto que já teria sido descontinuado.  

http://www.ecodevelopers.net/Goiania/Agenda

A pouco mais de 15 dias alguns amigos meus fizeram prova para certificação Microsoft em Silverlight.

Estas são apenas algumas considerações que faço sobre o assunto, sem o interesse de radicalizar ou trazer polêmica, nem mesmo iniciar uma infrutífera discução sobre o tema, afinal de contas, o tempo é quem vai responder a esta questão .... morreu ou não morreu? 

A Microsoft realizará um evento sobre o Silverlight no próximo dia 3 de dezembro. Nele a empresa deverá detalhar seus futuros planos para a tecnologia.

Como desenvolvedor Delphi, a muito ouço dizer que o Delphi é uma linguagem morta, e o tempo tem mostrado que a história não é bem essa !.

Abraços, e até o proximo post. 

Interface Gráfica do GIT

Olá amigos ... 

Aqueles que me acompanham sabem que sou fã incodicional do GIT e o considero como um dos melhores softwares de SCM (source code management) da atualidade. Entretanto alguns amigos sempre reclamavam de usa-lo via linha de comando ( particularmente eu gosto. Linha de comando te dá segurança e controle total da situação). 

Para esses meu amigos, vai a dica deste post: usar o comando git gui : O gui vem de graphics user interface ou seja interface gráfica com o usuário. Nesta interface você pode realizar o add + commits + push + um montão de comandos do git, tudo de forma gráfica. Eu mesmo uso bastante esse recurso. 

Quando se abre a tela no canto superior direito aparece o quadro chamado de Unstaged changes onde são mostrados os itens do repositorio que foram alterados/criados e que ainda não foram adicionados ao indice do git. Para adiciona-los ao indice basta clicar no ícone do item, o que equivale a linha de comando "git add nome_do_arquivo".  

Logo abaixo temos o quadro de Staged changes (will commit) . nesse quadro aparecem os itens que foram adicionados ao indice, porém ainda não foram commitados. Para retornar um item desse quadro para o quadro Unstaged Changes, apenas clique no seu ícone. 

Digite o texto do seu commit no quadro Commit Message e clique no botão Commit. Pronto isso equivale à linha de comando "git commit -m "mensagem do commit" " . 

Em seguida se quiser "empurrar" suas alterações para o servidor, basta clicar no botão push .

Além disso você poderá selecionar um arquivo e reverter as mudanças, deletar aquivos, gerenciar branches e muito mais através dessa ferramenta nativa do git. 

Se você ficou curioso, dê uma olhada nos menus desta ferramenta e veja as inúmeras possibilidades que ela oferece. 

No meu proximo post vou falar de outra ferramenta gráfica para trabalhar com o git ... a versão do Tortoise para o GIT ... 

Um grande abraço e até o próximo post. 

Você conhece Objective-C

Um post do Adriano Santos no seu blog Delphi To Delphi  chamou minha atenção, sobre uma fatia do mercado que percebo como pouco explorada atualmente no Brasil, os aplicativos para iPhone, iPad e iPod.

Procurando um pouco mais de informação sobre o assunto, deparei-me com a linguagem Objective-C, que para quem não sabe é a linguagem usada para criação de aplicações para os sistemas da Apple.

Um pouco de história 

O ObjC foi criado principalmente por Brad Cox e Tom Love no início da década de 1980 na empresa deles, a Stepstone. A principal descrição do Objective-C em sua forma original foi publicada no livro de Cox, Object-Oriented Programming, An Evolutionary Approach, de 1986.

Em 1988, a NeXT de Steve Jobs licenciou o Objective-C da StepStone (a dona da marca registrada Objective-C) e liberou sua própria versão do compilador e das bibliotecas da linguagem nas quais a interface do usuário e da estrutura NeXTstep eram baseadas. O sucesso das ferramentas e a qualidade do sistema operacional resultante ajudaram a NeXT a ocupar um nicho de provedor de workstations bastante popular.

O projeto GNU começou a trabalhar em seu clone livre do NeXTStep baseado no padrão OpenStep, o GNUstep. Dennis Glatting escreveu o primeiro runtime do gnu-objc em 1992, e Richard Stallman criou o segundo pouco depois. O runtime do GNU Objective-C que tem estado em uso desde 1993 é aquele desenvolvido por Kresten Krab Thorup, quando ele era estudante universitário na Dinamarca. Kresten também trabalhou para a NeXT por algum tempo.

Depois de adquirir a NeXT em 1996, a Apple usou o OPENSTEP como base para seu principal sistema operativo, o Mac OS X. Isto inclui o Objective-C e a ferramenta de desenvolvimento NeXT's Objective-C, o Project Builder (mais tarde substituído pelo Xcode), bem como sua ferramenta de projeto de interface, Interface Builder.

A maior parte da presente API Cocoa da Apple está baseada na interface de objetos OpenStep, e este é o mais significativo ambiente Objective-C sendo usado para desenvolvimento ativo.

O Objective-C é uma camada construída sobre a linguagem C e constitui-se num superconjunto estrito de C. Ou seja, é possível compilar qualquer programa C com um compilador Objective-C. O Objective-C deriva sua sintaxe tanto do C quanto do Smalltalk. A maior parte de sua sintaxe (incluindo pré-processamento, expressões, declaração e chamadas de funções) foi herdade do C, enquanto a sintaxe para os aspectos orientados a objetos foi criada para habilitar passagem de mensagens no estilo Smalltalk.

Ambiente de programação

Para programar em Objective-C, tal como em qualquer outra linguagem moderna, você precisa de um editor e um compilador. Ambos estão disponíveis gratuitamente em muitos dos sistemas operacionais atuais.

No MacOS X, você deve instalar os "Developer Tools" gratuitos da Apple, caso eles não estejam presentes no seu sistema. Essas ferramentas incluem dentre muitas outras coisas o compilador gcc e um ambiente de programação extremamente eficiente, denominado Xcode.

No Linux você já deve ter o gcc instalado, bem como muitos editores de texto (vi, pico, emacs). Você tambem pode utilizar algum ambiente de programação, como o KDevelop ou ferramentas GNUStep.

No Windows você pode instalar o compilador Objective-C que acompanha o sistema MinGW (http://www.mingw.org). Para escrever os códigos, qualquer editor de texto puro, como o Notepad, ou algum ambiente de programação devem servir.

Nos três sistemas, compilar um programa utilizando a linha de comando resume-se ao gcc (para projetos maiores costuma-se utilizar ferramentas como make, automake, etc), cujo formato geral de chamada é:

Portanto, chegamos a conclusão que por ser uma linguagem derivada do C, quem já possui algum conhecimento sobre esta linguagem larga na frente. 

Com o crescimento das vendas dos equipamentos da Apple no mercado brasileiro, creio que seja uma possibilidade a ser observada com carinho. 

Um agrande abraço e sucesso ao Adriano Santos o mais novo licenciado como desenvolvedor Apple®.

Fontes utilizadas neste post: 

http://pt.wikipedia.org/wiki/Objective-C

http://www.astro.iag.usp.br/~algol/computacao/ObjCtutorial.html

Número por Extenso

Diante da necessidade de gerar valores por extenso, pesquisando na web, deparei-me com a excelente procedure abaixo, para Firebird. 

Ela não usa UDF´s e consegue gerar extenso para valores de até 8 (oito) quatrilhões.

Ela pode ignorar a geração do extenso dos centavos, para o caso de um extenso para cheques (basta atribuir 'N' ao segundo parâmetro).
 
Parabéns ao Emersom, o autor dessa "belezura" !!!

CREATE PROCEDURE EXTENSO (
    valor numeric(18,2),
    cents char(1))
returns (
    valorextenso varchar(250))
as
declare variable cmoeda varchar(10);
declare variable cmoedas varchar(10);
declare variable ccentavo varchar(10);
declare variable ccentavos varchar(10);
declare variable cmil varchar(12);
declare variable cmils varchar(12);
declare variable cmilhao varchar(12);
declare variable cmilhoes varchar(12);
declare variable cbilhao varchar(12);
declare variable cbilhoes varchar(12);
declare variable ctrilhao varchar(12);
declare variable ctrilhoes varchar(12);
declare variable cquatrilhao varchar(12);
declare variable cquatrilhoes varchar(12);
declare variable cvalor varchar(100);
declare variable nvalor smallint;
declare variable cvalorint varchar(100);
declare variable nvalorint integer;
declare variable nvalordec  numeric(6,3);
declare variable i smallint;
declare variable nconj integer;
declare variable cletra varchar(1);
declare variable caux varchar(200);
declare variable extensocentavos varchar(100);
declare variable separador varchar(3);
declare variable extensoconj varchar(150);
declare variable cdig1 varchar(10);
declare variable cdig2 varchar(10);
declare variable cdig3 varchar(10);
declare variable centenas char(108) = 'CENTO       DUZENTOS    TREZENTOS   QUATROCENTOSQUINHENTOS  SEISCENTOS  SETECENTOS  OITOCENTOS  NOVECENTOS  ';
declare variable dezenas char(79) = 'DEZ      VINTE    TRINTA   QUARENTA CINQUENTASESSENTA SETENTA  OITENTA  NOVENTA  ';
declare variable unidades char(54) = 'UM    DOIS  TRES  QUATROCINCO SEIS  SETE  OITO  NOVE  ';
declare variable unid10 char(81) = 'ONZE     DOZE     TREZE    QUATORZE QUINZE   DEZESSEISDEZESSETEDEZOITO  DEZENOVE ';
declare variable extensounidade varchar(12);
declare variable extensodezena varchar(12);
declare variable extensocentena varchar(12);
declare variable vlrextenso varchar(250);
begin
  if (cents is null) then cents = 'S';
  cents = UPPER(cents);
 
  -- poderia ter deixado esses valores fixos,
  -- mas preferi em variáveis
  cMil = 'MIL'; cMils = 'MIL';
  cMilhao = 'MILHÃO'; cMilhoes = 'MILHÕES';
  cBilhao = 'BILHÃO'; cBilhoes = 'BILHÕES';
  cTrilhao = 'TRILHÃO'; cTrilhoes = 'TRILHÕES';
  cQuatrilhao = 'QUATRILHÃO'; cQuatrilhoes = 'QUATRILHÕES';
  cMoeda = 'REAL'; cMoedas = 'REAIS';
  cCentavo = 'CENTAVO'; cCentavos = 'CENTAVOS';
  Separador = ' ';
 
  -- valores a serem utilizados para geração do extenso
  nValorInt = cast(valor/100*100 as integer);
  nValorDec = (Valor - Cast(nValorInt as numeric(18,3))) / 10;
  cAux = Cast(nValorDec as varchar(100));

  cValorInt = Cast(nValorInt as varchar(100)) || Substring(cAux from 3 for 3);
 
  -- inverto o número. assim fica mais fácil trabalhar
  -- pois não haverá necessidade de UDF's
  cLetra = Substring(cValorInt from 1 for 1);
  cAux = cValorInt;
  cValorInt = '';
  while (cAux <> '') do
  begin
    cValorInt = (cLetra || cValorInt);
    cAux = Substring(cAux from 2 for 100);
    cLetra = Substring(cAux from 1 for 1);
    if (cLetra = '') then cLetra = ' ';
  end
 
  -- obtenho os subconjuntos de números, de 3 em 3,
  -- para formar o extenso, que poderá chegar aos quatrilhões
  nConj = 1;
  extensocentavos = '';
  vlrextenso = '';
 
  if (Valor <> 0) then
  begin
    while (cValorInt <> '') do
    begin
      cValor = '';
      i = 1;
      while (i <= 3) do
      begin
        cLetra = Substring(cValorInt from 1 for 1);
        if (cLetra = '') then cLetra = ' ';
        cValor = (cLetra || cValor);
        cValorInt = Substring(cValorInt from 2 for 100);
        i = (i + 1);
      end
 
      nValor = Cast(cValor as smallint);
 
      cDig1 = Substring(cValor from 1 for 1);
      cDig2 = Substring(cValor from 2 for 1);
      cDig3 = Substring(cValor from 3 for 1);
 
      extensounidade = '';
      extensodezena = '';
      extensocentena = '';
 
      -- obtenho o extenso da unidade
      if (cDig3 > '0') then
      begin
        cAux = cast((cast(cDig3 as integer) * 6 - 5) as varchar(3));
        cAux = 'select cast(Substring(''' || unidades || ''' from ' || cAux || ' for 6) as varchar(12)) from rdb$database';
        execute statement cAux into :extensounidade;
      end
 
      -- obtenho o extenso da dezena
      if (cDig2 > '0') then
      begin
        if ((cDig3 > '0') and (cDig2 = '1')) then
        begin
          extensounidade = '';
          cAux = unid10 || ''' from ' || cast((cast(cDig3 as integer) * 9 - 8) as varchar(3));
        end
        else
          cAux = dezenas || ''' from ' || cast((cast(cDig2 as integer) * 9 - 8) as varchar(3));
        cAux = 'select cast(Substring(''' || cAux || ' for 9) as varchar(12)) from rdb$database';
        execute statement cAux into :extensodezena;
      end
 
      -- obtenho o extenso da centena
      if (cDig1 > '0') then
      begin
        if (nValor = 100) then
          extensocentena = 'CEM';
        else
        begin
          cAux = cast((cast(cDig1 as integer) * 12 - 11) as varchar(3));
          cAux = 'select cast(Substring(''' || centenas || ''' from ' || cAux || ' for 12) as varchar(12)) from rdb$database';
          execute statement cAux into :extensocentena;
        end
      end
 
      -- faço a montagem do extenso do conjunto
      if (extensounidade <> '') then
        extensoconj = extensounidade;
      else
        extensoconj = '';
 
      if (extensodezena <> '') then
      begin
        if (extensoconj <> '') then
          extensoconj = extensodezena || ' E ' || extensoconj;
        else
          extensoconj = extensodezena;
      end
 
      if (extensocentena <> '') then
      begin
        if (extensoconj <> '') then
          extensoconj = extensocentena || ' E ' || extensoconj;
        else
          extensoconj = extensocentena;
      end
 
      -- adiciono os devidos sufixos de cada conjunto
      if (nValor > 0) then
      begin
        if (nConj = 1) then -- centavos
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' ||ccentavos;
          else
            extensoconj = extensoconj || ' ' || ccentavo;
        end
 
        -- obs.: o conjunto 2 não precisa ser avaliado, pois
        --       nele NÃO há necessidade de acrescentar sufixo
 
        if (nConj = 3) then -- milhares
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cMils;
          else
            extensoconj = extensoconj || ' ' || cMil;
        end
        else
        if (nConj = 4) then -- milhoes
        begin
        if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cMilhoes;
          else
            extensoconj = extensoconj || ' ' || cMilhao;
        end
        else
        if (nConj = 5) then -- bilhoes
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cBilhoes;
          else
            extensoconj = extensoconj || ' ' || cBilhao;
        end
        else
        if (nConj = 6) then -- trilhoes
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cTrilhoes;
          else
            extensoconj = extensoconj || ' ' || cTrilhao;
        end
        else
        if (nConj = 7) then -- quatrilhoes
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cQuatrilhoes;
          else
            extensoconj = extensoconj || ' ' || cQuatrilhao;
        end
 
        if ((vlrextenso = '') and (nConj > 3)) then
          extensoconj = extensoconj || ' DE ';
      end
 
      -- avalio qual será o separador de conjuntos
      if (nConj < 4) then
        Separador = ' E ';
      else
        Separador = ', ';
 
      -- gero o extenso dos 'inteiros' e dos centavos
      if (nConj = 1) then -- centavos
        extensocentavos = extensoconj;
      else
      if (extensoconj <> '') then
      begin
        if (vlrextenso <> '') then
          vlrextenso = extensoconj || Separador || vlrextenso;
        else
          vlrextenso = extensoconj;
      end
 
      nConj = nConj + 1;
    end
 
    -- depois de tudo avaliado...
    -- acrescento a moeda
    if (nvalorint > 0) then
    begin
      if (nvalorint > 1) then
        vlrextenso = vlrextenso || ' ' || cmoedas;
      else
        vlrextenso = vlrextenso || ' ' || cmoeda;
    end
 
    -- monto o extenso completo: inteiros mais os centavos.
    -- obs.: a inclusão dos centavos é controlada pela variável
    -- 'cents'. fiz assim pois pode ser uma geração de extenso
    -- para cheques, que não destacam os centavos no extenso
    if ((extensocentavos <> '') and (cents = 'S')) then
    begin
      if (vlrextenso <> '') then
        vlrextenso = vlrextenso || ' E ' || extensocentavos;
      else
        vlrextenso = extensocentavos;
    end
  
    -- limpo a variavel de retorno, pois ainda preciso trabalhar os 'espaços'
    valorextenso = '';
 
    -- retiro os espacos desnecessários e populo a variável de retorno.
    -- obs.: fiz com while pra não precisar de UDF's
    cLetra = Substring(vlrextenso from 1 for 1);
    cAux = '';
    while (vlrextenso <> '') do
    begin
      cLetra = Substring(vlrextenso from 1 for 1);
      vlrextenso = Substring(vlrextenso from 2 for 250);
      if ((cLetra <> ' ') or ((cLetra = ' ') and (cAux <> ' ')))  then
        valorextenso = valorextenso || cLetra;
      cAux = cLetra;
    end
  end
  else
    valorextenso = 'ZERO';
 
  -- exibe o resultado
  suspend;
end

-----

Veja o Post Original em http://www.firebase.com.br/fb/artigo.php?id=2078

Firebird - Comandos SQL úteis - Substring, Cast, Case, Like

Olá amigos esse post abaixo é um copy / paste que fiz do endereço no final do post .... quero agradecer ao Thunder Boy pelas dicas ... não deixem de dar uma passada lá no blog dele e conferir. 

Problema: Como mostrar apenas parte dos dados de um coluna em um relatório?

=============================
SUBSTRING
=============================
Conheça o  “substring”, mas como ele funciona? 

A sintaxie é a seguinte: select substring (”nome do campo” from “coluna_inicial” for “caracteres”) from “nome da tabela”

Exemplo: A máscara de estoque é de 8 digitos, porém quero que na SQL mostre apenas os 3 últimos dígitos

select substring (codpa from 6 for 3) as Referencia from etprocab where codemp=1

Nota: Este comando é muito útil e pode ser usado inclusive para acerto de base, quando é necessário diminuir o tamanho de alguma configuração, para isto basta combiná-lo com update

=============================
CAST
=============================

Porém a coluna irá ser mostrada grande, devido ao tamanho que foi criada, ai neste caso basta usar o “cast” para reduzir o tamanho da coluna na consulta

Exemplo:

select cast(substring (codpa from 6 for 3) as varchar (3)) as Ref from etprocab
where codemp=1

Nota: Este comando é útil, para ser usado no gerrel, pois neste caso iria mostrar a coluna grande no excel e após usar o “cast” o tamanho da coluna fica limitada ao tamanho informado no comando

=============================
LIKE
=============================

Outro comando bacana é o like, que acredito que não seja novidade pra ninguém, porém mesmo assim vai a dica:

select * from dtclifor
where insestrg like ‘%NTO’ /* Neste caso o percentual antes da palavra substitui as letras que o antecede */
and insestrg like ‘ISE%’ /* Neste caso o percentual depois da palavra substitui as letras da sequencia */
and insestrg like ‘%EN%’ /* E entre percentuais ira retornar todos valores que contenham a consulta em qualquer parte do campo */

Mais se quiser consultar todos os registros que variam apenas um caracter, como faço?

Basta utilizar o “_” (underline) no lugar do percentual, pois neste caso ele irá considerar a variação de apenas uma casa decimal na consulta.

Exemplo:

select * from dtclifor
where codclifor like ‘10000_1′

=============================
CASE
=============================

E vai a dica do comando case, onde com ele é possivel mostrar dados que seriam mostrados por linha, nas colunas

Exemplo:

select
sum ( case when vendedor = 1 then pretot else 0 end ) as Vendedor_1,
sum ( case when vendedor = 2 then pretot else 0 end ) as Vendedor_2,
sum ( case when vendedor = 3 then pretot else 0 end ) as Vendedor_3,
sum ( case when vendedor = 4 then pretot else 0 end ) as Vendedor_4
from vtvencor
where tipo in (’VBA’, ‘VBT’, ‘VCO’)
and situacao=1
and codemp=1

Nota: Este é um exemplo simples de como usar o comando case, onde mostra o valor vendido com base na tabela vtvencor, porém não é considerado os descontos e acréscimos do cadastro da venda e mostra os valores independente da venda cadastrada ou não. É apenas para demonstrar o uso do case.

=============================
COMENTÁRIO EM COMANDOS
=============================

Outra dica útil é poder colocar comentários em comandos para isso basta entre os comentários colocar as tags “/*” para iniciar e “*/” para finalizar, com isso ao executar o comando, não será considerado o que estiver entre as tags

Exemplo:

select * from dtclifor
where codemp=1 /* Comentário qualquer de sua preferencia… */

Este post foi Copiado deste link http://infoblogs.com.br/frame/goframe.action?contentId=41528

Compilar em apenas um passo

Na serie de arigos sobre o teste do Joel estou escrevendo sobre os pontos que devem ser levados em consideração para a melhor o processo de produção de software.

A segunda  pergunta do teste do Joel é saber se você pode compilar todo o projeto em apenas um passo. Essa é uma questão essencial e um desafio para muitas equipes. Em muitos casos perdem-se horas sagradas para gerar um novo Release.

Boas equipes possuem um único script que faz um checkout completo do zero, reconstrói cada linha de código, faz os EXE's, em todas as suas várias versões, linguagens e combinações de #ifdef, cria o pacote de instalação e cria a mídia final -- layout do CDROM, download do website, o que seja.

Se este processo possui mais de uma etapa, ele tende a ter erros. E quanto mais perto você chega da data de entrega, mais você quer ter um ciclo realmente rápido para corrigir o "último" bug, fazer os EXE's finais, etc. Se você leva 20 etapas para compilar o código, executar o construtor de instalação, etc, você vai enlouquecer e cometerá erros bobos.

Para automatizar o processo de compilação existem diversas ferramentas mas duas premissas sempre se mantêm independente da ferramenta escolhida :

• Deve ser possível compilar o projeto inteiro em um passo
• Deve ser possível usar qualquer máquina de desenvolvimento para isso

Citando algumas ferramentas:

Cruise Control  - ferramenta que automatiza o processo de build, provendo várias tarefas que facilitam o controle sobre o código, incluindo uma interface para visualizar os detalhes sobre cada build

Visual Build Professional -   ferramenta que possui suporte para o Microsoft Visual Studio .NET/2005, Visual Studio Team System, Visual Basic, Visual C++, SourceSafe, eMbedded Tools, Borland Developer Studio, Delphi, JBuilder, C++Builder, ClearCase.  Para sistemas de builds pequenos/medios ele é excelente. Já para builds de grande porte, pode não ser uma boa já que ele não permite o que, em alguns casos, dificulta o reaproveitamento dos scripts.

Além das ferramentas acima ainda merecem ser lembradas o Quick Build e o Luntbuild

Finalizando ...

Seja qual for a sua ferramenta preferida, o que realmente importa é que o processo seja o mais automatizado possivel, para assim diminuir as possibilidades de erros, como também agilizar o processo de deploy de novas versões do sistema.

Para quem desejar saber mais sobre o assunto seguem alguns links que entre outros serviram de base para este post

http://josepaulopapo.blogspot.com/2006/02/integrao-contnua-e-gesto-de-builds-com.html

http://www.caloni.com.br/blog/archives/como-compilar-em-somente-um-passo

http://brazil.joelonsoftware.com/Articles/TheJoelTest.html

O Planning Poker

Antes de mais nada o conceito

O Planning Poker é uma técnica de estimativa baseada no consenso de toda a equipe, onde é utilizado um conjunto de cartas com valores específicos que podem representar pontos relativos ou até mesmo horas (esses valores podem seguir a seqüência de fibonacci) e é praticado como se fosse um jogo. Uma pessoa apresenta a tarefa ou estória para o time, e, após uma breve discussão, cada um escolhe uma carta e coloca virada para baixo sobre uma mesa. Quando todas as cartas estiverem lançadas, elas são viradas e caso não haja consenso nos valores escolhidos, as diferenças são discutidas de forma breve, e uma nova rodada acontece até que haja a convergência.

Porque usar o Planning Poker?

Quem trabalha com desenvolvimento de software sabe que um dos nossos maiores desafios é conseguir mensurar o tamanho de cada tarefa com uma boa precisão, e, conseqüentemente, conseguir prever quando determinado recurso deverá ser concluído. A forma como fazemos nossas estimativas tem um grande impacto na confiabilidade de nossos prazos, porém, nem sempre as equipes tomam consciência desse fato, e continuam dando pouco valor ou dedicando menos esforço do que deveriam a essa atividade.

Seja qual for a metodologia de trabalho que sua equipe utiliza (scrum + XP ou outra mais tradicional) você pode utilizar diversas técnicas de estimativas. 

Algumas vantagens do Planning Poker:

· Equipe mais comprometida, pois todos participam;

· Força a equipe a ter um conhecimento de negócio mais homogêneo;

· Aumenta bastante a precisão das estimativas, pois considera a experiência de todos;

· Mais atraente (divertida) que as demais técnicas.

Se seu time está tentando implementar o scrum, algumas considerações:

· Estórias são funcionalidades, na forma como tem valor para o cliente (no scrum, o PO ou Product Owner). Exemplo: Eu como usuário quero poder cadastrar um produto;

· Tarefas são as implementações que devem ser feitas para que a funcionalidade seja entregue. Uma estória pode possuir uma ou mais tarefas;

· Nós só conseguimos estimar com precisão as tarefas pequenas. Se estiver estimando em horas, um valor maior que oito já é considerado um ‘chute’, e geralmente significa que aquela tarefa deve ser particionada em pelo menos duas partes, e reestimada, portanto, é recomendável assumir que cada tarefa deve ser pequena o suficiente para poder ser executada em um dia;

· Nem todas as estórias precisam ser detalhadas durante as estimativas. Se você trabalha com scrum, durante o backlog estimate (reunião, geralmente semanal, onde estimamos apenas as estórias de usuário) todas as estórias são reestimadas, e as estórias grandes são quebradas de acordo com a priorização do Product Owner. Dessa forma, as estórias com prioridade mais baixas podem ser estimadas com valores mais altos, e seu detalhamento pode ser postergado para quando se tornarem mais próximas de serem selecionadas para o sprint;

· Estimativas por horas devem ser feitas sem considerar as interrupções, ou seja, o tempo que efetivamente levaríamos para concluir a tarefa em um dia ideal;

· Estimativas por pontos é uma técnica muito boa para se estimar as estórias de usuário e não as tarefas, que usamos estimativas por horas em dias ideais (veja mais sobre estimativas por pontos aqui).

Existe um site bem interessante onde é possível jogar online o Planning Poker com sua equipe: planningpoker.com. Mas note que o poker real, com cartas de papel, é mais recomendável e geralmente mais ágil. Existem vários sites que fornecem as cartas para impressão, como: sprintplanning.com (para mais, deem uma olhada nas referências da Wikipedia).

Aqui tem uma explicação bem legal sobre como funciona a dinâmica do jogo:www.crisp.se/planningpoker

Links que serviram de base para este post 

http://www.brasiltech.net/agilez/2009/12/13/mais-agilidade-em-suas-estimativas-com-o-planning-poker/

Instalando o Git com o Cygwin

Ola amigos, 


Dando seqüencia nos posts sobre Controle de Código (SCM) hoje vou mostrar como instalar o Git com o Cygwin. 

Pra começar, o  que é Cygwin?

Cygwin é uma coleção de ferramentas de software livre originalmente desenvolvidas por Cygnus Solutions de maneira a permitir que várias versões do Microsoft Windows possam, de certa forma, agir como um sistema Unix. Sua principal intenção é portar softwares que rodam em sistemas POSIX (como sistemas Linux, sistemas BSD, e sistemas Unix) para que rodem em Windows com pouco mais do que uma recompilação. Programas portados com Cygwin funcionam melhor em Windows NT, Windows 2000, Windows XP, e Windows Server 2003, mas alguns podem rodar aceitavelmente bem em Windows 95 e Windows 98. O Cygwin é atualmente mantido por funcionários da Red Hat e outras pessoas.


Então vamos às instruções 


a) Baixe o instalador do Cygwin. (aqui)
b) Execute o programa setup.exec) Na primeira tela, clique em Avançar 
d) Selecione "Install from Internet" e clique em Avançar
e) Deixe o root directory como "C:\Cygwin" e clique em Avançar
f) Informe o local package directory como "C:\Cygwin\packages" e clique em Avançar
g) Marque "Direct Connection" e clique em Avançar
h)Após o programa baixar alguns arquivos, selecione o site ftp://mirrors.kernel.org na lista de Available Download Sites e clique em Avançar
i) Após o programa baixar mais alguns arquivos, clique no botão 'View', de forma que passe de 'Category' para 'Full'. Será necessário instalar os seguintes pacotes:


   - git
   - git-completion
   - git-gui
   - gitk
   - openssh
   - subversion
   - subversion-perl
   - subversion-python
   - subversion-ruby


j) Para instalar, clique em cima de 'Skip', de forma que apareça a versão do pacote que vai ser instalada. Após selecionar todos os pacotes acima, clique em Avançar.
k) Se aparecer alguma tela falando sobre instalação de dependências dos pacotes selecionados, clique em Avançar.


O programa vai baixar os pacotes selecionados e após isso ira aparecer uma tela perguntando sobre criação de ícones. Proceda da forma que lhe for mais conveniente e clique em Concluir.


Para testar, acesse o cygwin pelo atalho criado, se tiver algum, ou diretamente via c:\cygwin\cygwin.bat. 


Sendo apenas mais uma janela no ambiente, você continua usando seu Windows normalmente, e com um simples Alt+TAB, terá toda a flexibilidade e poder dos comandos do Linux, como bash, ls, grep, find, awk e amigos.É possível rodar o WindowMaker, KDE ou Gnome, dentro de uma janela do Windows! 


No nosso caso, especificamente, será possivel acessar todas a funcionalidades do Git 

Alguns Links para saber mais sobre o Cygwin 

http://pt.wikipedia.org/wiki/Cygwin

http://aurelio.net/cygwin/

http://forcehacker.kit.net/tutorial/cygwin.html

Aproveito também para lembrar que estou prestando consultoria e treinamento para implantação do Git.  


Abraço e até o proximo post. 

Controle de Código - Introdução ao GIT

Olá amigos ...

Dando seqüência aos posts sobre SCM (do inglês source code management) ou em bom português Sistema de Gerenciamento de Código, nosso assunto hoje será uma introdução ao GIT

Se esta á a sua primeira vez por aqui, recomendo a leitura dos seguintes posts antes de continuar

O Teste do Joel: 12 Passos para um Código Melhor

O Básico sobre Controle de Código

Sistema de controle de versão (wikipedia) 


Feito isso então vamos falar do GIT

O Git é um software para controle de versão distribuído, liberado sob a licença GPL (Software Livre), inicialmente criado por Linus Torvalds para o desenvolvimento do Kernel do Linux. O atual responsável pela manutenção do projeto Git é Junio Hamano.

O objetivo do Git é atender requisitos como desenvolvimento distribuído, manipulação de grandes conjuntos de arquivos, operações de junção (merge) complexas, rapidez, etc.

Cada diretório de trabalho Git é um repositório com todos os históricos e habilidade total de controle das revisões, não dependente de acesso a uma rede ou a um servidor central.

Vários projetos de software usam Git para controle de versão, exemplos notáveis como Kernel Linux, Servidor X.org, Qt (toolkit), Um laptop por criança (OLPC) e a ferramenta de trabalho web Ruby on Rails são alguns exemplos.

O design do Git foi inspirado por dois outros sistemas de versionamento: BitKeeper e Monotone.

Para aprofundar no assunto, recomendo aos interessados visitarem os seguintes links.

Porque Git é melhor que X
GitSvnComparsion em Inglês 

Aproveito também para avisar que estou prestando consultoria e treinamento para implintação do Git. 


Abraço e até o proximo post. 

O Básico sobre Controle de Código

Muitos problemas de desenvolvimento de software são causados por falta de controle de versão. Faça uma avaliação rápida da situação da sua equipe de desenvolvimento:

1. Alguém já sobrescreveu o código de outra pessoa por acidente e acabou perdendo as alterações?
2. Tem dificuldades em saber quais as alterações efetuadas em um programa, quando foram feitas e quem fez?
3. Tem dificuldade em recuperar o código de uma versão anterior que está em produção?
4. Tem problemas em manter variações do sistema ao mesmo tempo?

Se alguma das perguntas acima teve um sim como resposta, então sua equipe necessita urgentemente de um sistema para controle de versão!

Um sistema de controle de versão (ou versionamento), VCS (do inglês version control system) ou ainda SCM (do inglês source code management) na função prática da Ciência da Computação e da Engenharia de Software, é um software com a finalidade de gerenciar diferentes versões no desenvolvimento de um documento qualquer. Esses sistemas são comumente utilizados no desenvolvimento de software para controlar as diferentes versões – histórico e desenvolvimento – dos códigos-fontes e também da documentação.

Esse tipo de sistema é muito presente em empresas e instituições de tecnologia e desenvolvimento de software. É também muito comum no desenvolvimento de software livre. É útil, em diversos aspectos, tanto para projetos pessoais pequenos e simples como também para grandes projetos comerciais.

Principais vantagens

As principais vantagens de se utilizar um sistema de controle de versão para rastrear as alterações feitas durante o desenvolvimento de software ou o desenvolvimento de um documento de texto qualquer são:

Controle do histórico: facilidade em desfazer e possibilidade de analisar o histórico do desenvolvimento, como também facilidade no resgate de versões mais antigas e estáveis. A maioria das implementações permitem analisar as alterações com detalhes, desde a primeira versão até a última.

Trabalho em equipe: um sistema de controle de versão permite que diversas pessoas trabalhem sobre o mesmo conjunto de documentos ao mesmo tempo e minimiza o desgaste provocado por problemas com conflitos de edições. É possível que a implementação também tenha um controle sofisticado de acesso para cada usuário ou grupo de usuários.

Marcação e resgate de versões estáveis: a maioria dos sistemas permite marcar onde é que o documento estava com uma versão estável, podendo ser facilmente resgatado no futuro.

Ramificação de projeto: a maioria das implementações possibilita a divisão do projeto em várias linhas de desenvolvimento, que podem ser trabalhadas paralelamente, sem que uma interfira na outra.

Não existe nada mais frustrante do que não ter exatamente o código-fonte da versão que está rodando no cliente ou não saber o que mudou desde que a versão foi entregue. Esse tipo de coisa pode acabar com uma empresa ou fazer com que ela fique muito mal vista no mercado.

Porém, independente do mercado, existe um bom motivo para o desenvolvedor possuir algum tipo de controle de código: controle. Se você ou sua equipe não conseguem corrigir todos os bugs, pelo menos saberão o que já foi feito. Se você achou um bug que não existia antes da versão 10, o histórico das mudanças entre a versão estável 9 e a versão não-tão-estável 10 vai te dar uma pista muito boa de onde o problema pode ter sido gerado. Visto dessa forma, não importa muito o tamanho da equipe ou da organização. O importante de um bom código é que suas mudanças estejam sempre registradas, visíveis e disponíveis a qualquer um.

Opções para Controle de Código

Um controle de código para uma pessoa só não precisa ser nada muito sofisticado, sendo que um amontoado de ZIPs pode dar conta do recado. Porém, a partir do momento em que o número de desenvolvedores aumenta para dois ou mais, aí o controle baseado em ZIPs começa a ruir, e é necessário usar uma ferramenta mais apropriada. Existem algumas opções, que vai do gosto e necessidades de cada um:

Visual Source Safe ou VSS: não é gratuito nem robusto o suficiente para agüentar toneladas de código-fonte, mas vem junto do Visual Studio e pode ser apropriado para empresas de porte pequeno ou médio (e empresas de um programador só).

Concurrent Version System ou CVS: é um sistema fonte aberto, gratuito e robusto. Suficiente para agüentar toneladas de código-fonte e equipes de vários andares. Atualmente está sendo substituído gradualmente pelo

Subversion ou SVN: é um substituto moderno do antigo CVS; igualmente gratuito e poderoso, está rapidamente se tornando a opção predominante.

Git: é um sistema de controle de revisão distribuida, rápido e escalável. O Git foi desenvolvido inicialmente por Linus Torvalds mediante uma necessidade de ter um software robusto para controle de versão do kernel linux. O Git, diferente do subversion, por exemplo, não é um repositório de dados centralizado. Assim, cada pessoa que trabalha no mesmo projeto terá uma cópia completa do repositório, portanto, as operções comuns de um repositório de dados são feitas localmente. Isso dá a liberdade total para o usuário trabalhar com o repositório como quiser, criando branches, fazendo merges, etc... Ao final do processo, ele pode enviar um branch mais bem trabalhado e testado ao repositório remoto.

Para aqueles que queiram aprofundar no assunto recomendo a leitura dos artigos abaixo, que entre outros, serviram de base para este post.

http://pt.wikipedia.org/wiki/Sistema_de_controle_de_versão

http://www.pronus.eng.br/artigos_tutoriais/gerencia_configuracao/conceitos_basicos_controle_versao_centralizado_e_distribuido.php