High School/Jr.High

  10 PRINT "HELLO WORLD"
  20 END

First year in College

  program Hello(input, output)
    begin
      writeln('Hello World')
    end.

Senior year in College

  (defun hello
    (print
      (cons 'Hello (list 'World))))

New professional

  #include <stdio.h>
  void main(void)
  {
    char *message[] = {"Hello ", "World"};
    int i;
    for(i = 0; i < 2; ++i)
      printf("%s", message[i]);

    printf("\n");
  }

Seasoned professional

  #include <iostream.h>
  #include <string.h>
 
  class string
  {
  private:
    int size;
    char *ptr;
 
  string() : size(0), ptr(new char[1]) { ptr[0] = 0; }

    string(const string &s) : size(s.size)
    {
      ptr = new char[size + 1];
      strcpy(ptr, s.ptr);
    }
 
    ~string()
    {
      delete [] ptr;
    }
 
    friend ostream &operator <<(ostream &, const string &);

    string &operator=(const char *);
  };
 
  ostream &operator<<(ostream &stream, const string &s)
  {
    return(stream << s.ptr);
  }
 
  string &string::operator= (const char *chrs)

  {
    if (this != &chrs)
    {
      delete [] ptr;
     size = strlen(chrs) ;
      ptr = new char[size + 1];
      strcpy(ptr, chrs);
    }
    return(*this) ;
  }

  int main()

  {
    string str;
 
    str = "Hello World";
    cout << str << endl;
    return(0);
  }

Master Programmer

  [
  uuid(2573F8F4- CFEE-101A- 9A9F-00AA0034282 0)
  ]
  library LHello
  {
      // bring in the master library
      importlib("actimp.tlb");
      importlib("actexp.tlb");

      // bring in my interfaces
      #include "pshlo.idl"

      [
      uuid(2573F8F5- CFEE-101A- 9A9F-00AA0034282 0)
      ]
      cotype THello
   {
   interface IHello;
   interface IPersistFile;

   };
  };
  [
  exe,
  uuid(2573F890- CFEE-101A- 9A9F-00AA0034282 0)
  ]
  module CHelloLib
  {
      // some code related header files
      importheader(<windows.h>);
      importheader(<ole2.h>);

      importheader(<except.hxx>);
      importheader("pshlo.h");
      importheader("shlo.hxx");
      importheader("mycls.hxx");

      // needed typelibs
      importlib("actimp.tlb");

      importlib("actexp.tlb");
      importlib("thlo.tlb");

      [
      uuid(2573F891- CFEE-101A- 9A9F-00AA0034282 0),
      aggregatable
      ]
      coclass CHello
   {

   cotype THello;

   };
  };

  #include "ipfix.hxx"
  extern HANDLE hEvent;

  class CHello : public CHelloBase
  {
  public:
      IPFIX(CLSID_ CHello);
      CHello(IUnknown *pUnk);

      ~CHello();

      HRESULT  __stdcall PrintSz(LPWSTR pwszString);
 
  private:
      static int cObjRef;
  };

  #include <windows.h>
  #include <ole2.h>
  #include <stdio.h>

  #include <stdlib.h>
  #include "thlo.h"
  #include "pshlo.h"
  #include "shlo.hxx"
  #include "mycls.hxx"
  int CHello::cObjRef = 0;

  CHello::CHello( IUnknown *pUnk) : CHelloBase(pUnk)

  {
      cObjRef++;
      return;
  }
 
  HRESULT  __stdcall  CHello::PrintSz( LPWSTR pwszString)
  {
      printf("%ws
", pwszString);
      return(ResultFromSc ode(S_OK) );
  }

  CHello::~CHello( void)
  {
 
  // when the object count goes to zero, stop the server
  cObjRef--;
  if( cObjRef == 0 )
      PulseEvent(hEvent) ;

  return;
  }

  #include <windows.h>

  #include <ole2.h>
  #include "pshlo.h"
  #include "shlo.hxx"
  #include "mycls.hxx"

  HANDLE hEvent;

   int _cdecl main(
  int argc,
  char * argv[]

  ) {
  ULONG ulRef;
  DWORD dwRegistration;
  CHelloCF *pCF = new CHelloCF();

  hEvent = CreateEvent( NULL, FALSE, FALSE, NULL);
 
  // Initialize the OLE libraries
  CoInitializeEx( NULL, COINIT_MULTITHREADE D);

  CoRegisterClassObje ct(CLSID_ CHello, pCF, CLSCTX_LOCAL_ SERVER,
      REGCLS_MULTIPLEUSE, &dwRegistration) ;

  // wait on an event to stop
  WaitForSingleObject (hEvent, INFINITE);

  // revoke and release the class object

  CoRevokeClassObject (dwRegistration) ;
  ulRef = pCF->Release();
 
  // Tell OLE we are going away.
  CoUninitialize( );

  return(0); }

  extern CLSID CLSID_CHello;
  extern UUID LIBID_CHelloLib;

  CLSID CLSID_CHello = { /* 2573F891-CFEE- 101A-9A9F- 00AA00342820 */
      0x2573F891,
      0xCFEE,
      0x101A,
      { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
  };

  UUID LIBID_CHelloLib = { /* 2573F890-CFEE- 101A-9A9F- 00AA00342820 */

      0x2573F890,
      0xCFEE,
      0x101A,
      { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
  };
 
  #include <windows.h>
  #include <ole2.h>
  #include <stdlib.h>

  #include <string.h>

  #include <stdio.h>
  #include "pshlo.h"
  #include "shlo.hxx"
  #include "clsid.h"
  int _cdecl main(
  int argc,
  char * argv[]
  ) {
  HRESULT  hRslt;

  IHello        *pHello;
  ULONG  ulCnt;
  IMoniker * pmk;
  WCHAR  wcsT[_MAX_PATH] ;
  WCHAR  wcsPath[2 * _MAX_PATH];
 
  // get object path
  wcsPath[0] = '';
  wcsT[0] = '';

  if( argc > 1) {
      mbstowcs(wcsPath, argv[1], strlen(argv[ 1]) + 1);
      wcsupr(wcsPath) ;
      }
  else {
      fprintf(stderr, "Object path must be specified\n");
      return(1);

      }
 
  // get print string
  if(argc > 2)
      mbstowcs(wcsT, argv[2], strlen(argv[ 2]) + 1);
  else
      wcscpy(wcsT, L"Hello World");
 
  printf("Linking to object %ws\n", wcsPath);
  printf("Text String %ws\n", wcsT);

  // Initialize the OLE libraries
  hRslt = CoInitializeEx( NULL, COINIT_MULTITHREADE D);

  if(SUCCEEDED( hRslt)) {

      hRslt = CreateFileMoniker( wcsPath, &pmk);

      if(SUCCEEDED( hRslt))
   hRslt = BindMoniker( pmk, 0, IID_IHello, (void **)&pHello);
      if(SUCCEEDED( hRslt)) {
   // print a string out
   pHello->PrintSz(wcsT) ;

   Sleep(2000);

   ulCnt = pHello->Release();
   }
      else
   printf("Failure to connect, status: %lx", hRslt);

      // Tell OLE we are going away.
      CoUninitialize( );
      }
  return(0);

  }

Apprentice Hacker

  #!/usr/local/ bin/perl
  $msg="Hello, world.\n";
  if ($#ARGV >= 0) {
    while(defined( $arg=shift( @ARGV))) {
      $outfilename = $arg;
      open(FILE, ">" . $outfilename) || die "Can't write $arg: $!\n";

      print (FILE $msg);
      close(FILE) || die "Can't close $arg: $!\n";
    }
  } else {
    print ($msg);
  }
  1;

Experienced Hacker

  #include <stdio.h>
  #define S "Hello, World\n"
  main(){exit( printf(S) == strlen(S) ? 0 : 1);}

Seasoned Hacker

  % cc -o a.out ~/src/misc/hw/ hw.c
  % a.out

Guru Hacker

  % echo "Hello, world."

New Manager

  10 PRINT "HELLO WORLD"
  20 END

Middle Manager

  mail -s "Hello, world." bob@b12
  Bob, could you please write me a program that prints "Hello, world."?
  I need it by tomorrow.
  ^D

Senior Manager

  % zmail jim
  I need a "Hello, world." program by this afternoon.

Chief Executive

  % letter
  letter: Command not found.
  % mail
  To: ^X ^F ^C
  % help mail
  help: Command not found.
  % damn!
  !: Event unrecognized
  % logout

    A App Store funciona muito bem. Está tudo lá, a um clique de distância. Jogos, aplicativos de escritório, inutilidades… Comprar é muito fácil. Difícil é ter que se conformar com uma compra ruim. Eu, por exemplo, já gastei muitos dólares na compra de apps ruins ou pouco funcionais. Já xinguei os criadores do QuickOffice por muitas e muitas gerações (19,99 dólares jogados no lixo)…

    Por isso, a partir de hoje, publicaremos semanalmente (espero que sim.. rs) um review em vídeo sobre algum jogo ou aplicativo para o iPhone/iPod Touch. Nós compraremos e publicaremos o review de cada app para que você sempre saiba o que está comprando. Se precisar, nós xingaremos por você! :P Espero que essa seja uma experiência boa, pois é difícil encontrar sites brasileros que façam reviews de apps em vídeo e em bom português.

    Esta semana começaremos com o game Need for Speed Undercover. O que vocês acham? Quais jogos ou aplicativos merecem uma resenha? Contamos com o auxílio de vocês.

Separo ele em duas partes: a sala, local da família, aonde eu cuido dos assuntos mais chatos, trabalho com o IDA, utilizo programas que só funcionam no PC, e faço jailbreak. Lá, temos um computador montado de 2GB de RAM e 100 de HD, e uma tela de 17 polegadas, o notebook, com 1GB de ram e 150 de HD. Também temos um PS3, aonde eu tiro meu tempo de diversão.

A outra, é meu quarto, com meu Mac, com 200GB de HD, 2 de RAM (semana que vem teremos 4), que uso para programar em C++ e objective- C, editar o blog, vídeos, fotos e tudo mais. iPhone, aonde faço ligações, e mais uma tela de 22 polegadas HD da Saumsung, que acaba de chegar, e uso para ver filmes, e apresentações em slides, etc.

Dei uma puxada aqui, empurrada ali, para que caiba nas fotos, espero que tenham gostado!

A propósito, comprei uma expansão de 4GB para o Mac, que deve chegar na semana que vem. Alguém já fez o upgrade nos novos Macs (unibody) e sabe se é tranquilo, ou costuma dar muitos Kernel Panics?

     Aqui vocês podem ver como ele está. Coloquem no comentário uma sugestão ou crítica para que eu possa ainda mexer!

By mZ

Você sabe binário?

Você tem vontade de fazer contas em binário de cabeça?

Pois seus problemaas acabaram, com a nova aulinha do PontoGeek!!!

Os números binários são identicos aos números que você disca no seu telefone. A unica diferença é que ao inves de aumentar dois algarismos quando você chega no 10º número (9, 10(o 10 tem 2 algarismos)), no 2º você aumenta dois algarismos.

———————–

Binário   |   Decimal

1             |       1

10        |       2

11           |       3

100      |       4

———————

Você quer confirir suas contas?

Consulte este link: http://www.tradutordebinario.pt.vu

Artigos anteriores:

Série objective-c 1 – Primeira aplicação via console texto

Série objective-c 2 – Primeira aplicação compilada via X-Code

Série objective-c 3 – Exercícios de fixação

Série objective-c 4 – Orientação a objetos

Série objective-c-5 – Estrutura lógica de um programa objective-c

No artigo anterior estudamos a estrutura lógica de um programa construído com objective-c explicamos sobre:

@interface section

@implementation section

program  section

No  exemplo mostrado, o programa era um único arquivo .m que continha todas as seções,  a interface, implementation e o programa principal. A titulo de exemplo, isto é válido para conhecer a estrutura da programação em objective-c, mas com o passar do tempo seus programas irão aumentar de tamanho e a divisão dos programas é vital para melhor organização e reutilização do código.

Hoje iremos aprender a separar as nossas classes em arquivos separados, dividindo a interface da implementação, para uma melhor organização e posterior reutilização do código.

EXEMPLO PROPOSTO

Temos o seguinte problema, queremos fazer a conversão entre moedas, a titulo de exemplo, vamos pensar em DOLAR para REAL, o usuário tem uma quantia em dolares e quer converter para reais, e nossa classe fará isto. Vou colocar um pequeno diagrama para facilitar o entendimento e a programação da classe.

Nossa classe será chamada ConverteMoeda.

Resumo do diagrama acima:

a)  Uma classe chamada ConverteMoeda conforme a instrução:

Class ConverteMoeda

b) Nossa classe tem dois atributos definidos

quantidade:   Atributo do tipo float ( para receber parte decimal de um número ), responsavel por armazenar a quantidade da moeda que iremos converter.

cambio: Atributo float, receberá o valor do cambio para fazer a conversão da moeda.

A classe terá 5 métodos

OBS: Foram implementados métodos acessores get e set para retornar e atualizar os valores dos atributos, em objective-c temos um recurso mais simples para acessar os atributos, mas veremos este conceito nos próximos artigos.

getQuantidade:  Retorna um float com o valor do atributo quantidade.

GetCambio: Retorna um float com o valor do atributo cambio

setQuantidade: Permite atualizar o valor do atributo quantidade

setCambio: Permite atualizar o valor do atributo cambio

printConversao: Calcula e retorna o valor da conversao entre as moedas.

Já entendemos o problema e fizemos um diagrama básico da classe, chegou a hora de iniciar a codificação.

O detalhe é que a partir de agora as nossas classes serão separadas em arquivos para facilitar a organização e a reutilização, ta legal, eu sei que já falei isto antes. :)

Os arquivos tem extensões, geralmente para identificar o conteúdo e a sua utilidade, arquivos swf são para Flash, mp3 músicas e por ai vai. Em objective-c por convenção os arquivo com extensão .m irão conter códigos e os .h serão os arquivos de cabeçalho, ou seja a parte da interface declaração da classe, atributos e assinatura dos métodos irão ficar em arquivos .h e a implementação ou a codificação propriamente dita em arquivos .m

No nosso exemplo criamos o diagrama para construir a classe ConverteMoeda, de acordo a metodologia explicada, teremos 2 arquivos:

ConverteMoeda.h

ConverteMoeda.m

Atenção:

A numeração das linhas foram incluidas apenas para facilitar a explicação devem ser incluidas para testar os programas.

Arquivo ConverteMoeda.h

01 // ————————— Inicio da codificação ———————————–

02 // Interface Class: ConverteMoeda

03 // Arquivo: ConverteMoeda.h

04 // Programador: Pierre Freire

05 // E-mail: blog@pierrefreire.com.br

06 // Versao: 0.01

07 //

08 #import < objc/Object.h>

09 @interface ConverteMoeda:Object

10 {

11    float quantidade;

12    float cambio;

13  }

14   -(float) getQuantidade;

15   -(float) getCambio;

16   -(void)  setQuantidade: (float) quantidadeMoeda;

17   -(void)  setCambio: (float) cambioMoeda;

18   -(float)  printConversao;

19 @end

//————————— Fim da codificação ———————————–

Comentários sobre ConverteMoeda.h

Linha 01-07: São apenas um comentário no programa

Linha 08: Usamos a diretiva #import para incluir a classe Object 

Linha 09: Inicio da declaração da classe, informamos o seu nome ConverteMoeda e usamos

                 a herança para que ele herde caracteristicas da SuperClasse Object, métodos como

                init e free que iremos usar são implementados nesta Classe.

Linha 10-13: Definimos os atributos de nossa classe.

Linha 14: Método que vai retornar um float com o valor do atributo quantidade

Linha 15: Método que vai retornar um float com o valor do atributo cambio

Linha 16: Método que recebe um parametro chamado quantidadeMoeda e atualiza atributo

                quantidade.

Linha 17: Método que recebe um parametro chamado câmbioMoeda e atualiza atributo cambio

Linha 18: Este método vai calcular o valor do câmbio e retornar um float com o resultado.

Linha 19: Finaliza o bloco de interface da classe.

Definimos o arquivo com a interface de nossa classe, vamos agora criar o arquivo para implementar as funcionalidades que definimos.

ConverteMoeda.m

01 // ————————— Inicio da codificação ———————————–

02 // Implementation: Class ConverteMoeda

03 // Arquivo: ConverteMoeda.m

04 // Programador: Pierre Freire

05 // E-mail: blog@pierrefreire.com.br

06 // Versao: 0.01

07

08 #import “converteMoeda.h”

09 

10 @implementation ConverteMoeda

11

12 -(float) getQuantidade

13 {

14    return quantidade;

15  }

16

17 -(float) getCambio

18

19  {

20     return cambio;

21  }

22

23 -(void) setQuantidade: (float) quantidadeMoeda

24  {

25     quantidade=quantidadeMoeda;

26  }

27

28   -(void) setCambio: (float) cambioMoeda

29  {

30      cambio=cambioMoeda;

31   }

32

33  -(float) printConversao;

34

35  {

36      return cambio*quantidade;

37  }

38

39 @end

40  //————————— Fim da codificação ———————————–

Linha 01-07: São apenas um comentário no programa

Linha 08: Usamos a diretiva #import para incluir a interface que definimos ConverteMoeda.h

Linha 10: Iniciamos o bloco de implementação da classe

Linha 12-15: Implementamos o método getQuantidade onde retornamos um float com o valor

                      do atributo quantidade.

Linha 17-21 Implementamos o método getCambio onde retornamos um float com o cambio

Linha 23-26 Implementamos o método setQuantidade onde recebemos o parâmetro

                    quantidadeMoeda e atualizamos o valor do atributo quantidade

Linha 28-31 Implementamos o método setCambio onde recebemos o parâmentro cambioMoeda

                    e atualizamos o valor do atributo cambio.

Linha 33-41 Implementamos o método printConversao onde multiplicamos o cambioXquantidade

                    e retornamos o valor da conversão.

Linha 39  Fechamos o bloco de implementação com @end.

Finalizamos a nossa classe, dividimos em 2 arquivos, o converteMoeda.h e o converteMoeda.m e agora podemos utilizar esta classe onde for necessário.

Vamos criar agora um arquivo chamado CalculaMoeda.m  para testar a nossa classe.

CalculaMoeda.m

01  // Programa Conversao de moedas

02  // Arquivo: CalculaMoeda.m

03  // E-mail: blog@pierrefreire.com.br

04  // Versao: 0.01

05

06  #import <  stdio.h >

07  #import “converteMoeda.h”

08  int main (int argc, char *argv[])

09  {

10       // Cria um objeto do tipo ConverteMoeda

11       // Aloca um espaco para o objeto dolar e o inicializa

12          ConverteMoeda *dolar=[[ConverteMoeda alloc] init];

13

14      // Usando metodo setQuantidade do objeto dolar

15      // Estamos informando a quantidade de dolares que queremos converter

16         [dolar setQuantidade: 12];

17

18     // Usando metodo setCotacao do objeto dolar

19     // Vamos informar o valor da cotacao, vamos imaginar em REAIS

20        [dolar setCambio: 2.30];

21     // Usando o metodo printSaldo

22     // Imprimindo o resultado

23        printf(“Quantidade de dolares…………%10.2f\n”,[dolar getQuantidade]);

24        printf(“Taxa de cambio em Reais…….%10.2f\n”,[dolar getCambio]);

25        printf(“Valor da conversao…………… %10.2f\n”,[dolar printConversao]);

26

27      // Liberando o objeto da memoria – Metodo free

28        [dolar free];

29        return 0;

30   }

Linha 01-05: São simples comentários do programa

Linha 06: Importando a biblioteca stdio.h, para usarmos a função prinft no programa.

Linha 07: Importando a nossa classe ConverteMoeda para que possamos usa-la no programa.

Linha 08: Declara o inicio da função main responsável por iniciar a execução do programa.

Linha 09: Delimitador do bloco de inicio do programa

Linha 12: Nesta linha declaramos o ponteiro *dolar sendo do tipo ConverteConta, e alocamos e inicializamos o objeto. Em relação aos artigos anteriores executamos estes passos em uma única linha. Para relembrar esta linha poderia ser escrita da seguinte forma também.

  IMPLEMENTAÇAO 01:

   ConverteMoeda *dolar;

   dolar = [ConverteMoeda alloc];

   dolar = [dolar init]; 

  IMPLEMENTAÇAO 02:

   ConverteMoeda *dolar=[[ConverteMoeda alloc] init];

A implementação 02 passará a ser usada neste e nos próximos artigos.

Linha 16: Nesta linha usamos o método setQuantidade para indicar a quantidade de doláres que

queremos calcular.

Linha 20: Usamos o método setCambio com o valor da cotação da moeda.

Linha 23: Usamos a função printf para imprimir na tela a quantidade de dolares, usando o método getQuantidade.

Linha 24: Usamos a função printf para imprimir na tela o valor do cambio usando o getCambio

Linha 25: Imprime o valor da conversão usando o  método printConversão.

OBS: o parametro %10.2f, indica que o número vai ter 10 digitos no máximo e 2 casas decimais o f vem de float e o \n indica uma quebra de linha.

Linha 28: Usamos o método free para liberar o objeto, vale a pena comentar que este método podemos usar porque nossa classe ConverteMoeda herda de Object que implementa esta método.

Linha 29: Esta linha retorna o controle ao SO indica que tudo terminou bem.

Para compilar:

gcc CalculaMoeda.m ConverteMoeda.m -o moeda -lobjc

gcc: Invoka o compilador gcc

CalculaMoeda.m e converteMoeda: São os arquivo com os fontes

-o moeda: Indica o nome do arquivo de saida, o executavel, escolha fica a criterio

-lobjc: Indica que deve ser usado as bibliotecas objective-c

Para executar:

./moeda

Resultado:

Quantidade de dolares…………     12.00

Taxa de cambio em Reais…….      2.30

Valor da conversao……………      27.60

Agora com este exemplo simples, aprendemos como dividir as classes em arquivos separados de interface e implementação e usa-la em outro programa.  Existem muitas coisas a saber sobre classes, fizemos apenas uma pequena introdução, futuramente iremos tratar deste assunto de forma mais profunda. Nos próximos artigos falaremos sobre os tipos, estruturas de controle e de decisões para que possamos finalizar a parte básica da linguagem.

Qualquer dúvida entrem em contato:

Abraço a todos.

Todos os meus artigos:

Desenvolvimento de sistemas para ambiente Apple

Configurando um ambiente de desenvolvimento para Mac, iPod e iPhone

Série objective-c

Artigo 01 – Conceitos Iniciais e Primeira Aplicação Via Console de Texto

Artigo 02 – Primeira Aplicação Compilada Via XCode

Artigo 03 – Exercícios de revisão

Artigo 04 – Orientação a Objetos

Artigo 05 – Estrutura Lógica de um Programa

Meu primeiro livro sobre Mac OS X, A primeira vez a gente nunca esquece!!!

Acessar Mac via Windows

Instalando Postgresql no Mac

01 – Acessamos o site http://www.postgresql.org/download e clicamos em Mac OS X.

02 – Chegamos a esta página, onde existem os pacotes pré-compilados para Mac OS X, clicamos em Download Mac OS X 10.4+ ou versões mais novas, no meu caso, foi testado no Mac OS X 10.5.5, esta página nos mostra os pacotes disponiveis para Mac OS, o mantenedor  deste pacote é o Dave Page.

03 – Chegamos a EnterpriseDB, empresa onde trabalha o mantenedor dos pacotes, clique no instalador para Mac OS X.

04 – A versão é a 8.3.5-1 e o tamanho é de 40 mb, agora vai tomar um café e relaxa um pouco.

05 – Quando terminar de baixar, você clica no arquivo que ele abre a imagem para você conforme a figura abaixo:

06 – Neste caso não é apenas arrastar para aplicativos, você vai acionar o instalador dele, clica e aquela típica mensagem do Mac OS, sempre que você abre um aplicativo pela primeira vez. Você concorda.

07 – Por questões de segurança o Mac OS exige que você digite a senha do seu usuário, aquele que você loga no sistema.

08 – O instalador faz algumas alterações no /etc/sysctl.conf do Mac OS, para otimizar alguns recurso do Postgresql, ele altera e pede para que você reinicie o sistema, isto mesmo, vamos lembrar do Windows ( risos ), não vai prejudicar o seu sistema, ele mostra que você pode deletar o arquivo depois também se quiser desfazer a operação, mas não se preocupe não vai doer. ( risos )

09 – Você ja voltou do reboot? Nossa que rápido, então execute novamente o instalador, até chegar nesta tela, onde iremos iniciar a configuração do banco.

10 – Nesta tela, ele pede para você indicar o diretório ( pasta ) onde sera instalado o banco, eu deixei no padrão.

11 – Este tela, quer saber onde ficará a pasta, onde os dados serão armazenados, em muitos casos, os administradores definem uma partição separada para armazenar as informações do banco, eu deixei no padrão escolhido pelo instalador.

12 – Para quem já usou um banco de dado, sabe que todo banco tem um SuperUsuário, aquele que pode fazer tudo no banco até apagar ele ( que medo ), então esta é  senha dele. O nome do superusuário é postgres. Neste caso você esta definindo a senha do superusuário postgres

13 – Aqui você define a porta que o banco vai escutar para receber conexões, a porta de conexão padrão do postgres é a 5432, você pode até mudar, desde que ela não esteja ocupada por outro serviço omo por exemplo a 22 do ssh ou a 80 do apache. Te aconselho a deixar a padrão neste caso.

14 – As configurações regionais do banco, vamos deixar no locale padrão.

15 – Agora que respondemos a estas perguntas, manda o instalador trabalhar :). Estamos prontos. Clique em Next para o próximo passo.

16 – A festa começou, ele esta instalando o banco, olhe a tela abaixo, cara vai fazer algo útil enquanto ele trabalha, já sei, vai ler os outros posts do blog. :)

17 – Olha o elefante ai gente, isto quer dizer que chegamos a Africa? Não o elefante é o simbolo do Postgres, ele esta falando para você que o banco foi instalado com sucesso, olhe que esta marcada a opção Launch Stack Builder at exit, ou seja assim que clicar em finish ele já inicia o banco para você.

18 – Na parte de aplicativos, você agora pode ver o icone da pasta Postgresq 8.3 instalada, clique nela para expandir.

19 – Eu sei que você é meio cego:) e não estava vendo direito, por isto eu resolvi ampliar para você, tem algumas opções importantes aqui:

Documentation: Documentação sobre o Banco

PGAdmin: um programa gerenciador do Banco, pode usar ele para criar, apagar, selecionar tabelas, usuarios ou seja administrar o banco. É uma interface gráfica.

SQL Shell: Um cliente em modo texto, extremamente poderoso e altamente recomendado o aprendizado para administrar o banco.

Start Server: Serve para iniciar os serviços do banco, ou seja colocar ele no ar.

Stop Server: Tem um pirulito se acertar o que isto faz? Parar o banco né filho!!

19 – Vamos iniciar o banco para testar? Pierre, eu já iniciei quando fechei o instalador. Ta, mas quero iniciar de novo, faz o seguinte, para ele então. :)

Clica em Start Server

20 – O Start Server, exige que você digite a sua senha de usuário do Sistema, aqui não é a sua senha do banco, é a senha sua no sistema, aquela que você usa quando instala um programa e faz algumas operações no sistema, quando loga por exemplo.

21 – Ele vai mostrar esta mensagem, o banco esta no ar.

22 – Existem duas formas de acessar o banco via a interface gráfica, PGAdmin ou através do modo texto, vamos usar o modo texto, acesse a opção SQL Shell ( psql ), naquele menu dos aplicativos onde tem a pasta Postgresql que  mostrei antes. Quando clicar, ele vai:

Server [localhost]: Aqui é o endereço de onde esta o banco de dados, no nosso caso esta instalado na nossa maquina, entao pode colocar localhost ou 127.0.0.1 o ip de loopback local.

Database: Aqui ele pergunta o nome do banco de dados que você quer acessar,  ainda não criamos os nossos bancos de dados, não é o escopo deste artigo, mas quando você instala o postgres ele cria um banco de modelo, ele se chama template1, coloque este.

Username: Cara pálida, este é o nome do usuário que você escolheu quando estava instalando o banco, lembra que te falei que o superusuário do banco se chama postgres, coloca ele.

Port: Já falamos sobre isto né? Coloque a porta que você escolheu ou deixe a padrao 5432

Password: Aqui é a senha, não é a senha do Sistema, aqui é a senha que você escolheu para o usuário postgres, lembra??

Resumindo:

Server [localhost]: localhost

Database [postgres]: template1

Port [5432]: 5432

Username [ postgres ]: postgres

Password for user postgres: **** ( Esta aqui você que colocou, o problema é teu ) :)

23 – Se aparecer a tela abaixo, você conseguiu!! Esta conectado no banco.

Vamos ficando por aqui, as vezes precisamos de feedbacks para continuarmos escrevendo, além da série sobre objective-c que estou escrevendo, vocês gostariam de alguns artigos sobre banco de dados? Não sei até que ponto seria interessante, aguardo as sugestões de vocês.

Abraços.

Aproveitem e vejam o que acontece nas horas vagas de um nerd.

Video sobre treinamento de como aumentar a inteligência do seu cachorro

Perguntas:

01 – Pierre, agora que instalei o banco o que faço?

R – Este artigo tinha este foco, a instalação do banco, caso ache útil alguns artigos sobre como usar o banco e uma breve introdução sobre SQL, comente para quem sabe criarmos uma série neste sentido.

02 – E a série sobre objective-c?

R – Estou preparando novos artigos, e instalar um banco é importante porque futuramente poderemos fazer alguns posts falando do uso dele com Objective-c e Cocoa.

03 – É você mesmo no video?

R – Sim, as vezes tenho um tempo livre e quando falta o que fazer, gravo vídeos e blogo com os amigos.

Estamos de volta e agora chegamos ao artigo número 5 da série objective-c, para reforçar os estudos do post anterior onde apresentamos a orientação a objetos, vamos falar sobre cada parte da estrutura de um programa feito com objective-c, é importante que postem suas dúvidas, criticas e sugestões nos comentários para que possamos ir melhorando ou pelo menos tentando. Vamos ao post…

Leitura recomendada:

Posts anteriores da série:

Desenvolvimento de sistemas para o mundo Apple
Configurando um ambiente de desenvolvimento para iPod, iPhone e Mac
Objective-c 01 – Conceitos iniciais e primeira aplicação via console de texto
Objective-c 02 – Primeira aplicação compilada via XCode
Objective-c 03 – Exercícios de revisão
Objective-c 04 – Orientação a objetos
Estes artigos você encontra no item programação, aqui no blog.

No último artigo nós vimos os primeiros passos em orientação a objetos e escrevemos o primeiro programa, hoje irei fazer uma revisão rápida sobre a estrutura lógica de um programa em objective-c, é importante que leiam o artigo Série objective-c 4 – Orientação a objetos para terem um melhor aproveitamento deste artigo.
Hoje iremos ver mais detalhes da estrutura lógica de um programa objective-c

Existem 3 seções fundamentais em um programa:

1. @interface section
2. @implementation section
3. program  section

A @interface section é onde você descreve a classe, uma espécie de contrato, onde você define o que será implementado na sua classe, informa o nome da classe, seus atributos, métodos.
A @implementation section é onde codificamos os métodos que foram definidos na interface.
programa section é o inicio do programa em si, onde definimos a função main e o que ela vai executar.

Cada seção tem suas tarefas bem definidas em objective-c, inclusive é recomendavel que elas sejam divididas em arquivos diferentes ou seja um arquivo para @interface section, outro para @implementation e mais um para o programa principal. No nosso exemplo inicial usamos apenas um, mas no decorrer deste curso iremos aprender a usa-los separados.

1. @interface section

Quando você deseja criar uma classe, primeiro você define a sua interface, o nome da classe, de qual classe ela vai herdar funcionalidades ( não obrigatório ), quais os atributos e métodos que esta classe irá ter, esta é a parte de interface que devemos escrever em um programa objective-c.

@interface ClassName: ParentClassName
{
atributos;
}
métodos;
@end

// Exemplo prático

@interface Funcionario: Object
{
int  cpf
int anoNascimento;
}
-(void) setCpf: (int) nCpf;
-(void) setAnoNascimento: (int) nAno;
-(void) printFicha;
@end

Definimos uma classe chamada Funcionario que vai herdar caracteristicas de uma super classe chamada Object, esta classe vai ter os atributos  cpf e anoNascimento e 3 métodos de instância setCpf, setAnoNascimento e printFicha.

Esta é a seção interface de um programa objective-c, leia este artigo e estude o exemplo do artigo anterior.

2. @implementation section

A seção de implementação é onde você vai escrever o código dos métodos que foram definidos na interface, caso você defina um método na interface, mas não escreva sua implementação na hora da compilação, será dado um aviso que o método definido na interface não foi implementado, mas o programa vai ser compilado, caso por algum razão da vida, queira definir um método e não implementa-lo totalmente, você pode definir a assinatura do método e a parte da codificação entre {} deixar em branco.

@implementation ClassName;
métodos;
@end

Exemplo prático

@implementation Funcionario;
-(void) setCpf: (int) nCpf
{
cpf = nCpf;
}

-(void) setAnoNascimento: (int) nAno
{
ano=nAno;
}

-(void) printFicha
{
printf(“Ficha do funcionario\n”);
printf(“CPF: %i”,cpf);
printf(“Ano Nascimento:%i”,ano);
}

@end

@implementation Funcionario;
Iniciamos a implementação dos métodos definidos na classe Funcionário.

-(void) setCpf: (int) nCpf
Esta é a assinatura do método setCpf definido na interface funcionário.
-   O sinal de – indica que é um método de instância, caso fosse estático seria +
(void) se refere ao retorno do método, neste caso void indica que ele nao retorna nada
setCpf:  Nome do método
(int) nCpf informa que na hora da chamada, este método recebe um parametro inteiro
{} O código para implementação do método deve estar entre chaves

// A implementação dos outros métodos…

@end Finaliza o bloco de implementação.

3. Program Section

Esta é a parte onde se inicia o seu programa a partir da função main.

int main (argc,char argv[])
{
Funcionario *pierre;
pierre=[Funcionario alloc];
pierre=[pierre init];
[pierre setCpf 12345674831];
[pierre setAnoNascimento 1969];
[pierre printFicha];
[pierre free];
return 0;
}

Este linha indica que pierre é um objeto do tipo funcionário, ele é usado para guardar valores da classe Funcionário, o * indica que ele é um ponteiro, iremos ver sobre ponteiros mais adiante.
Funcionario *pierre;

Nesta linha nós estamos alocando um espaço da memória para o objeto pierre, ou seja foi disponibilizada uma área da memória para este objeto, não podemos ainda acessar seus atributos e métodos porque eles ainda não foram inicializados.
pierre=[Funcionario alloc];

Depois de alocar espaço na memória, inicializamos o objeto ou seja tornamos acessiveis as suas propriedades e métodos.
pierre=[pierre init]

Agora com o objeto instanciado, estamos usando os métodos que implementamos, o método setCpf e passando o parametro 12345674831.
[pierre setCpf 12345674831]

Usando método setAnoNascimento e passando o parametro 1969. Em Java poderia ser algo do tipo pierre.setAnoNascimento(1969)
[pierre setAnoNascimento 1969]

Abaixo usamos o método printFicha como podem ver ele não requer parametros.
[pierre printFicha]

Abaixo usamos o método free, este método a exemplo do alloc e do init, não foi implementado por nós, mas sim herdado da classe Object, analisem a parte de interface, para comprovarem este fato, já deu para perceber como a herança é um conceito importante em OOP. Este método libera a memória usada pelo objeto, geralmente usamos quando não precisamos mais do objeto no nosso programa.
[pierre free]

É o retorno da função main.
return 0;

Chegamos ao fim de mais um artigo da série objective-c, espero que tenha ficado claro estes conceitos iniciais da estrutura lógica de um programa em objective-c. Agora é continuar os estudos e praticando sempre.

Abraços,

A série objective-c continua, e hoje iremos conhecer a estrutura básica de um programa feito nesta linguagem, até o momento os programas eram basicamentes codificados usando a sintaxe do C Ansi, como disse antes objective-c herdou  a simplicidade, velocidade do C e hoje iremos conhecer a orientação objetos, paradigma que ela herdou da Smalltalk, estes conceitos irão nos acompanhar até chegarmos aos nossos exemplos em Cocoa, objetivo este que iremos alcançar até 2097… Vamos a mais um tutorial.

Leitura recomendada:

Posts anteriores da série:

Desenvolvimento de sistemas para o mundo Apple
Configurando um ambiente de desenvolvimento para iPod, iPhone e Mac
Objective-c 01 – Conceitos iniciais e primeira aplicação via console de texto
Objective-c 02 – Primeira aplicação compilada via XCode
Objective-c 03 – Exercícios de revisão

Estes artigos você encontra no item programação, aqui no blog.

Hoje iremos falar sobre orientação a objetos no objective-c. Iremos trabalhar com um exemplo simples e ilustrar os conceitos de classe, objetos métodos e atributos.
Aos que não tem  familiaridade com este paradigma de programação, recomendo ler materiais sobre o assunto, pois o domínio da programação orientada a objetos é vital no desenvolvimento de aplicações em objective-c.

Vejam os link abaixo:
Orientação a objetos Wikipédia

Artigo orientação a objetos

Até agora vimos exemplos extremamente simples e usando apenas a função main, nada diferente dos programas feitos em C ansi.
Vamos estudar alguns aspectos mais específicos do objective-c, em especial a orientação a objetos. Vamos escrever um pequeno programa que armazena e exibe o saldo de uma conta corrente. Como se trata de um exemplo,  nesta versão, não iremos contemplar, saques, depósitos, apenas o número da conta e saldo.
Abaixo temos um diagrama de classe bem simples, do que iremos implementar, recomendo darem uma olhada em UML em especial diagrama de classes para quem tiver dúvidas.

Diagrama da Classe Conta:

No diagrama acima, estamos definindo a classe Conta:

Nome da nossa classe
Class Conta

São definidos 2 atributos, saldo e conta, private indica que eles serão acessiveis apenas dentro da classe, isto mostra um exemplo de um dos conceitos de OOP o encapsulamento, logo a seguir definimos os tipos destes atributos int e float.
private int: conta
private float: saldo

Métodos da classe
Os métodos trazem funcionalidades as classes,  nesta diagrama de classe definimos 3 métodos:
setConta, setSaldo e printSaldo. Eles tem escopo público(public), diferente dos nossos atributos, eles podem ser acessados de fora da nossa classe,  o parametro void indica que eles não terão retorno algum. Os métodos setConta e setSaldo serão chamados mas terão um parametro obrigatório na hora da chamada respectivamente int e float.

public void setConta(int)
public void setSaldo(float)
public void printSaldo()

Codificando em objective-c

Agora que entendemos o nosso diagrama de classe, temos os atributos e os métodos definidos vamos escrever o nosso primeiro programa em objective-c com programação orientada a objetos.

Use o seu editor ou IDE favorito e vamos iniciar os trabalhos.
É importante saber que um programa em objective-c tem 3 partes bem definidas:

01. Definição da interface das classes
02. Implementação dos métodos definidos na interface
03. A função main e o ínicio do programa em si.

Listagem do programa em azul:

// Programa exemplo orientação a objetos
// Programador: Pierre Freire
// E-mail: blog@pierrefreire.com.br
// Versao: 0.01

//———— Definindo as diretrizes ————-
#import <stdio.h>
#import <objc/Object.h>

//————- Definição da interface das classes ————–

@interface Conta:Object
{
int conta;
float saldo;
}
-(void)  setConta: (int) numberConta;
-(void)  setSaldo: (float) valorOperacao;
-(void)  printSaldo;
@end

//—————– Implementação dos métodos definidos na classe ——————–

@implementation Conta
-(void) setConta: (int) numberConta
{
conta=numberConta;
}

-(void) setSaldo: (float) valorOperacao
{
saldo=valorOperacao;
}

-(void) printSaldo;
{
printf(“Extrato bancario \n\n”);
printf(“———————–\n”);
printf(“Conta:%i\n”,conta);
printf(“Saldo:%f\n”,saldo);
}
@end

//————- Programa principal —————

int main (int argc, char *argv[])
{
// Cria um objeto do tipo Conta
Conta *itau;

// Aloca um espaco para o objeto itau e inicializa
itau = [Conta alloc];
itau = [itau init];

// Usando metodo setConta do objeto itau
[itau setConta: 12];

// Usando metodo setSaldo do objeto itau
[itau setSaldo: 200.00];

// Usando o metodo printSaldo
[itau printSaldo];

// Liberando o objeto da memoria – Metodo free
[itau free];
return 0;
}

Entendendo o código

01 – Definindo as diretrizes do pré-processador
//———— Definindo as diretrizes ————-
#import <stdio.h>
#import <objc/Object.h>

Como comentamos anteriormente este parte do código, definimos as diretrizes do pré-processador, neste caso, incluimos a biblioteca stdio.h porque estamos usando a função printf e a Object.h porque estamos usando a classe Object.

02 – Definindo a interface da classe

//————- Definição da interface das classes ————–

@interface Conta:Object
{
int conta;
float saldo;
}
-(void)  setConta: (int) numberConta;
-(void)  setSaldo: (float) valorOperacao;
-(void)  printSaldo;
@end

A definição da interface da classe é uma espécie de contrato, onde você define o nome da sua classe, se ela herda característica de outra classe os atributos que a compoem e os métodos que ela irá ter.  Ou seja definimos apenas a estrutura da classe.

Definimos a interface, o nome da classe será Conta e ela é subclasse de Object ou seja ele herda todos os métodos e atributos desta classe. Definimos os atributos conta e saldo sendo tipo int ( inteiro) e float respectivamente.

@interface Conta:Object
{
int conta;
float saldo;
}

Definimos os 3 métodos da classe o sinal de – indica que será um método de instância ou seja ele só pode ser acessado depois de instanciada o objeto da classe, mas adiante veremos mais detalhes sobre isto. setConta e setSaldo necessitam de um parametro do tipo int e a variavel usada para este parametro é definida logo adiante numberConta e valorOperação respectivamente. O @end fecha o bloco.
-(void)  setConta: (int) numberConta;
-(void)  setSaldo: (float) valorOperacao;
-(void)  printSaldo;
@end

03 – Implementação dos métodos definidos na classe

Inicio do bloco de implementação da classe Conta
@implementation Conta

Implementação do método setConta, o método não retorna nada (void) na sua chamada ele recebe um inteiro(int) que será armazenado na variavel numberConta no corpo do método definido pelos “{}” ele armazena no atributo conta o número passado por parâmetro.
-(void) setConta: (int) numberConta
{
conta=numberConta;
}

Implementação do método setSaldo, o método não retorna nada (void) na sua chamada ele recebe um float(float) que será armazenado na variavel valorOperacao no corpo do método definido pelos “{}” ele armazena no atributo saldo o número passado por parâmetro.

-(void) setSaldo: (float) valorOperacao
{
saldo=valorOperacao;
}

Este método nada retorna (void) não recebe parametros e simplesmente imprime as informações armazenadas por setConta e setSaldo.

-(void) printSaldo;
{
printf(“Extrato bancario \n\n”);
printf(“———————–\n”);
printf(“Conta:%i\n”,conta);
printf(“Saldo:%f\n”,saldo);
}
@end

4 – Programa principal
Nesta parte do código é de fato onde se inicia a execução do nosso programa, vamos ver passo a passo o que acontece.

Função main, é o inicio do programa, ela retorna um inteiro ao seu final e alguns parametros podem ser passados via linha de comando, mais adiante veremos como isto funciona.
int main (int argc, char *argv[])
{

Nesta linha criamos uma variavel chamada itau, que guardará valores da classe Conta, ou seja poderemos acessar os métodos e atributos desta classe atraves deste objeto, o * informa que itau é também um ponteiro.
Conta *itau;

Antes de usarmos o objeto é necessário alocar espaço na memória para ele.
itau = [Conta alloc];

Após alocar espaço inicializamos as variaveis que fazem parte do objeto, no nosso exemplo os atributos conta e saldo.
itau = [itau init];

Tudo pronto, começamos a usar o nosso objeto, acessamos o método setConta definido na classe e passamos o parâmetro 12 para ele. Algumas linguagens se usam o ponto, por exemplo em Java esta chamada poderia ser itau.setconta(12), abaixo a chamada deste método em objective-c.
[itau setConta: 12];

Aqui estamos executando o método setSaldo e passando o valor 200.00, como ele aceita um float podemos passar a parte decimal.
[itau setSaldo: 200.00];

Agora que preenchemos os atributos do objeto conta e saldo, usamos o método print para imprimir o resultado na console.
[itau printSaldo];

Já usamos o objeto para atribuir os valores e imprimir, agora usamos o método free para liberar a memória, este método não foi criado por você, como a nossa classe Conta herda Object ela pode usar este método que pertence a Object, este é o conceito de herança, não tivemos o trabalho de implementar este método, simplesmente herdamos ele de outra classe.
[itau free];

Estamos finalizando a função main e na declaração dela ela exige que se retorne um inteiro, estamos retornando o valor zero, que na verdade é um código para informar ao Sistema operacional que o programa terminou com sucesso.
return 0;
}

Resultado do programa.

Extrato bancario
———————–
Conta:12
Saldo:200.000000

Bem, ficamos por aqui, estude o exemplo, crie um programa qualquer parecido e poste suas dúvidas nos comentários ou me mande um e-mail.
Na próxima aula iremos fazer alguns exercícios e incrementaremos o nosso programa de conta, adicionando novos métodos. E estude orientação a objetos.

Durante o curso iremos estudar outros conceitos de OOP, isto foi apenas uma pequena introdução de como se usar OOP em objective-c.
Espero que esteja sendo útil para alguém estes tutoriais.

Abraços.