Para se programar em Clipper, você precisa de um editor de textos tipo o Edit do MS-DOS para escrever os programas. Os mais conhecidos são o Qedit e o Side-Kick pela sua gama de opções na editoração do texto que facilita a vida do programador.

 Os programas são compostos de arquivo de texto e tem por padrão a extensão de arquivo *.PRG.

// Tudo que vem depois das duas barras é ignorado, apenas comentário.
CLS // LIMPA A TELA
cNOME := SPACE(35) // DEFINE VARIÁVEL cNOME C/ 35 CARACTERES EM BRANCO
@ 01,10 SAY "QUAL É O SEU NOME ?" GET cNOME // Pergunta na linha 1, coluna 10.
READ // LÊ O(S) GET(S) - ESPERA ENTRADA DO TECLADO
// SE FINALIZAR COM [ENTER] ATRIBUI O VALOR À cNOME
// SE SAIR COM [ESC] cNOME PERMANECE = SPACE(35)
@ 02,10 SAY "VOCÊ DISSE QUE ERA "+cNOME // DIZ NA LINHA 2, COLUNA 10, SEU NOME 

 Cada linha do programa não necessita de indicadores de final de linha, como se verifica em algumas linguagens com o (;) "ponto e vírgula" (Pascal, Javascript, C etc.). Pelo contrário, se o último caractere de uma linha no Clipper for um "ponto e vírgula", indica que a linha não terminou e que a linha abaixo é continuação da linha de cima.

 Ex:

 
IF (!EMPTY(cCDEBITO) .OR. !EMPTY(cCCREDITO));
   .OR. cCDEBITO # cCCREDITO 
   EXIT 
ENDIF

Seria o mesmo que:

IF (!EMPTY(cCDEBITO) .OR. !EMPTY(cCCREDITO)) .OR. cCDEBITO # cCCREDITO
   EXIT 
ENDIF  

  Só que, para visualizar melhor, você preferiu "quebrar" a linha para não ter que ficar usando a rolagem para a direita para ver o que tem depois.

  Para compreender melhor o programa, sempre utilize endentação das linhas, que nada mais é do que os espaços regulares que são dados no início de cada uma delas para indicar que as informações fazem parte de uma rotina (conjunto de informações) específica a ser executada. Quer dizer que você irá dar espaços regulares nas linhas que estiverem dentro de um Loop (DO WHILE...ENDDO, FOR...NEXT) ou que satisfaçam uma condição (IF...ENDIF, DO CASE...ENDCASE, DO WHILE <condição>...ENDDO)

Ex.:

IF !EMPTY(cCCREDITO) 
   nTCRED -= tvCAMPO // ESTORNA VALOR ANTERIOR
   nTCRED += vCAMPO // LANCA VALOR ATUAL
   IF nACAO = 3
      IF SA->( DBSEEK(TMP->CREDITO + DTOS(TMP>DATA) ))
             SA->( LOCKREG())
             SA->CREDITO -= tvCAMPO
             SA->CREDITO += vCAMPO
             SA->( DBUNLOCK())
             SA->( DBCOMMIT())
      ENDIF
   ENDIF
ENDIF

 Observe como é dado os espaços no início de cada linha. Viu como ficou mais legível a visualização?! Desta forma fica muito mais fácil interpretar e entender o programa do que se estivesse tudo junto à margem esquerda, não acha?! Use também linhas em branco para separar segmentos de código que executam um determinada tarefa e abuse de linhas de comentário para lembrá-lo rapidamente o que faz cada rotina do seu programa.

 Os espaços, linhas em branco e linhas de comentários são simplesmente ignorados pelo compilador do Clipper. Não pense que você irá estar economizando bytes do seu programa (*.EXE) ao ignorar a dica do parágrafo anterior. Você já percebeu que não consegue marcar uma linha de comentário no depurador (Debug)?!

 Procure padronizar a programação em letras maiúsculas. Quando for criar variáveis de memória, use a primeira letra da variável igual a primeira letra do tipo da variável, em minúscula, (n = NUMÉRICO, c = CARACTERE, d = DATA, m = MEMO e l = LÓGICO). Por exemplo: dINICIAL := CTOD(""). Você saberá que dINICIAL é do tipo DATA (DATE), em qualquer lugar do programa, porque começa pela letra d.

 Se você está aprendendo uma linguagem, não pense que você precisa decorar a sintaxe de todos os comandos e funções para conseguir programar alguma coisa, ao invés disso mentalize o que aquilo faz e tente imaginar quando irá precisar usar, execute o NG (Norton Guide) quando for programar e aí é só pressionar Shift + F1 para consultar a sintaxe correta. Nem os veteranos sabem a sintaxe de tudo e mesmo sabendo, normalmente preferem não arriscar e consultar o NG, por isso não tenha vergonha de usá-lo, use-o sempre!

 Um Loop ("laço") é um conjunto de informações que são executadas automaticamente mais de uma vez. Os comandos DO WHILE...ENDDO e FOR...NEXT, por exemplo, podem fazer loop, podem fazer executar as informações que estão contidas dentro deles mais de uma vez.

  Linguagem de Alto Nível é a linguagem que se aproxima da linguagem dos homens. É aquela que é mais inteligível aos "olhos dos homens" do que aos "olhos da máquina". Quanto mais "alto nível", mais fácil é de programar e maior o tamanho do programa, porque haverá uma grande "tradução" para a linguagem que a máquina entende.

  Linguagem de Baixo Nível é a linguagem que se aproxima da linguagem das máquinas. É aquela que é mais inteligível aos "olhos das máquinas" do que aos "olhos do homem". Quanto mais "baixo nível", mais difícil é de programar e menor o tamanho do programa, porque haverá apenas uma pequena "tradução" para a linguagem que a máquina entende.

  Compilar um programa consiste basicamente em transformar o seu *.PRG em *.OBJ (arquivos OBJetos), que contém informações em linguagem de máquina. É nesta fase que aparece todos os erros de sintaxe do programa, ou seja, se você digitou alguma coisa errada que não existe, dará erro neste momento. Poderão ocorrer outros erros, mas isto é uma outra estória...

  Linkeditar ou Linkar (do inglês Link, ligar, conectar, vincular) um programa consiste em vincular o seu programa objeto (OBJ) às bibliotecas intérpretes (clipper.lib, extend.lib etc) da linguagem. Todos os comandos do Clipper são transformados em funções (Veja o arquivo STD.CH no sub-diretório /INCLUDE) e estas funções são escritas em uma linguagem de baixo nível, a maioria em C ou Assembler (ASM). Isto quer dizer que as funções que você usa em Clipper, são funções prontas  em C ou ASM para facilitar a sua vida.

  Importante: Quando alguém manda você compilar o programa, este alguém quer dizer: COMPILE e LINKEDITE o programa! Transforme-o em um arquivo executável (*.EXE).

  Para usar o Clipper é preciso definir algumas variáveis ambiente do DOS, que apontam os diretórios onde se encontram cada tipo de arquivo usado pelo Clipper onde ele foi instalado, i.e., arquivos de cabeçalho (*.CH), bibliotecas (*.LIB), objetos (*.OBJ) etc. Usa-se o comando interno do MS-DOS chamado SET para definir tais variáveis e é aconselhável que todas elas estejam no arquivo de lote AUTOEXEC.BAT que é executado automaticamente toda vez que o computador é ligado. 

Ex.:

SET PATH=C:\WINDOWS;C:\WINDOWS\COMMAND;C:\CLIPPER5\BIN;C:\NG;C:\BLINKER
SET CLIPPER=S1,F200
SET INCLUDE=C:\CLIPPER5\INCLUDE
SET LIB=C:\CLIPPER5\LIB;C:\BLINKER\LIB
SET OBJ=C:\CLIPPER5\OBJ;C:\BLINKER\OBJ
SET PLL=C:\CLIPPER5\PLL
SET TEMP=C:\TEMP
SET TMP=C:\TEMP

   Veja mais detalhadamente como instalar o Clipper aqui.

  Observe que o linkador Blinker possui algumas variáveis ambiente iguais ao do Clipper, usa-se o ";" (ponto e vírgula) entre os valores da variável. Para saber mais sobre o Blinker, entre em Dicas. Se você não usa o Blinker, ignore o conteúdo de fundo amarelo do exemplo acima.
  Para verificar se estas variáveis estão definidas, digite SET no prompt de comando do MS-DOS (e tecle Enter), aparecerá todas as variáveis de ambiente definidas.

  Para compilar um programa em Clipper, digite CL mais o nome do seu programa. Ex.: CL teste

  CL é um arquivo de lote (*.BAT) que vem com o Clipper e fica no sub-diretório \BIN onde o Clipper foi instalado. Observe que este sub-diretório está no PATH do Autoexec.bat.

  Se você tem o Blinker, mas não sabe usar, baixe o arquivo BLI.BAT na página de Downloads, pois serve como o CL.BAT, exceto que, linkando com o Blinker.

  Todos os arquivos que estão dentro dos diretórios listados na variável ambiente PATH do MS-DOS, separados por ";", podem ser executados em qualquer outro diretório como se o referido arquivo nele estivesse.

  Para se obter o valor de uma variável ambiente no MS-DOS usa-se o "%" no início e no fim da variável. No Clipper usa-se a função GETENV(<variável ambiente>).

  Ex.: Digamos que você gostaria que o diretório C:\UTIL estivesse em seu PATH, mas você não quer alterar o Autoexec.bat e reiniciar a máquina agora e também não quer redigitar o PATH inteiro de novo incluindo o referido diretório, o que você faz? SET PATH=%PATH%;C:\UTIL

  Seu arquivo CONFIG.SYS deve estar, no mínimo, assim:

DEVICE=C:\WINDOWS\HIMEM.SYS /TESTMEM:OFF
DEVICEHIGH=C:\WINDOWS\EMM386.EXE 2048 MIN=1024 RAM HIGHSCAN
DOS=HIGH,UMB
BUFFERS=50
FILES=220
BREAK=ON
SHELL=C:\WINDOWS\COMMAND\COMMAND.COM C:\WINDOWS\COMMAND /E:1024 /P

Na última linha, o parâmetro /E:1048 acima reserva 1Kb de espaço ambiente (environment space) para variáveis ambiente. Prevenindo o erro out of environment space quando se está definindo novas variáveis ambiente no MS-DOS. Você pode aumentar esse número para 2048. Não se preocupe com isso se você estiver usando o Windows XP, veja como instalar o Clipper. 

Se você deseja criar um sistema em Clipper, entre no sub-diretório SOURCE\DBU do Clipper e observe o que fazem os arquivos *.RMK e *.LNK. Observe também os *.PRG, todos são como grandes funções, começando na primeira linha por FUNCTION NOMEDOPROGRAMA(). Veja também que o programa executado primeiramente contém na sua primeira linha FUNCTION MAIN(). Esta é a melhor forma de compilação porque você não precisa compilar todos os programas de novo se alterar apenas alguns programas, só os programas que estiverem sido alterados serão compilados novamente, poupando-se tempo. Além disso, este método evita o erro: Too many symbols e o Too many labels. Veja a seguir o arquivo DBU.RMK comentado:

// Dbu.rmk
//
// Make file padrão para o utilitário DBU
// Copyright (c) 1990-1993, Computer Associates International Inc.
// All rights reserved.
//
// NOTA:
// Para compilar o DBU com o DEBUG (CLD) você deve definir
// o nome da macro DEBUG com o parâmetro /d. Isto pode ser feito assim: 
//
// RMAKE DBU /dDEBUG
//
// Determina se DEBUG é ativado // Veja mais informações no seu Norton Guide (NG) em: Manutençao de Programas RMAKE.EXE (linha de comando)
#ifdef DEBUG
// Se foi ativado inclui parâmetro /b correspondente ao DEBUG
// Veja mais informações no NG em: Compilador do Clipper CLIPPER.EXE (linha de comando)
CompOptions := /b /m /n
#else
CompOptions := /m /n
#end

.prg.obj:
clipper $< $(CompOptions)
// aqui é sempre uma lista de todos os programas que compõem seu aplicativo
// sendo que do lado esquerdo o nome do obj e do lado direito o nome do programa, separados por dois pontos (:)
dbu.obj : dbu.prg
dbuutil.obj: dbuutil.prg
dbuhelp.obj: dbuhelp.prg
dbuview.obj: dbuview.prg
dbuindx.obj: dbuindx.prg
dbuedit.obj: dbuedit.prg
dbucopy.obj: dbucopy.prg
dbustru.obj: dbustru.prg
dbunet.obj : dbunet.prg
// essas linhas abaixo são desnecessárias, visto que é papel do arquivo *.lnk fazer isso
// não entendo porque existem e você pode criar o seu arquivo *.RMK apenas com as linhas que foram listadas acima.
dbu.exe: dbu.obj dbuutil.obj dbuhelp.obj dbuview.obj
dbuindx.obj dbuedit.obj dbucopy.obj dbustru.obj dbunet.obj
rtlink @dbu

Este arquivo *.RMK é lido pelo RMAKE, já o *.LNK é lido pelo RTLINK, BLINKER etc.

Veja que as barras duplas para o RMAKE é um comentário, já para o RTLINK é a cerquilha (#) que faz esse papel.

Baixe o Norton Guide (NG) em português na página de Downloads.

Agora veremos o arquivo DBU.LNK comentado:

# coloque o arquivo principal do seu sistema na primeira linha e depois o resto.
# observe que basta o nome do arquivo sem a extensão
# todos os programas devem ser precedidos por "file"
file dbu
file dbuutil
file dbuhelp
file dbuview
file dbuindx
file dbuedit
file dbucopy
file dbustru
file dbunet
# no final ponha as LIBs que serão compiladas com o seu aplicativo
# as LIBs devem ser precedidas por "lib"
lib clipper
lib extend
lib dbfntx
lib terminal 

Assim você agiliza a compilação do seu sistema.

É tão fácil programar em Clipper que você não precisa de uma estrutura tão complicada para criar um programa simples, veja como ficaria o clássico programa "Olá Mundo":

? "Olá, Mundo!"

Pronto! Mais nada. Agora é só salvar o arquivo como ola.prg e compilar com CL OLA. Viu como é facil?

Agora veja como seria em C++:

#include "iostream"

int main()
{
   std::cout << "Olá, Mundo!";
   return 0;
}

Em PASCAL:

Program Ola_Mundo;
Uses crt;
Begin
   Writeln('Olá, Mundo!');
End.

Em FORTRAN:

PROGRAM HELLO
WRITE(*,10)
10 FORMAT('Olá, Mundo!')
STOP
END

    Em ASSEMBLY:

.model small
.stack
.data
message   db "Olá, Mundo!", "$"

.code

main   proc
   mov   ax,seg message
   mov   ds,ax

   mov   ah,09
   lea   dx,message
   int   21h

   mov   ax,4c00h
   int   21h
main   endp
end main_

Fonte: Programa Olá Mundo. In: <http://pt.wikipedia.org/wiki/Programa_Olá_Mundo >. Acessado em 01/05/2010.

Agora está vendo o que estou falando, não é?! rs

Veremos a seguir os tipos de campos e variáveis do Clipper:

COMO PROGRAMAR UM SISTEMA

Um sistema deve ter basicamente:

• Cadastro;
• Consulta;
• Edição;
• Deleção;
• Relatórios.

Além disso, todo sistema profissional tem que ter controle de acesso por tipos de usuário. 

Logicamente que um sistema profissional tem muito mais funções. Citei apenas o básico.

Recomenda-se a leitura do "Algoritmos Estruturados - 3ª Ed. 2011 - Farrer,Harry"

Muito bom livro, quem quer programar mesmo de verdade, precisa saber como funcionam os algorítimos em sua forma mais primitiva. Depois recomendo um bom livro sobre arquitetura de computadores, tal como:

Fundamentos da Programação de Computadores - 3ª Ed. 2012 Ascencio,Ana Fernanda GomesCampos,Edilene Aparecida Veneruchi

Finalmente procure um bom livro de MS-SQL Express, com estas leituras você verá que é bem fácil programar.

Se quiser ir mais rápido, veja as dicas do site, tire as dúvidas no fórum e no nosso grupo de Whatsapp.