Como iniciar e migrar para o TLPP?

Olá dev, anteriormente já esclarecemos que o AdvPL não morrerá. Depois, lhe apresentamos as vantagens de programar em TLPP. Agora, te convidamos através dessa leitura a dar os primeiros passos com TLPP em sua jornada profissional.

Antes de começar, temos que dar uma informação muito importante. Não é preciso migrar às pressas suas rotinas já desenvolvidas em AdvPL para TLPP, pois o TLPP foi criado para facilitar a vida do desenvolvedor e, portanto, não há nenhuma exigência técnica para que essa migração seja feita com urgência e sobrecarregue as equipes de desenvolvimento. Logo pode-se adotar a seguinte estratégia:

1 — Para rotinas novas, já comece o desenvolvimento com TLPP;

2 — Migre inicialmente algum trecho de antigos programas que necessitem dos recursos do TLPP, criando componentes em TLPP e sendo executados pelas antigas rotinas em AdvPL;

3 — E caso haja o interesse, vá migrando aos poucos as demais rotinas, sem pressa e sem atropelo.

Bom, dito isso, seguimos.

Considerando que você já desenvolva em AdvPL e tenha um ambiente de desenvolvimento com VSCode configurado, a primeira coisa a se fazer é obter os arquivos de includes do TLPP e tlppCore. Para isso, só seguir os passos descritos em: Ambiente de compilação do TLPP.

Esse passo é fundamental, pois as “includes” são disponibilizadas na expedição do AppServer + tlpp.rpo e sem elas você não poderá fazer uso de muitos recursos.

Sempre que atualizar o binário ou o tlpp.rpo essa etapa precisa ser refeita.

Após a extração dos “includes”, devemos copiá-los para o diretório já configurado no VSCode (onde as demais “includes” já estão), ou adicionar a pasta onde estão os “includes” recém extraídos na configuração mencionada. Escolha com sabedoria, caro padawan.

Agora já podemos então iniciar nosso primeiro programa em TLPP e como todo início criaremos o bom e velho “Olá Mundo” ou “Hello World”.

Então vamos à primeira diferença, pois para acessar os recursos da linguagem é preciso utilizar a extensão [tlpp], logo pelo VSCode iremos criar um arquivo de nome “olaMundo.tlpp”.

Agora adicionaremos o seguinte conteúdo:

namespace meu.exemplo

/*
Podemos usar a sintaxe abaixo em substituição à clássica:
User Function Ola_Mundo_em_TLPP()
*/
function U_Ola_Mundo_em_TLPP()
  conout( "Olá Mundo!", "meu primeiro programa em TLPP" )
return

Podemos testar essa função diretamente pela execução Crtl+F5 do VSCode, informando a função:

meu.exemplo.U_Ola_Mundo_em_TLPP

Ou, podemos chamar através de um programa:

meu.exemplo.U_Ola_Mundo_em_TLPP()

Note que já de início utilizamos dois recursos úteis em TLPP: Nomes longos e Namespace.

Por ora basta sabermos que nomes longos podem ser aplicados para funções, classes, métodos, variáveis e propriedades de objetos com o limite máximo de 255 caracteres.

E sobre namespace iremos abordar mais adiante em novo artigo citando suas vantagens e aplicações práticas.

E programar orientado a objetos? TLPP ajuda?

Sim, ajuda e muito, falaremos agora de Class V2

Class V2

Avançando nos estudos chegamos ao desenvolvimento orientado a objetos, e é aqui que temos um grande ganho de recursos em relação ao AdvPL. Porém, aqui, iremos abordar somente os detalhes importantes para que você não tropece nas pequenas pedras.

Para acessar todos os recursos corretamente você deverá importar a biblioteca do TLPP object, assim:

#include "tlpp-object.th"

Também é possível importando indiretamente, pois em seu fonte você irá importar a biblioteca do tlppCore, assim:

#include "tlpp-core.th"

Nesse caso, lembre-se que estará importando indiretamente não somente a biblioteca de objetos, mas também outras bibliotecas do tlppCore, como por exemplo o tlpp-REST. Logo, somente utilize esse modo caso você também tenha interesse nas demais bibliotecas.

Importante! A importação do include mencionado acima deve vir antes das importações em CH, seja ela a [msobject.ch] ou as generalistas [totvs.ch] e [protheus.ch] conforme abaixo:

#include "tlpp-core.th"
#include "totvs.ch"

Sem seguir esse detalhe você não terá acesso, por exemplo, aos modificadores de acesso, ou seja, indicar que um método ou propriedade possa ser: “private”, “public” ou “protected”, ou então o uso de Interfaces, Sobrecarga de Operadores e outros recursos interessantes.

Para aprender mais sobre classes em TLPP, recomendamos que faça a leitura da documentação no TDN: [CLASS V2].

Agora, se você preferir que façamos um artigo mostrando detalhes dos recursos, coloque nos comentários: “#Artigo Classes”.

Migrando “.prw” para “.tlpp”

A essa altura você deve estar se perguntando se é possível apenas renomear um código-fonte em .prw para .tlpp e apenas compilar, certo?

Bom, é possível? É, sim, bem plausível!

Mas, é 100% garantido que apenas renomeando eu não tenha problemas? Infelizmente não podemos garantir que em 100% dos casos isso funcionará, pois existem alguns pontos de atenção que deve-se considerar ao optar por esse caminho, são eles:

Tipagem

Embora AdvPL não tenha tipagem, muitos código-fontes em AdvPL foram escritos “tipando” variáveis com nomes distintos de tipos de dados que foram implementadas na tipagem do TLPP.

Existirão muitos casos, como as string ou as boolean, que tem uma identificação diferente em TLPP. Para se referir a estes tipos, você deve utilizar as character ou as logical. Aí vai funcionar direitinho.

Portanto, antes de renomear seu fonte para “.tlpp”, revise a tipagem já feita em seu código para seguir corretamente os tipos nativos do TLPP conforme documentado em: Tipos Nativos

Nomes longos

Um ponto que parece inofensivo em AdvPL são os nomes de funções, classes e métodos estarem limitados a 10 caracteres.

Em teoria isso não deveria ser um problema, pois você estará aumentando essa capacidade para 255 caracteres ao utilizar TLPP, porém existem casos em AdvPL que o desenvolvedor possui um falso positivo.

Como assim?

Irei explicar melhor:

Imagine que em seu fonte em AdvPL você tenha criado uma função conforme abaixo:

function myFunction001()
  /* code */
return

Note que o nome da função tem 13 caracteres, o que não gera erro de compilação, porém ao compilar como AdvPL o nome registrado no repositório de funções será de apenas 10 caracteres, ou seja: myFunction().

Agora as demais implementações por não conhecerem o código-fonte original e apenas conhecerem a assinatura que “funciona”, fazem a chamada “corretamente” como myFunction(). E digo corretamente entre aspas porque só é correto porque você utiliza o AdvPL.

Por algum motivo, esse caso acima não é raro no meio de desenvolvedores AdvPL.

Bom, se o fonte original for migrado para “.tlpp”, ao compilar a função será registrada com os 13 caracteres, ou seja, myFunction001()

Porém, agora os demais fontes não farão mais a chamada “correta”, pois podemos ter dois cenários:

• Se os repositórios não forem trocados, a antiga função ainda existirá mas, será uma versão obsoleta de seu fonte e caso você implemente lógicas novas elas simplesmente não serão acionadas, pois os demais fontes ainda fazem a chamada ao myFunction() e não ao myFunction001(). Esse cenário é bem difícil de descobrir e muito provavelmente você decidirá reconstruir os repositórios desde o início e com isso ocorrerá o próximo cenário.
• Os repositórios foram trocados por novos e reconstruídos com seus fontes, nesse caso a antiga função não existirá mais e você obterá “Cannot find function” em tempo de execução de suas rotinas. Agora você terá que modificar todas as chamadas que se referiam à myFunction() e passar a se referir à myFunction001(), solucionando seu problema.

Portanto, caro colega, sugiro revisar os nomes das funções primeiro antes de efetuar a migração da extensão.

Outra boa prática é obter RPO novo no portal e recompilar todos os seus fontes para terem somente as novas versões de seus programas.

MVC

O Model View Controller é um recurso do Framework do Protheus, e nesse caso temos dois cenários, sendo:

Protheus com releases anteriores à 12.1.2410, infelizmente esse fonte não poderá ser convertido em TLPP, pois o MVC até essa release utiliza o recurso de Static Call na qual foi bloqueado em TLPP, pois uma função Static somente poderá ser executada através de uma função ou método que esteja no mesmo código-fonte.

Protheus com release a partir de 12.1.2410, o MVC já é suportado em TLPP, porém não poderemos apenas modificar a extensão e recompilar. Nesse caso, será necessário uma refatoração de seu código, pois você deverá retirar o uso de Static Function e começar a usar o recurso de Namespace do TLPP.

Para entender melhor esse processo, nosso amigo e dev Daniel Mendes escreveu um artigo bem interessante: TLPP no Protheus

Aconselhamos a sua leitura, além, claro, de atualizar seu ambiente Protheus!

Enfim, seus primeiros passos já podem ser dados sem maiores medos e estaremos aqui para auxiliá-los nessa caminhada.

Contem conosco e desejamos que aproveite o TLPP!