<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>artigos on Abapinho</title><link>https://abapinho.com/categories/artigos/</link><description>Recent content in artigos on Abapinho</description><generator>Hugo -- gohugo.io</generator><language>pt</language><copyright>&amp;copy;2009-2026 Nuno Godinho</copyright><lastBuildDate>Mon, 27 Apr 2026 09:00:00 +0000</lastBuildDate><atom:link href="https://abapinho.com/categories/artigos/index.xml" rel="self" type="application/rss+xml"/><item><title>Odeio números mágicos</title><link>https://abapinho.com/2026/04/odeio-numeros-magicos/</link><pubDate>Mon, 27 Apr 2026 09:00:00 +0000</pubDate><guid>https://abapinho.com/2026/04/odeio-numeros-magicos/</guid><description>&lt;p>Quem trabalha em SAP acha normal que tudo seja representado por números e códigos obscuros que não significam nada. Mas não tem de ser assim. Pára com isso! Cria códigos que os seres humanos entendam por favor.&lt;/p></description></item><item><title>Define uma ponto de partida para o ATC</title><link>https://abapinho.com/2025/10/atc-baseline/</link><pubDate>Mon, 20 Oct 2025 09:00:00 +0100</pubDate><guid>https://abapinho.com/2025/10/atc-baseline/</guid><description>&lt;p>Sabes que podes definir um ponto de partida para o ATC e que isso te permite correr o ATC em código legacy?&lt;/p></description></item><item><title>Kintsugi</title><link>https://abapinho.com/2025/10/kintsugi/</link><pubDate>Mon, 13 Oct 2025 09:00:00 +0100</pubDate><guid>https://abapinho.com/2025/10/kintsugi/</guid><description>&lt;p>Quando no Japão se quebra um objecto de porcelana, às vezes, em vez de o deitarem fora, remendam-no. Mas não remendam de qualquer maneira; É com ouro. Esta técnica chama-se Kintsugi.&lt;/p></description></item><item><title>Porquê sempre MODIFY?</title><link>https://abapinho.com/2025/10/porque-modify/</link><pubDate>Mon, 06 Oct 2025 09:00:00 +0100</pubDate><guid>https://abapinho.com/2025/10/porque-modify/</guid><description>&lt;p>É hábito em ABAP usar o MODIFY em vez de INSERT e UPDATE. Costumas fazê-lo? Explica-me porquê. É preguiça? É medo? É na base do &amp;ldquo;já agora&amp;rdquo;? Ou é mais na base do &amp;ldquo;caga nisso&amp;rdquo;?&lt;/p></description></item><item><title>Sobre janelas partidas</title><link>https://abapinho.com/2025/06/sobre-janelas-partidsa/</link><pubDate>Mon, 09 Jun 2025 09:00:00 +0100</pubDate><guid>https://abapinho.com/2025/06/sobre-janelas-partidsa/</guid><description>&lt;p>A teoria das janelas partidas diz que, se uma janela de um prédio for partida e não for reparada rapidamente, as pessoas ficam tentadas a atirar pedras e partir as outras janelas.&lt;/p></description></item><item><title>É normal não se acertar à primeira</title><link>https://abapinho.com/2025/04/nao-se-acerta-a-primeira/</link><pubDate>Mon, 07 Apr 2025 09:00:00 +0000</pubDate><guid>https://abapinho.com/2025/04/nao-se-acerta-a-primeira/</guid><description>&lt;p>No mundo do ABAP é costume fazer-se uma vez e nunca mais mexer. Como ficou, ficará para sempre. Que grande disparate.&lt;/p></description></item><item><title>Onde? Quem? O quê? Como?</title><link>https://abapinho.com/2025/03/onde-quem-oque-como/</link><pubDate>Mon, 17 Mar 2025 09:00:00 +0000</pubDate><guid>https://abapinho.com/2025/03/onde-quem-oque-como/</guid><description>&lt;p>Pediram-te para criar uma nova funcionalidade. Estás pronto para a construir. Mas aguenta os cavalos. Antes de começares sugiro que encontres resposta a algumas perguntas. Encontrares uma boa resposta para cada uma delas é fundamental para garantir que o que vais construir fica sólido e elegante.&lt;/p></description></item><item><title>No Eclipse ADT não mudas constantemente de contexto</title><link>https://abapinho.com/2024/04/eclipse-adt-mudanca-de-contexto/</link><pubDate>Mon, 01 Apr 2024 09:00:00 +0000</pubDate><guid>https://abapinho.com/2024/04/eclipse-adt-mudanca-de-contexto/</guid><description>&lt;p>Cada vez que trocas de contexto, perdes ligeiramente o fio à meada. É a natureza humana. Portanto, quanto menos o fizeres, melhor.&lt;/p></description></item><item><title>No Eclipse ADT o compilador não é preguiçoso</title><link>https://abapinho.com/2024/03/eclipse-adt-compilacao-constante/</link><pubDate>Mon, 25 Mar 2024 09:00:00 +0000</pubDate><guid>https://abapinho.com/2024/03/eclipse-adt-compilacao-constante/</guid><description>&lt;p>Ainda usas o SAPGUI em vez do Eclipse ADT? Prepara-te para ser achincalhado.&lt;/p></description></item><item><title>As linguagens moldam o pensamento</title><link>https://abapinho.com/2024/02/linguagem-molda-pensamento/</link><pubDate>Mon, 05 Feb 2024 09:00:00 +0000</pubDate><guid>https://abapinho.com/2024/02/linguagem-molda-pensamento/</guid><description>&lt;p>Li algures que os matemáticos orientais tendem a resolver um tipo de problemas matemáticos diferente do tipo de problemas que os matemáticos ocidentais resolvem.&lt;/p></description></item><item><title>YAGNI</title><link>https://abapinho.com/2023/10/yagni/</link><pubDate>Mon, 16 Oct 2023 09:00:00 +0100</pubDate><guid>https://abapinho.com/2023/10/yagni/</guid><description>&lt;p>&lt;em>You Ain&amp;rsquo;t Gonna Need It&lt;/em> em português quer dizer &lt;em>Faz o que quiseres, mas não digas que eu não te avisei&lt;/em>. Estou a brincar. Não é bem isso.&lt;/p></description></item><item><title>Prefixos fixos</title><link>https://abapinho.com/2023/05/prefixos-fixos/</link><pubDate>Mon, 01 May 2023 09:00:00 +0100</pubDate><guid>https://abapinho.com/2023/05/prefixos-fixos/</guid><description>&lt;p>É muito fácil fazer asneira com os nomes dos objectos em SAP. Encontrei recentemente uma forma de minimizar esse problema: definir regras para fixar prefixos por pacote para determinados tipos de objecto.&lt;/p></description></item><item><title>Empacoto tudo o que mexe</title><link>https://abapinho.com/2023/04/empacoto-tudo/</link><pubDate>Mon, 03 Apr 2023 09:00:00 +0100</pubDate><guid>https://abapinho.com/2023/04/empacoto-tudo/</guid><description>&lt;p>Eu empacoto obsessivamente tudo o que mexe.&lt;/p></description></item><item><title>Undo com abapGit</title><link>https://abapinho.com/2023/03/undo-with-abapgit/</link><pubDate>Mon, 06 Mar 2023 09:00:00 +0000</pubDate><guid>https://abapinho.com/2023/03/undo-with-abapgit/</guid><description>&lt;p>Sabias que podes finalmente fazer alterações radicais num desenvolvimento sem medos
porque há uma forma simples de desfazer todas essas alterações?&lt;/p></description></item><item><title>Os 3 pais das excepções</title><link>https://abapinho.com/2023/02/exception-parents/</link><pubDate>Mon, 20 Feb 2023 09:00:00 +0000</pubDate><guid>https://abapinho.com/2023/02/exception-parents/</guid><description>&lt;p>As excepções OO têm sempre de ter um pai. Têm sempre de herdar de alguém. E o ABAP dá 3 hipóteses, cada uma tratada de forma diferente pelo compilador.&lt;/p></description></item><item><title>Desmamar a SE24</title><link>https://abapinho.com/2022/10/desmamar-a-se24/</link><pubDate>Mon, 03 Oct 2022 09:00:00 +0100</pubDate><guid>https://abapinho.com/2022/10/desmamar-a-se24/</guid><description>&lt;p>A transacção SE24 esconde parcialmente o código atrás de um GUI. Supostamente é para nosso benefício. Mas o que aparenta ser conveniente torna-se na realidade muito limitativo.&lt;/p></description></item><item><title>Livrei-me finalmente dos prefixos</title><link>https://abapinho.com/2022/09/prefixos/</link><pubDate>Mon, 12 Sep 2022 09:09:00 +0100</pubDate><guid>https://abapinho.com/2022/09/prefixos/</guid><description>&lt;p>Demorei muitos anos mas finalmente livrei-me do raio dos prefixos.&lt;/p></description></item><item><title>Os teus utilizadores conseguem hackar o teu SQL?</title><link>https://abapinho.com/2022/03/sql-injection/</link><pubDate>Mon, 21 Mar 2022 09:00:00 +0000</pubDate><guid>https://abapinho.com/2022/03/sql-injection/</guid><description>&lt;p>Tens a certeza de que o teu SQL é à prova de bala?&lt;/p></description></item><item><title>Um programa é um animal</title><link>https://abapinho.com/2022/02/animal/</link><pubDate>Mon, 28 Feb 2022 09:00:00 +0000</pubDate><guid>https://abapinho.com/2022/02/animal/</guid><description>&lt;p>Quando os programas estão mal feitos por terem código duplicado, se os reescrevemos ficam mais curtos. Mas se, pelo contrário, estiverem mal feitos por não estarem devidamente estruturados em várias classes com vários métodos, podem ficar bem mais longos se os reescrervemos de acordo com as boas prácticas.&lt;/p></description></item><item><title>Sê polígamo</title><link>https://abapinho.com/2022/02/poligamia/</link><pubDate>Mon, 21 Feb 2022 09:00:00 +0000</pubDate><guid>https://abapinho.com/2022/02/poligamia/</guid><description>&lt;p>A maior parte dos programadores ABAP são como os cisnes. Quando casam com o ABAP é para sempre e são-lhe eternamente fiéis.&lt;/p></description></item><item><title>Adeus Wordpress, olá Jamstack</title><link>https://abapinho.com/2022/01/jamstack/</link><pubDate>Fri, 21 Jan 2022 09:00:00 +0000</pubDate><guid>https://abapinho.com/2022/01/jamstack/</guid><description>&lt;p>Depois de mais de 10 anos a usar &lt;a href="https://wordpress.org/">Wordpress&lt;/a>, o mundo evoluiu e o Abapinho decidiu evoluir com ele.&lt;/p></description></item><item><title>Se amas o próximo, evita o CLEAR</title><link>https://abapinho.com/2021/12/evita-o-clear/</link><pubDate>Mon, 13 Dec 2021 09:00:59 +0000</pubDate><guid>https://abapinho.com/2021/12/evita-o-clear/</guid><description>&lt;p>Demasiadas regressões acontecem porque alguém se esquece de fazer CLEAR ou de não fazer CLEAR a uma variável.&lt;/p></description></item><item><title>As duplas negativas dos RANGEs</title><link>https://abapinho.com/2021/07/as-duplas-negativas-dos-ranges/</link><pubDate>Mon, 26 Jul 2021 09:00:15 +0000</pubDate><guid>https://abapinho.com/2021/07/as-duplas-negativas-dos-ranges/</guid><description>&lt;p>Os RANGEs têm propriedades interessantes.&lt;/p></description></item><item><title>SELECT WHERE field IN (*, x)</title><link>https://abapinho.com/2021/07/select-where-field-in-a-b/</link><pubDate>Mon, 19 Jul 2021 09:00:53 +0000</pubDate><guid>https://abapinho.com/2021/07/select-where-field-in-a-b/</guid><description>&lt;p>Vamos por partes.&lt;/p>
&lt;p>Imagina um cenário em que tens uma tabela de parametrização com vários níveis de detalhe que podem ou não estar definidos:&lt;/p>
&lt;ol>
&lt;li>
&lt;p>BUKRS (empresa)&lt;/p>
&lt;/li>
&lt;li>
&lt;p>WERKS (plant)&lt;/p>
&lt;/li>
&lt;li>
&lt;p>LGORT (depósito)&lt;/p>
&lt;/li>
&lt;/ol>
&lt;p>Quando um dos campos está vazio, é um wildcard, ou seja, é válido para todos os valores.&lt;/p></description></item><item><title>Adeus Evernote, olá Obsidian</title><link>https://abapinho.com/2020/12/obsidian/</link><pubDate>Thu, 17 Dec 2020 09:00:33 +0000</pubDate><guid>https://abapinho.com/2020/12/obsidian/</guid><description>&lt;p>Depois de 10 anos a usar o Evernote, este ano comecei a procurar alternativas. No início o Evernote era fantástico. Mas parou no tempo e deixou-se ultrapassar. Entretanto apareceram tantos conceitos novos: &lt;a href="https://joelhooks.com/digital-garden">jardins digitais&lt;/a>, &lt;em>&lt;a href="https://www.youtube.com/watch?v=n7xrHPpTWJ0">backlinks&lt;/a>&lt;/em> , &lt;em>&lt;a href="https://en.wikipedia.org/wiki/Zettelkasten">Zettelkasten&lt;/a>&lt;/em> , &lt;em>&lt;a href="https://notes.andymatuschak.org/Evergreen_notes">Evergreen notes&lt;/a>&lt;/em> , &lt;a href="https://www.youtube.com/watch?v=WUq8Pun28FI">MOCs&lt;/a>, etc. E o Evernote lá continua, igual ao que sempre foi, condicionando-nos a &lt;a href="https://www.linkingyourthinking.com">tirar notas em vez de criar notas&lt;/a>.&lt;/p></description></item><item><title>Adeus Evernote, olá Notion</title><link>https://abapinho.com/2020/07/notion/</link><pubDate>Wed, 15 Jul 2020 11:20:11 +0000</pubDate><guid>https://abapinho.com/2020/07/notion/</guid><description>&lt;p>&lt;a href="https://abapinho.com/en/2010/04/evernote/">Um dos primeiros artigos do Abapinho foi sobre o Evernote&lt;/a>. Ou melhor, foi sobre a importância de tomar notas. Mas nele eu explicava como uso o Evernote para tirar essas notas.&lt;/p>
&lt;p>Parece mentira mas passaram 10 anos. 10 anos a tirar notas no Evernote. Infelizmente parece que quem faz o Evernote deve ter parado de tirar notas há muitos anos porque o Evernote pouco evoluiu desde que o adoptei. Aliás, na versão iOS, piorou. Já lá vão 10 anos e ainda não conseguiram sequer (tentar?) implementar uma forma decente para editar tabelas. Burros.&lt;/p></description></item><item><title>O caminho mais curto para ir de SELECT a RANGE</title><link>https://abapinho.com/2019/11/o-caminho-mais-curto-para-ir-de-select-a-range/</link><pubDate>Wed, 13 Nov 2019 10:21:31 +0000</pubDate><guid>https://abapinho.com/2019/11/o-caminho-mais-curto-para-ir-de-select-a-range/</guid><description>&lt;p>Hoje debruçamo-nos sobre como tentar optimizar o código para transformar um SELECT num RANGE.&lt;/p></description></item><item><title>A árvore dos pacotes Z - Uma proposta modesta</title><link>https://abapinho.com/2019/10/arvore-de-pacotes-z/</link><pubDate>Wed, 23 Oct 2019 09:00:46 +0000</pubDate><guid>https://abapinho.com/2019/10/arvore-de-pacotes-z/</guid><description>&lt;p>Quem lê o Abapinho sabe que eu defendo o uso e abuso do &lt;a href="https://abapinho.com/2014/07/pacotes-2-0/">ABAP Package Concept&lt;/a>. Hoje em dia a primeira coisa que eu faço quando começo um desenvolvimento novo é criar-lhe um pacote encapsulado que guardará todos os seus objectos que, nos casos mais complexos, será um pacote &amp;ldquo;Main&amp;rdquo; ainda subdividido em vários sub-pacotes.&lt;/p>
&lt;p>Fica aqui a minha modesta proposta para criar uma árvore de pacotes Z que ajude a organizar aquilo que é normalmente uma confusão danada.&lt;/p></description></item><item><title>Guarda dados XML numa ST (Simple Transformation)</title><link>https://abapinho.com/2019/04/guarda-dados-xml-numa-st-simple-transformation/</link><pubDate>Mon, 01 Apr 2019 09:00:59 +0000</pubDate><guid>https://abapinho.com/2019/04/guarda-dados-xml-numa-st-simple-transformation/</guid><description>&lt;p>No outro dia estava a aprender sobre ST (Simple Transformations) e lembrei-me que, ainda que tenha sido desenvolvida para transformar dados, é uma forma práctica de guardar dados XML.&lt;/p>
&lt;p>Temos o seguinte XML:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span> &lt;span style="color:#000">&amp;lt;cocktails&amp;gt;&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &amp;lt;&lt;span style="color:#000">cocktail&lt;/span> &lt;span style="color:#00f">id&lt;/span>=&amp;amp;&lt;span style="color:#000">quot&lt;/span>;&lt;span style="color:#00f">gt&lt;/span>&amp;amp;&lt;span style="color:#000">quot&lt;/span>; &lt;span style="color:#000">nome&lt;/span>=&amp;amp;&lt;span style="color:#000">quot&lt;/span>;&lt;span style="color:#000">Gin&lt;/span> &lt;span style="color:#000">Tonic&lt;/span>&amp;amp;&lt;span style="color:#000">quot&lt;/span>;/&amp;gt;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &amp;lt;&lt;span style="color:#000">cocktail&lt;/span> &lt;span style="color:#00f">id&lt;/span>=&amp;amp;&lt;span style="color:#000">quot&lt;/span>;&lt;span style="color:#000">ws&lt;/span>&amp;amp;&lt;span style="color:#000">quot&lt;/span>; &lt;span style="color:#000">nome&lt;/span>=&amp;amp;&lt;span style="color:#000">quot&lt;/span>;&lt;span style="color:#000">Whiskey&lt;/span> &lt;span style="color:#000">Sour&lt;/span>&amp;amp;&lt;span style="color:#000">quot&lt;/span>;/&amp;gt;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &amp;lt;&lt;span style="color:#000">cocktail&lt;/span> &lt;span style="color:#00f">id&lt;/span>=&amp;amp;&lt;span style="color:#000">quot&lt;/span>;&lt;span style="color:#000">cl&lt;/span>&amp;amp;&lt;span style="color:#000">quot&lt;/span>; &lt;span style="color:#000">nome&lt;/span>=&amp;amp;&lt;span style="color:#000">quot&lt;/span>;&lt;span style="color:#000">Campari&lt;/span> &lt;span style="color:#000">Laranja&lt;/span>&amp;amp;&lt;span style="color:#000">quot&lt;/span>;/&amp;gt;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#000">&amp;lt;/cocktails&amp;gt;&lt;/span>&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div></description></item><item><title>Quando o código cheira mal</title><link>https://abapinho.com/2019/02/quando-o-codigo-cheira-mal/</link><pubDate>Mon, 25 Feb 2019 09:00:12 +0000</pubDate><guid>https://abapinho.com/2019/02/quando-o-codigo-cheira-mal/</guid><description>&lt;p>É frequente ao programar começar a sentir um cheiro desagradável. Normalmente não consigo logo identificar o que é. Sinto apenas uma leve mas incómoda fragrância. À medida que vou cheirando com mais propósito vou conseguindo perceber de onde vem. Mas mesmo nessa altura, muitas vezes ainda não me é perfeitamente claro porque é que aquele cheiro dali vem.&lt;/p></description></item><item><title>Não é para reutilizar que se encapsula</title><link>https://abapinho.com/2019/02/nao-e-para-reutilizar-que-se-encapsula/</link><pubDate>Mon, 18 Feb 2019 09:00:18 +0000</pubDate><guid>https://abapinho.com/2019/02/nao-e-para-reutilizar-que-se-encapsula/</guid><description>&lt;p>Desde 1998 que oiço colegas ABAPers dizerem que não vale a pena meter determinado código numa função ou método porque não lhes parece que este vá tornar a ser reutilizado. E lá vão continuando na SE38 a fazer os seus reports cheios de includes.&lt;/p>
&lt;p>A ideia de que a principal razão para encapsular código é poder reutilizá-lo é um dos maiores mal entendidos da história do nosso planeta.&lt;/p></description></item><item><title>Refactorizarás: Extrair método</title><link>https://abapinho.com/2019/01/refactorizacao-extrair-metodo/</link><pubDate>Wed, 02 Jan 2019 09:00:23 +0000</pubDate><guid>https://abapinho.com/2019/01/refactorizacao-extrair-metodo/</guid><description>&lt;p>No mundo do SAP, o código ABAP onde cai é onde fica.&lt;/p>
&lt;p>Num dia o Manel faz uma coisa mal porque está com pressa ou não sabe fazer melhor. Um ano depois pedem ao António para fazer uma pequena alteração. O António vê a asneira do Manel mas não a melhora porque, por alguma razão, no mundo do SAP, alterar código que está a funcionar, por muito mau que seja, é tabu. Em vez disso, acrescenta o seu código ao já existente de forma geralmente acrítica.&lt;/p>
&lt;p>Esta atitude, quando adoptada por todos, contribui para uma inevitável erosão do código de um sistema que, após alguns anos, se tornará ingerível.&lt;/p>
&lt;p>No meu entender, isso está errado e vai contra os interesses do cliente. Aliás, mesmo se o cliente não quiser que se mexa no código antigo&amp;hellip; eu mexo. Quem é ele para me dizer como é que se programa?&lt;/p></description></item><item><title>Testa função com dados de teste carregados por ficheiro</title><link>https://abapinho.com/2018/06/testa-funcao-com-ficheiro/</link><pubDate>Mon, 04 Jun 2018 09:00:33 +0000</pubDate><guid>https://abapinho.com/2018/06/testa-funcao-com-ficheiro/</guid><description>&lt;p>A transacção SE37 permite testar módulos de função. Por vezes esses módulos de função utilizam tabelas. Pode dar-se o caso de precisarmos de carregar muitas linhas de dados de teste em uma ou mais dessas tabelas.&lt;/p>
&lt;p>Aqui fica um truque para o conseguir fazer a partir de um ficheiro.&lt;/p></description></item><item><title>Serialização - Clona a Dolly em ABAP</title><link>https://abapinho.com/2017/10/serializacao-abap/</link><pubDate>Mon, 30 Oct 2017 09:00:20 +0000</pubDate><guid>https://abapinho.com/2017/10/serializacao-abap/</guid><description>&lt;p>Este artigo é da autoria de José Vília.&lt;/p>
&lt;p>A ovelha Dolly está no ABAP e eu não sabia.&lt;/p>
&lt;p>Depois de criar uma instância de uma classe, gostava de partilhá-la com outro programa totalmente independente para que este outro programa posso usá-la como se a tivesse instanciado.&lt;/p>
&lt;p>Como se de uma fábrica de ovelhas Dollies se tratasse, o ABAP pode utilizar serialização para resolver o problema.&lt;/p></description></item><item><title>Protocolo de erros da ALV Grid</title><link>https://abapinho.com/2017/09/alv-grid-built-in-error-protocol/</link><pubDate>Mon, 11 Sep 2017 09:00:20 +0000</pubDate><guid>https://abapinho.com/2017/09/alv-grid-built-in-error-protocol/</guid><description>&lt;p>A lei do menor esforço, esse grande axioma da Humanidade, tem, no mundo da programação, a particularidade de, em muitos casos, acabar por ser simplesmente a lei do esforço adiado. Porque é muito provável que algo que tenha sido desenvolvido de acordo com esta lei venha mais tarde a precisar de um grande esforço extra. Seja dos utilizadores que vão utilizar esse algo ou dos programadores que mais tarde terão de o manter.&lt;/p>
&lt;p>Atire a primeira pedra aquele que não se deixou guiar por esta lei ao desenvolver este ou aquele programas.&lt;/p>
&lt;p>Eu não atiro.&lt;/p></description></item><item><title>PlantUML - Finalmente o UML dá para usar</title><link>https://abapinho.com/2017/09/plantuml-finalmente-o-uml-da-para-usar/</link><pubDate>Tue, 05 Sep 2017 09:00:59 +0000</pubDate><guid>https://abapinho.com/2017/09/plantuml-finalmente-o-uml-da-para-usar/</guid><description>&lt;p>&lt;strong>Prólogo&lt;/strong>&lt;/p>
&lt;p>Quando digo que gosto de usar diagramas de classes UML para documentar o meu código as pessoas acham que sou maluco.&lt;/p>
&lt;p>&lt;strong>Introdução&lt;/strong>&lt;/p>
&lt;p>O UML ganhou má fama porque as pessoas pensam que primeiro se faz o diagrama de classes todo em UML e só depois o programa. Mas isso era em 1996, quando se achava que a primeira coisa a fazer era o desenho técnico todo, mesmo que na práctica ninguém nunca o fizesse.&lt;/p>
&lt;p>Hoje em dia felizmente já não temos vergonha de dizer que o próprio acto de programar é já em si uma forma de desenhar.&lt;/p></description></item><item><title>Dantes o ABAP gostava de inverter datas</title><link>https://abapinho.com/2017/02/dantes-abap-gostava-inverter-datas/</link><pubDate>Mon, 27 Feb 2017 09:00:40 +0000</pubDate><guid>https://abapinho.com/2017/02/dantes-abap-gostava-inverter-datas/</guid><description>&lt;p>Todos os dias o ABAP me revela coisas novos. Às vezes coisas que mais valia eu nem saber que existem. Como esta.&lt;/p>
&lt;p>A tabela T056P tem um campo com uma data. Fazendo um SELECT a esta tabela filtrando pela data não conseguia obter nada de jeito. Mas o código parecia correcto. Na SE16N descobri que o intervalo de datas também não funcionava conforme esperado: só apresentava resultados quando a data final era colocada no LOW e a inicial no HIGH. Bizarro.&lt;/p></description></item><item><title>A transacção que queria chamar outra e não podia</title><link>https://abapinho.com/2017/02/a-transaccao-que-queria-chamar-outra-e-nao-podia/</link><pubDate>Mon, 06 Feb 2017 09:00:24 +0000</pubDate><guid>https://abapinho.com/2017/02/a-transaccao-que-queria-chamar-outra-e-nao-podia/</guid><description>&lt;p>O Manelinho criou a transacção ZFB01 associada ao programa ZFB01 que faz lá umas coisas e depois faz CALL TRANSACTION à FB01. A seguir veio o Joãozinho e correu a transacção ZFB01.&lt;/p>
&lt;p>Conseguiu começar a corrê-la porque tem permissões para a transacção ZFB01. Mas a meio teve um erro porque não tem permissões para a transacção FB01.&lt;/p>
&lt;p>Tanto o Manelinho como o Joãozinho sabiam que os administradores de sistema nunca na vida deles darão ao Joãozinho autorizações para correr a FB01.&lt;/p></description></item><item><title>Obtém o texto mais profundo de cadeia de excepções</title><link>https://abapinho.com/2017/01/texto-mais-profundo-de-cadeia-de-excepcoes/</link><pubDate>Mon, 16 Jan 2017 10:34:04 +0000</pubDate><guid>https://abapinho.com/2017/01/texto-mais-profundo-de-cadeia-de-excepcoes/</guid><description>&lt;p>Nos dias que correm se não estás a usar objectos &lt;a href="https://abapinho.com/2012/10/mariquinhas-pe-de-salsa/">és totó&lt;/a>.&lt;/p>
&lt;p>Se usas objectos, espero que estejas a seguir a &lt;a href="https://abapinho.com/2015/01/usaras-classes-de-excepcao/">boa práctica&lt;/a> de usar classes de excepções.&lt;/p>
&lt;p>E se usas classes de excepção é bom que entendas a melhor forma de as usar, particularmente as &lt;a href="https://abapinho.com/2015/02/cadeias-de-excepcoes/">vantagens de as encadear&lt;/a>.&lt;/p>
&lt;p>Com tudo isto esclarecido, chegamos ao que nos traz aqui hoje. No artigo sobre &lt;a href="https://abapinho.com/2015/02/cadeias-de-excepcoes/">cadeias de excepções&lt;/a> mostrei como, para obter o texto da excepção mais profunda, a que foi inicialmente espoletada, se pode fazer um DO WHILE:&lt;/p></description></item><item><title>Como devolver um REF TO data sem fazer asneira</title><link>https://abapinho.com/2017/01/devolver-ref-to-data/</link><pubDate>Mon, 02 Jan 2017 09:00:26 +0000</pubDate><guid>https://abapinho.com/2017/01/devolver-ref-to-data/</guid><description>&lt;p>Tenho usado cada vez mais referências em ABAP.&lt;/p>
&lt;p>Primeiro usava REF TO só para classes mas vou percebendo cada vez mais as vantagens de as usar também para estruturas de dados. Mas, tal como acontece em C++, há que ter cuidado quando se lida con referências para dados pois facilmente a coisa pode dar para o torto.&lt;/p>
&lt;p>Neste artigo tento mostrar como usar e como não usar o REF TO data. Comecemos por ver um exemplo de como não usar:&lt;/p></description></item><item><title>$PACOTES locais</title><link>https://abapinho.com/2016/11/pacotes-locais/</link><pubDate>Mon, 07 Nov 2016 09:00:37 +0000</pubDate><guid>https://abapinho.com/2016/11/pacotes-locais/</guid><description>&lt;p>Todos os objectos criados em SAP têm de estar associados a um pacote.&lt;/p>
&lt;p>Até recentemente, quando eu queria fazer um teste rápido criava o objecto no pacote $TMP. Tinha assim a garantia de este nunca viria a ser transportado.&lt;/p>
&lt;p>Mas por vezes há necessidade de criar coisas no sistema de desenvolvimento que não pretendemos nunca vir a transportar mas que queremos que lá existam eternamente. Como o ZSAPLINK e o abapGit, por exemplo. Mas se as associarmos todas as pacote $TMP fica uma valente confusão.&lt;/p></description></item><item><title>INSERT wa INTO itbl REFERENCE INTO ref. Bug?</title><link>https://abapinho.com/2016/10/reference-into-ref-bug/</link><pubDate>Mon, 03 Oct 2016 09:00:43 +0000</pubDate><guid>https://abapinho.com/2016/10/reference-into-ref-bug/</guid><description>&lt;p>Tenho usado cada vez mais referências em ABAP. Primeiro usava REF TO só para classes mas agora vou percebendo as vantagens de as usar também para estruturas de dados.&lt;/p>
&lt;p>Recentemente descobri um comportamento muito lamentável do seguinte comando:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">INSERT&lt;/span> &lt;span style="color:#000">wa&lt;/span> &lt;span style="color:#00f">INTO&lt;/span> &lt;span style="color:#000">itbl&lt;/span> &lt;span style="color:#00f">REFERENCE INTO&lt;/span> &lt;span style="color:#000">ref&lt;/span>.&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>Mas antes de me queixar sobre isso, dou um bocado de contexto.&lt;/p></description></item><item><title>Devíamos ser responsabilizados pela merda que fazemos</title><link>https://abapinho.com/2016/09/deviamos-ser-responsabilizados/</link><pubDate>Mon, 19 Sep 2016 09:00:33 +0000</pubDate><guid>https://abapinho.com/2016/09/deviamos-ser-responsabilizados/</guid><description>&lt;p>Se, ao construir uma ponte, um engenheiro civil fizer mal as contas a ponte cai. Mas não é só a ponte que cai. Esse engenheiro civil provavelmente também cai. Ou pelo menos desequilibra-se. Porque quando fez o projecto da ponte assinou-o, assumindo responsabilidade pelo que fez.&lt;/p>
&lt;p>Nós os programadores ABAP não temos esses problemas.&lt;/p></description></item><item><title>ABAP Code PushDown em HANA</title><link>https://abapinho.com/2016/07/abap-code-pushdown-on-sqlscript/</link><pubDate>Mon, 25 Jul 2016 09:00:10 +0000</pubDate><guid>https://abapinho.com/2016/07/abap-code-pushdown-on-sqlscript/</guid><description>&lt;p>[Artigo por Artur Moreira]&lt;/p>
&lt;p>A SAP introduziu a partir da versão 7.4 do ABAP o conceito de Code PushDown, que significa utilizar mais a base de dados para cálculos (agregação de dados, somas e vários cálculos prévios).&lt;/p></description></item><item><title>GROUP BY em LOOPs a tabelas internas</title><link>https://abapinho.com/2016/03/group-by-loops-tabelas-internas/</link><pubDate>Mon, 21 Mar 2016 09:00:57 +0000</pubDate><guid>https://abapinho.com/2016/03/group-by-loops-tabelas-internas/</guid><description>&lt;p>Todos já ordenamos tabelas internas e utilizamos a instrução AT NEW.
Mas a partir da 7.40, podemos utilizar GROUP BY no LOOP.&lt;/p>
&lt;p>É fantástico a capacidade de agrupamento em que os valores do registo processado no loop podem ser comparados, recorrendo a expressões e até métodos.&lt;/p>
&lt;p>O agrupamento é realizado num primeiro LOOP e pode ser processado a seguir. Experimentem o seguinte código e, tal como eu, ficarão impressionados com o caminho que o ABAP está a seguir.&lt;/p></description></item><item><title>SAABs ASSERTar à primeira?</title><link>https://abapinho.com/2016/03/saabs-assertar-primeira/</link><pubDate>Mon, 07 Mar 2016 09:00:13 +0000</pubDate><guid>https://abapinho.com/2016/03/saabs-assertar-primeira/</guid><description>&lt;p>&lt;em>Checkpoints&lt;/em> é uma &lt;em>framework&lt;/em> muito poderosa do ABAP que no entanto quase ninguém a usa. Porquê? Provavelmente pela mesma razão que quase ninguém ouve &lt;a href="https://pt.wikipedia.org/wiki/Sun_Ra">Sun Ra&lt;/a> e que quase ninguém sabe que o &lt;a href="https://pt.wikipedia.org/wiki/Frank_Zappa">Frank Zappa&lt;/a> tem 102 álbuns. Porque embora seja bom, é obscuro e pouco comercial. Os &lt;em>checkpoints&lt;/em> são, de facto bons e pouco comerciais. Mas deviam ser mais como o Mozart, que é bom e comercial.&lt;/p></description></item><item><title>STA Ticket System acelera a resolução de incidentes SAP</title><link>https://abapinho.com/2016/02/sta-ticket-system/</link><pubDate>Mon, 29 Feb 2016 09:00:53 +0000</pubDate><guid>https://abapinho.com/2016/02/sta-ticket-system/</guid><description>&lt;p>Hoje temos um convidado, Tamás Holics. Ele é dono da STA Consulting, uma empresa Húngara que criou 2 produtos muito interessantes para SAP. Neste artigo o Tamás apresenta o STA Ticket System.&lt;/p>
&lt;h2 id="o-problema">O Problema&lt;/h2>
&lt;p>Desperdiça-se muito tempo nos processos de teste e manutenção SAP dado que os relatórios de erros produzidos pelos utilizadores serem muitas vezes incompletos ou incorrectos. A resolução do problema reportado normalmente fica pendente até a informação estar toda completa. Ora como em boa parte dos incidentes reportados a equipa de manutenção (analistas, programadores) tem de pedir mais informação sobre o erro, há uma enorme perda de tempo valioso em iterações desnecessárias, tanto de quem reporta incidentes como de quem lhes dá suporte.&lt;/p></description></item><item><title>Afinal a podridão é nobre</title><link>https://abapinho.com/2016/02/the-rot-is-noble-after-all/</link><pubDate>Mon, 22 Feb 2016 09:00:45 +0000</pubDate><guid>https://abapinho.com/2016/02/the-rot-is-noble-after-all/</guid><description>&lt;p>Durante anos queixei-me por o ambiente de desenvolvimento do SAP ser tão retrógrado e antiquado e por demorar tanto tempo a evoluir Sempre que mo ouvia dizer, um amigo meu avisava-me sabiamente: não mordas a mão que te dá de comer.&lt;/p>
&lt;p>Mas como pode um homem ficar calado?&lt;/p></description></item><item><title>Padrões de projecto de software em ABAP</title><link>https://abapinho.com/2016/02/padroes-de-projecto-de-software/</link><pubDate>Mon, 15 Feb 2016 09:00:26 +0000</pubDate><guid>https://abapinho.com/2016/02/padroes-de-projecto-de-software/</guid><description>Estamos em constante aprendizagem. Mas volta não volta aprendemos algo que nos obriga a dar um salto paradigmático na forma como olhamos para o que fazemos.
A última vez que isso me tinha acontecido foi quando comecei a usar OO em ABAP. OO não era novo para mim pois sempre programei em Java, C#, C++, etc. Mas poder finalmente aplicar os conceitos de OO em ABAP foi um alívio e um salto quântico na qualidade, flexibilidade e velocidade do meu trabalho.</description></item><item><title>Índices secundários em tabelas internas</title><link>https://abapinho.com/2016/01/indices-secundarios-em-tabelas-internas/</link><pubDate>Mon, 25 Jan 2016 09:00:47 +0000</pubDate><guid>https://abapinho.com/2016/01/indices-secundarios-em-tabelas-internas/</guid><description>&lt;p>Durante anos as tabelas internas eram declaradas assim:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">DATA&lt;/span>: &lt;span style="color:#000">itbl&lt;/span> &lt;span style="color:#00f">TYPE TABLE OF&lt;/span> &lt;span style="color:#000">bkpf&lt;/span>.&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div></description></item><item><title>Como sabotar textos standard</title><link>https://abapinho.com/2015/11/como-sabotar-textos-standard/</link><pubDate>Mon, 23 Nov 2015 09:00:43 +0000</pubDate><guid>https://abapinho.com/2015/11/como-sabotar-textos-standard/</guid><description>&lt;p>Às vezes não gosto dos nomes que a SAP deu às coisas. E então mudo-os.&lt;/p>
&lt;p>Por exemplo, um dia estava muito zangado e achava que os clientes eram todos uns parasitas.&lt;/p>
&lt;p>Então fiz o seguinte:&lt;/p></description></item><item><title>Eu te baptizo em nome do ABAP</title><link>https://abapinho.com/2015/10/eu-te-baptizo-em-nome-do-abap/</link><pubDate>Mon, 26 Oct 2015 09:00:05 +0000</pubDate><guid>https://abapinho.com/2015/10/eu-te-baptizo-em-nome-do-abap/</guid><description>&lt;p>Quando aprendemos ABAP ensinam-nos uma série de regras sobre como dar nomes a variáveis. Ainda que nem todos acabem por dar nomes iguais, ainda assim partilham-se algumas ideias rígidas:&lt;/p>
&lt;ul>
&lt;li>
&lt;p>As variáveis locais começam por L: L_BUKRS;&lt;/p>
&lt;/li>
&lt;li>
&lt;p>As variáveis globais começam por G: G_MODE;&lt;/p>
&lt;/li>
&lt;li>
&lt;p>As tabelas internas têm de ter lá um T_: LT_MARA;&lt;/p>
&lt;/li>
&lt;li>
&lt;p>As estruturas têm de ter lá um S_: LS_MARA;&lt;/p>
&lt;/li>
&lt;li>
&lt;p>As referências para objectos começam por R_: R_CUSTOMER;&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Os parâmetros &lt;em>input&lt;/em> devem começar por I, os &lt;em>output&lt;/em> por O, os &lt;em>changing&lt;/em> por C e os &lt;em>returning&lt;/em> por R.&lt;/p>
&lt;/li>
&lt;li>
&lt;p>E a mais estúpida de todas, os &lt;em>field-symbols&lt;/em> devem começar por FS_: &amp;lt;FS_MARA&amp;gt;.&lt;/p>
&lt;/li>
&lt;/ul>
&lt;p>No início do século XXI isto até fazia sentido (excepto a dos &lt;em>field-symbols&lt;/em> que já na altura era tão estúpida como escrever a palavra &amp;ldquo;lápis&amp;rdquo; em todos os lápis que tivermos). Hoje quase já não. Passo a explicar.&lt;/p></description></item><item><title>Abapinho Dev Tools: Translator</title><link>https://abapinho.com/2015/10/abapinho-dev-tools-translator/</link><pubDate>Thu, 22 Oct 2015 14:54:11 +0000</pubDate><guid>https://abapinho.com/2015/10/abapinho-dev-tools-translator/</guid><description>O Nuno Morais desenvolveu uma ferramenta muito útil que auxilia na tradução em massa da maioria dos objectos SAP.
A ferramenta não faz tradução automática entre línguas. Antes, permite:
Exportar um ficheiro Excel com textos
Importar um ficheiro Excel com textos
Copiar textos de uma língua para uma ou mais línguas de destino
Criar uma ordem de transporte com as alterações
Encontrar dependências de objectos a que faltem traduções
Práctico interface de navegação para tradução manual</description></item><item><title>Abapinho Dev Tools: Dependencies</title><link>https://abapinho.com/2015/10/abapinho-dev-tools-dependencies/</link><pubDate>Thu, 22 Oct 2015 14:37:19 +0000</pubDate><guid>https://abapinho.com/2015/10/abapinho-dev-tools-dependencies/</guid><description>O Nuno Morais desenvolveu uma ferramenta muito útil que permite comparar objectos entre sistemas e que funciona muito melhor do que a transacção SREPO.
O Abapinho passa a ser o seu repositório oficial.
Código no GitHub.
Em breve, instruções. Até lá vai experimentando, é intuitivo. E se gostares ou tiveres sugestões deixa aqui um comentário.
Obrigado Nuno por teres desenvolvido isto e por o partilhares com o mundo no Abapinho.</description></item><item><title>DELETE vs CLEAR vs REFRESH vs FREE</title><link>https://abapinho.com/2015/07/delete-vs-clear-vs-refresh-vs-free/</link><pubDate>Mon, 27 Jul 2015 09:00:01 +0000</pubDate><guid>https://abapinho.com/2015/07/delete-vs-clear-vs-refresh-vs-free/</guid><description>&lt;p>DELETE
CLEAR
REFRESH
FREE&lt;/p>
&lt;p>São várias maneiras de limpar os dados de uma tabela interna.
À partida parecem iguais.
Mas não são.&lt;/p></description></item><item><title>Converter excepção em classe de excepção</title><link>https://abapinho.com/2015/06/converter-excepcao-em-classe-de-excepcao/</link><pubDate>Mon, 01 Jun 2015 09:00:21 +0000</pubDate><guid>https://abapinho.com/2015/06/converter-excepcao-em-classe-de-excepcao/</guid><description>&lt;p>Se ainda não usas classes de excepção fazes mal. Porque são muito boas para a saúde do código. Além de nutritivas, emagrecem-no e tornam-no mais resistente a doenças.&lt;/p>
&lt;p>Mas há casos em que ainda é preciso lidar com as antigas excepções. Por exemplo quando se invoca um módulo de função.&lt;/p>
&lt;p>Neste artigo apresento uma sugestão um bocado rebuscada mas que funciona muito bem para integrar as excepções antigas com classe de excepção de uma forma simples. A solução é rebuscada mas só tem de ser feita uma vez. Uma vez feita, a forma como se a usa não tem nada de rebuscado.&lt;/p></description></item><item><title>Ensina o ABAP a fazer malabarismo</title><link>https://abapinho.com/2015/05/processamento-paralelo/</link><pubDate>Mon, 18 May 2015 09:00:13 +0000</pubDate><guid>https://abapinho.com/2015/05/processamento-paralelo/</guid><description>&lt;p>O que podemos fazer quando as noites não são suficientes para os processamentos diários?&lt;/p></description></item><item><title>Procurar texto numa WebDynpro</title><link>https://abapinho.com/2015/03/procurar-texto-numa-webdynpro/</link><pubDate>Mon, 23 Mar 2015 09:00:31 +0000</pubDate><guid>https://abapinho.com/2015/03/procurar-texto-numa-webdynpro/</guid><description>&lt;p>A SAP não sabe fazer as coisas bem à primeira. As WebDynpros são um bom exemplo disso. Aquilo nem sequer permite pesquisar texto. É triste.&lt;/p>
&lt;p>Felizmente o Sérgio Fraga descobriu uma forma, ainda que rebuscada:&lt;/p></description></item><item><title>Cadeias de excepções</title><link>https://abapinho.com/2015/02/cadeias-de-excepcoes/</link><pubDate>Mon, 02 Feb 2015 09:00:48 +0000</pubDate><guid>https://abapinho.com/2015/02/cadeias-de-excepcoes/</guid><description>&lt;p>Hoje vou ensinar-te a encadear excepções. É uma solução muito práctica para um problema complicado mas pouco óbvio.&lt;/p>
&lt;p>Começo por descrever o problema.&lt;/p>
&lt;p>Imagina que estás na aplicação BANANA.
É uma aplicação bastante complexa.
Tem, aliás, três módulos. São eles BANANA1, BANANA2 e BANANA3.
Cada um tem a sua classe de excepção ZCX_BANANA1, ZCX_BANANA2 e ZCX_BANANA3.
E como a aplicação até está bem desenhada, todas as classes de excepção herdam da mesma ZCX_BANANA.
Agora imagina o seguinte cenário.
Estás no módulo BANANA1 a fazer não sei o quê.
E lá tens de chamar uma classe do módulo MORANGO
Ora essa classe lança, claro, excepções, do tipo ZCX_MORANGO.
Este é o contexto.&lt;/p>
&lt;p>Tens várias hipóteses:&lt;/p></description></item><item><title>Comunicação por evento entre programas</title><link>https://abapinho.com/2014/12/comunicacao-por-evento-entre-programas/</link><pubDate>Mon, 22 Dec 2014 09:00:11 +0000</pubDate><guid>https://abapinho.com/2014/12/comunicacao-por-evento-entre-programas/</guid><description>&lt;p>Na mitologia grega a forma de comunicação mais frequentemente utilizada pelos deuses para comunicar com os mortais era o estupro. Estupravam por dá cá aquela palha.&lt;/p>
&lt;p>O mais parecido que temos com estupro no ABAP é o comando SUBMIT, que é também a forma mais comum de comunicação entre dois programas.&lt;/p></description></item><item><title>Pacotes 2.0</title><link>https://abapinho.com/2014/07/pacotes-2-0/</link><pubDate>Mon, 21 Jul 2014 09:00:12 +0000</pubDate><guid>https://abapinho.com/2014/07/pacotes-2-0/</guid><description>&lt;p>O repositório do R/3 é uma coisa maravilhosa. Um vasto armazém de elementos de dados, estruturas, tabelas e muito mais, prontamente disponíveis a todos. Como programadores, é fácil e conveniente escolher estes objectos e puxa-los para os nossos programas à medida das necessidades sem que a preciosa linha de pensamento seja interrompida.
Mas nem tudo é sol e flores. Se não tiveres cuidado com os cogumelos que apanhas podes dar por ti com um envenenado entre mãos.&lt;/p></description></item><item><title>Request Based Debugging</title><link>https://abapinho.com/2014/05/request-based-debugging/</link><pubDate>Mon, 12 May 2014 09:00:10 +0000</pubDate><guid>https://abapinho.com/2014/05/request-based-debugging/</guid><description>&lt;p>Se em &lt;em>debug&lt;/em> consultares a variável de sistema UNAME dentro de uma chamada RFC podes achar estranho encontrar um utilizador que não o teu. O que acontece é que o sistema adopta um utilizador específico a chamadas remotas e uma nova sessão é iniciada. Uma nova sessão implica um novo contexto de execução e, consequentemente, todos os nossos &lt;em>breakpoints&lt;/em> , já estrategicamente colocados, não serão reconhecidos.&lt;/p>
&lt;p>Este problema pode dificultar um &lt;em>debug&lt;/em> simples obrigando-nos a percorrer o código à procura DAQUELA chamada remota ÀQUELE sistema em particular.&lt;/p>
&lt;p>A SAP tem a solução.&lt;/p></description></item><item><title>O detective do ABAP</title><link>https://abapinho.com/2014/03/o-detective-do-abap/</link><pubDate>Mon, 10 Mar 2014 09:00:42 +0000</pubDate><guid>https://abapinho.com/2014/03/o-detective-do-abap/</guid><description>&lt;p>Em SAP, quando um desenvolvimento está concluído, chega finalmente o momento de o enviar para outros sistemas onde pode ser devidamente testado e por fim executado pelos utilizadores.
Mas antes disso, é crucial verificar se não existem lapsos, erros e afins que possam levar ao aparecimento de alguns comportamentos imprevisíveis por parte dos nossos programas.
Existe uma ferramenta muito útil que permite filtrar alguns desses erros e lacunas. Chama-se ABAP Code Inspector.&lt;/p></description></item><item><title>Matemática problemática</title><link>https://abapinho.com/2013/12/matematica-problematica/</link><pubDate>Mon, 09 Dec 2013 09:00:23 +0000</pubDate><guid>https://abapinho.com/2013/12/matematica-problematica/</guid><description>&lt;p>Sabes a diferença entre um mistério e um enigma? Num enigma sabe-se que há uma solução mas esta não é conhecida; já num mistério, não se sabe se haverá solução.&lt;/p>
&lt;p>Concordas com isto?
5 * 3 / 10 = ( 5 * 3 ) / 10 = 5 * ( 3 / 10 ) = 1.5&lt;/p>
&lt;p>Se não concordas, devias concordar porque é um facto matemático.&lt;/p>
&lt;p>Mas vamos lá fazer umas experiências.&lt;/p></description></item><item><title>Roubar o conteúdo de uma SALV</title><link>https://abapinho.com/2013/10/roubar-salv/</link><pubDate>Mon, 14 Oct 2013 10:04:02 +0000</pubDate><guid>https://abapinho.com/2013/10/roubar-salv/</guid><description>&lt;p>Um amigo de um amigo de um amigo disse que um amigo dele conhecia um amigo que, num bar de alterne ali nas docas, lhe explicou como roubar os dados a uma SALV.&lt;/p></description></item><item><title>Já usaste expressões regulares?</title><link>https://abapinho.com/2013/07/regex/</link><pubDate>Mon, 15 Jul 2013 09:00:55 +0000</pubDate><guid>https://abapinho.com/2013/07/regex/</guid><description>&lt;p>As expressões regulares já existem há que tempos. Mas ainda são muito pouco conhecidas e ainda menos usadas. São uma espécie de linguagem descritiva que permite efectuar pesquisas e substituições muito sofisticadas em cadeias alfa-numéricas.&lt;/p></description></item><item><title>Lê código da net e executa-o</title><link>https://abapinho.com/2013/07/ler-codigo-da-net-e-executa-lo/</link><pubDate>Mon, 01 Jul 2013 09:00:42 +0000</pubDate><guid>https://abapinho.com/2013/07/ler-codigo-da-net-e-executa-lo/</guid><description>&lt;p>Este artigo é um dois em um. Ou seja, vais aprender duas coisas de uma só vez.&lt;/p>
&lt;p>Mas prepara-te, o que vais aprender é dinamite e, nas mãos erradas, pode fazer implodir o teu universo.&lt;/p>
&lt;p>Primeiro vais aprender a ir ler conteúdo à net. E logo a seguir, assumindo que esse conteúdo é código ABAP, aprendes de rajada a executá-lo.&lt;/p></description></item><item><title>Com muitos campos evita INTO CORRESPONDING FIELDS</title><link>https://abapinho.com/2013/06/into-corresponding-fields/</link><pubDate>Mon, 10 Jun 2013 09:00:27 +0000</pubDate><guid>https://abapinho.com/2013/06/into-corresponding-fields/</guid><description>&lt;p>Já avisei aqui que, em tabelas com muitos campos, é sempre de evitar fazer SELECT *, devendo-se sempre seleccionar explicitamente apenas os campos necessários.&lt;/p>
&lt;p>Mas não avisei ainda que há ainda outra optimização que merece ser feita: evitar o INTO CORRESPONDING FIELDS OF TABLE.&lt;/p></description></item><item><title>R3TR vs LIMU</title><link>https://abapinho.com/2013/05/r3tr-vs-limu/</link><pubDate>Mon, 06 May 2013 23:00:21 +0000</pubDate><guid>https://abapinho.com/2013/05/r3tr-vs-limu/</guid><description>&lt;p>Espatifaste o sistema produtivo: fizeste uma alteração a um método de uma classe (ou a uma função, vá). Outra pessoa faz outra alteração a outro método da mesma classe (ou a outra função do mesmo grupo de funções, vá) e grava-a num transporte diferente. Quando transportas as tuas alterações para produtivo descobres que a classe (ou função, vá) agora tem um erro de sintaxe porque as alterações tinham dependências. Descobres também que agora, e até resolveres este problema, todos os teus colegas funcionais te odeiam.&lt;/p></description></item><item><title>O SAPlink</title><link>https://abapinho.com/2012/12/saplink/</link><pubDate>Mon, 03 Dec 2012 09:00:00 +0000</pubDate><guid>https://abapinho.com/2012/12/saplink/</guid><description>&lt;p>O SAPlink é um programa Z que se instala no ambiente de desenvolvimento e que permite importar e exportar os mais variados tipos de objectos do Workbench.&lt;/p>
&lt;p>Olha aqui exemplos de como o SAPlink pode ser usado:&lt;/p>
&lt;ul>
&lt;li>
&lt;p>Transferir uma tabela de um sistema SAP para outro&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Partilhar uma classe na Internet&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Fazer um backup local de segurança de um conjunto de programas antes de fazer uma alteração perigosa&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Guardar um desenvolvimento no nosso repositório pessoal (no &lt;a href="https://abapinho.com/2010/04/evernote/">Evernote&lt;/a>, claro) para o caso de vir a precisar dele mais tarde noutro projecto&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Etc.&lt;/p>
&lt;/li>
&lt;/ul></description></item><item><title>Olha pai, agora sem mãos</title><link>https://abapinho.com/2012/09/olha-pai-agora-sem-maos/</link><pubDate>Mon, 17 Sep 2012 09:00:48 +0000</pubDate><guid>https://abapinho.com/2012/09/olha-pai-agora-sem-maos/</guid><description>&lt;p>Neste artigo vou mostrar-te (e explicar-te!) como podes fazer com que um ecrã de selecção de um programa se refresque periodicamente sem intervenção do utilizador.&lt;/p>
&lt;p>Estás preparado?&lt;/p></description></item><item><title>Finalmente o ABAP sabe Excel</title><link>https://abapinho.com/2012/07/abap2xlsx/</link><pubDate>Mon, 02 Jul 2012 09:00:22 +0000</pubDate><guid>https://abapinho.com/2012/07/abap2xlsx/</guid><description>&lt;p>Há várias formas de criar um Excel em ABAP. Umas mais masoquistas, outras menos masoquistas; umas mais foleiras, outras menos foleiras.&lt;/p></description></item><item><title>Mete variáveis dentro de textos standard</title><link>https://abapinho.com/2012/04/mete-variaveis-dentro-de-textos-standard/</link><pubDate>Mon, 30 Apr 2012 10:00:06 +0000</pubDate><guid>https://abapinho.com/2012/04/mete-variaveis-dentro-de-textos-standard/</guid><description>&lt;p>Textos standard toda a gente usa. Mas sabias que os textos standard podem ter campos dinâmicos lá pelo meio? A SAP chama-lhes &amp;ldquo;símbolos de texto&amp;rdquo;. A forma de o conseguir é igual à dos velhos formulários da nefasta SE71, ou seja, envolvendo-os com o símbolo &amp;amp;. Assim: &amp;amp;KNA1-NAME1;&amp;amp;. Dá um jeitão. Vou mostrar-te como se faz.&lt;/p></description></item><item><title>Pesquisar por atributos de objectos em tabelas internas</title><link>https://abapinho.com/2012/03/atributos-de-objectos-em-tabelas-internas/</link><pubDate>Mon, 26 Mar 2012 10:00:17 +0000</pubDate><guid>https://abapinho.com/2012/03/atributos-de-objectos-em-tabelas-internas/</guid><description>&lt;p>Há cada vez mais objectos em ABAP, cada vez menos medo deles e, vê só!, cada vez mais gente a escrevê-los e a usá-los. Ora, se começam a aparecer objectos por todo o lado, é normal e desejável que comecem a enfiá-los também dentro de tabelas internas. Também eu guardei há uns tempos um monte de objectos dentro de tabelas mas infelizmente na altura não sabia disto que vou ensinar aqui. Tinha-me dado jeito.&lt;/p>
&lt;p>Mas afinal o que vou eu ensinar aqui?&lt;/p></description></item><item><title>Implementar métodos privados em BADIs</title><link>https://abapinho.com/2012/03/metodos-privados-em-badis/</link><pubDate>Mon, 19 Mar 2012 10:00:09 +0000</pubDate><guid>https://abapinho.com/2012/03/metodos-privados-em-badis/</guid><description>&lt;p>Há uns tempos tive uma ideia meio estrambólica meio fantástica que hoje decidi partilhar aqui: criar métodos privados nas classes das BADIs.&lt;/p>
&lt;p>Passo a explicar.&lt;/p></description></item><item><title>Como sabotar tabelas</title><link>https://abapinho.com/2012/03/como-sabotar-tabelas/</link><pubDate>Mon, 12 Mar 2012 13:30:24 +0000</pubDate><guid>https://abapinho.com/2012/03/como-sabotar-tabelas/</guid><description>&lt;p>Mais um artigo em auxílio dos que buscam a subversão subreptícia. Espiões, reparem como editar uma tabela que não pode (e provavelmente não deve) ser editada. Apresento-vos 3 técnicas. A primeira já caducou há anos, a segunda está em vias de caducar e a terceira vamos ver quando caducará.&lt;/p></description></item><item><title>Enviar relatório ou ordem de spool por e-mail</title><link>https://abapinho.com/2012/02/relatorio-por-email/</link><pubDate>Mon, 13 Feb 2012 10:00:35 +0000</pubDate><guid>https://abapinho.com/2012/02/relatorio-por-email/</guid><description>&lt;p>Este post inaugura uma nova categoria no Abapinho: Código. Os posts desta categoria apresentarão programas úteis prontos a correr.&lt;/p>
&lt;p>Este serve para enviar por e-mail o resultado de qualquer relatório ou ordem de spool. O programa apresentado faz uso da nova BCS (Business Communication Services) através da classe CL_BCS em vez do velho e cansado SO_DOCUMENT_SEND_API1, paz à sua alma.&lt;/p>
&lt;p>O conteúdo pode ser enviado no corpo do email, como um anexo TXT ou como um anexo HTML, sendo que este último até vai com as cores todas certinhas e tudo. Disfruta-o. Copia-o cegamente e usa-o ou disseca-o e aprende como usar a CL_BCS. Pelo meio, se te apetecer, ainda podes aprender como usar classes locais e como usar classes de excepção.&lt;/p></description></item><item><title>Automatizar catálogo de campos de ALV</title><link>https://abapinho.com/2011/12/automatizar-catalogo-alv/</link><pubDate>Mon, 12 Dec 2011 10:00:00 +0000</pubDate><guid>https://abapinho.com/2011/12/automatizar-catalogo-alv/</guid><description>&lt;p>Às vezes pergunto-me qual será, no mundo, a percentagem de código ABAP desnecessário. Um exemplo paradigmático de como se pode desperdiçar tempo a escrever código que não serve para nada e só prejudica é a tão frequente definição das descrições dos campos de uma ALV directamente em ABAP.&lt;/p></description></item><item><title>As funções *_SINGLE_READ</title><link>https://abapinho.com/2011/08/funcoes-single-read/</link><pubDate>Mon, 01 Aug 2011 10:43:04 +0000</pubDate><guid>https://abapinho.com/2011/08/funcoes-single-read/</guid><description>&lt;p>Quando se quer obter um único registo de uma tabela da base de dados é costume usar-se o SELECT SINGLE que, como toda a gente sabe, na sua forma mais básica reza assim:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">SELECT&lt;/span> &lt;span style="color:#00f">SINGLE&lt;/span> *
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#00f">FROM&lt;/span> &lt;span style="color:#000">KNA1&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#00f">WHERE&lt;/span> &lt;span style="color:#000">KUNNR&lt;/span> = &lt;span style="color:#5a2">&amp;#39;1234567890&amp;#39;&lt;/span>.&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div></description></item><item><title>LOOP ASSIGNING em vez de LOOP INTO</title><link>https://abapinho.com/2011/07/assigning-vs-into/</link><pubDate>Sat, 02 Jul 2011 12:25:03 +0000</pubDate><guid>https://abapinho.com/2011/07/assigning-vs-into/</guid><description>&lt;p>No princípio era o INTO.
Aliás, no princípio nem sequer era o INTO.&lt;/p></description></item><item><title>Partida... lagarta... fugida!</title><link>https://abapinho.com/2011/05/corrida-de-tabelas/</link><pubDate>Tue, 24 May 2011 09:00:41 +0000</pubDate><guid>https://abapinho.com/2011/05/corrida-de-tabelas/</guid><description>&lt;p>Senhoras e senhores, meninos e meninas, a corrida está prestes a começar.&lt;/p>
&lt;p>&lt;strong>Introdução&lt;/strong>&lt;/p>
&lt;p>Apresento-vos as 4 participantes. São 4 tabelas internas, de diferentes raças e credos, que se vão pelejar pelo título atlético do LOOP em velocidade. Aqui estão elas:&lt;/p>
&lt;p>Concorrente 1: DATA: LT_ITEM TYPE TABLE
Concorrente 2: DATA: LT_ITEM_HASHED TYPE HASHED TABLE
Concorrente 3: DATA: LT_ITEM_SORTED TYPE SORTED TABLE
Concorrente 4: DATA: LT_ITEM TYPE TABLE + INTO INDEX&lt;/p></description></item><item><title>Como encavalitar tabelas</title><link>https://abapinho.com/2011/02/encavalitartabelas/</link><pubDate>Sat, 05 Feb 2011 16:38:20 +0000</pubDate><guid>https://abapinho.com/2011/02/encavalitartabelas/</guid><description>&lt;p>Às vezes temos de criar uma tabela Z. Às vezes temos até de criar várias tabelas Z. Às vezes estas tabelas estão relacionadas de alguma forma. Como quando uma contém dados de cabeçalho e a outra dados de item, por exemplo. Ora se estão relacionadas pode dar jeito que sejam editadas em conjunto. É para isso que servem os Clusters de Visão (view cluster).&lt;/p></description></item><item><title>SELECT com mais olhos que barriga</title><link>https://abapinho.com/2010/11/select-todos-os-campos/</link><pubDate>Sun, 21 Nov 2010 22:56:36 +0000</pubDate><guid>https://abapinho.com/2010/11/select-todos-os-campos/</guid><description>&lt;p>Embora seja evidente que, ao fazer selecções de dados de uma tabela da base de dados, devemos ter o cuidado de escolher apenas os campos que necessitamos, a verdade é que há muito boa gente que não se dá a esse trabalho e manda vir tudo.&lt;/p>
&lt;p>Mediremos aqui a diferença real entre as duas abordagens.&lt;/p></description></item><item><title>Import/Export = Contrabando</title><link>https://abapinho.com/2010/08/importexport/</link><pubDate>Sat, 14 Aug 2010 00:37:24 +0000</pubDate><guid>https://abapinho.com/2010/08/importexport/</guid><description>&lt;p>O Java, uma linguagem de programação bem pensada, ajuda o programador a organizar o seu código obrigando-o a desenvolvê-lo de forma estruturada. A sua própria filosofia potencia o pensamento estruturado e promove coerência e arrumação.&lt;/p>
&lt;p>Já o ABAP&amp;hellip; promove o caos. Está cheio de caminhos perniciosos que levam direitinho a um inferno confuso e labiríntico. E geralmente são as coisas aparentemente mais convenientes que se revelam as mais perigosas.&lt;/p>
&lt;p>Uma das conveniências piores é a parelha &lt;strong>IMPORT&lt;/strong> e &lt;strong>EXPORT&lt;/strong>.&lt;/p></description></item><item><title>Procurar uma BADI no palheiro</title><link>https://abapinho.com/2010/06/procurar-uma-badi-no-palheiro/</link><pubDate>Mon, 14 Jun 2010 10:46:04 +0000</pubDate><guid>https://abapinho.com/2010/06/procurar-uma-badi-no-palheiro/</guid><description>&lt;p>O SAP é um enorme palheiro. E os ABAPers são pessoas que trepam por esse palheiro acima e nele vasculham e escarafuncham em busca de agulhas de todo o género. Às vezes, desesperados, deitam-se a descansar e vêm uma quantidade enorme de bicharocos que vivem no palheiro fazer-lhes comichão. Para evitar que isso aconteça, o Artur Moreira propõe-nos uma série de diferentes técnicas para procurar BADIs neste grande palheiro que é o SAP.&lt;/p></description></item><item><title>Evernote - No anotar é que está o ganho</title><link>https://abapinho.com/2010/04/evernote/</link><pubDate>Mon, 19 Apr 2010 17:00:15 +0000</pubDate><guid>https://abapinho.com/2010/04/evernote/</guid><description>&lt;p>&lt;em>Il faut cultiver notre jardin - Voltaire&lt;/em>&lt;/p>
&lt;p>No SAP fala-se muito de experiência. Fulano tem muita experiência, sicrano tem pouca experiência. Tenta-se com isso medir a capacidade que alguém tem de usar o seu passado para lidar com o seu futuro. Mas nem sempre ter experimentado uma coisa é sinónimo de ganhar experiência com ela. O exemplo paradigmático ao alcance de todos é o amor: quantos desgraçados, por muitas experiências desgraçadas que tenham tido, se continuam a desgraçar-se no amor! O SAP não é o amor. Ainda assim não nos faltarão exemplos de consultores que no CV descrevem muitas experiências e na prática se revelam uns grandes inexperientes.&lt;/p>
&lt;p>A Inteligência terá certamente muito peso nessa capacidade de sublimar as experiências, de as conservar, de fazer delas Compota de Experiência. Mas, pelo menos no que toca ao mirabolante mundo do SAP, quem tem também muito a dizer é a senhora Memória. Ou melhor dizendo, a falta dela.&lt;/p>
&lt;p>O mundo do SAP é horizontal e vasto. Para onde quer que se olhe é a perder de vista. E embora seja um mundo bastante populado e onde se viaja muito, não houve até hoje, que eu saiba, cartógrafos de jeito. Os mapas que dele se fizeram são parcos, pobres, distorcidos e normalmente ainda o julgam plano quando toda a gente já sabe há muito tempo que ele é curvo.&lt;/p>
&lt;p>Há que cartografar o nosso mapa.&lt;/p></description></item><item><title>O maravilhoso mundo do Application Log</title><link>https://abapinho.com/2009/09/application-log/</link><pubDate>Sat, 19 Sep 2009 09:51:49 +0000</pubDate><guid>https://abapinho.com/2009/09/application-log/</guid><description>&lt;p>Uma boa parte dos reports, interfaces ou jobs, têm de produzir algum tipo de relatório. É normal ver isso feito recorrendo ao comando WRITE. Ora nos dias que correm, usar o comando WRITE para isto é como recorrer a um par de pedras para acender uma fogueira. Afinal, porque não usar o Application Log que é muito mais simples e prático e standard e é só vantagens?&lt;/p></description></item><item><title>Macros - Velocidade de ponta</title><link>https://abapinho.com/2009/09/macros-velocidade-de-ponta/</link><pubDate>Wed, 16 Sep 2009 02:37:52 +0000</pubDate><guid>https://abapinho.com/2009/09/macros-velocidade-de-ponta/</guid><description>&lt;p>Normalmente quando há um pedaço de código que pretendemos reutilizar várias vezes, transformamo-lo numa sub-rotina que pode depois ser invocada repetidamente. Embora a SAP não saiba estruturar o seu próprio código, ainda assim, o ABAP, coitadinho, permite-o. E até disponibiliza várias alternativas para modularizar o código. Eu conto quatro alternativas que listo aqui, da mais rígida para a mais flácida: METHOD, FUNCTION, FORM, DEFINE. Se os 3 primeiros são já familiar de todos, o último - DEFINE - quase ninguém usa. O DEFINE permite definir macros em ABAP. E o que são macros? São sub-rotinas aparentes.&lt;/p>
&lt;p>Aparentes porquê?&lt;/p></description></item><item><title>Constantes inconstantes</title><link>https://abapinho.com/2009/06/constantes/</link><pubDate>Tue, 02 Jun 2009 15:24:07 +0000</pubDate><guid>https://abapinho.com/2009/06/constantes/</guid><description>&lt;p>As constantes não o são. Toda a gente sabe. Quando se define uma constante, é certo como a morte que mais cedo ou mais tarde alguém vem e muda-a. Quando isto acontece, quem usa os valores directamente no código ABAP está feito ao bife; Quem define constantes no código só tem de alterar o valor num sítio mas vê-se ainda assim obrigado a editar o programa e a transportá-lo, coisa que, dependendo do grau de burocracia do ambiente em que se está, se pode revelar complicada. Este artigo apresenta uma solução simples mas sofisticada para gerir de forma centralizada todas as constantes de um sistema SAP através do uso de uma tabela de utilizador central onde se manterá todos os valores constantes e de uma classe com alguns métodos estáticos que serão usados para os obter.&lt;/p></description></item><item><title>Melhorar os melhoramentos</title><link>https://abapinho.com/2009/03/melhorar-os-melhoramentos/</link><pubDate>Fri, 20 Mar 2009 10:17:37 +0000</pubDate><guid>https://abapinho.com/2009/03/melhorar-os-melhoramentos/</guid><description>&lt;p>No princípio era o INCLUDE.&lt;/p>
&lt;pre>&lt;code>Depois vieram os CMODs,
Seguiram-se logo as BADIs,
Agora são os Enhancements.
E no entanto, o caos continua.
&lt;/code>&lt;/pre>
&lt;p>&lt;strong>Crítica&lt;/strong>
Na maior parte dos projectos SAP em que já trabalhei, a metodologia de utilização de todas estas modificações é a tudo-ao-molho-e-fé-em-SAP e é normal encontrar num único include - como o MV45AFZZ - extensões de código tão grandes que, se o SAP fosse a princesa Rapunzel, dava para lhe fazer umas tranças até cá abaixo para o príncipe subir à sua torre. Este código normalmente implementa várias funcionalidades diferentes e independentes que, ao longo do tempo, se vão emaranhando quase irreversivelmente umas nas outras (tipo trança mesmo). Como consequência, qualquer alteração ao código existente requer cuidados redobrados e é sempre vista como um risco para o funcionamento de tudo o que lá está.&lt;/p>
&lt;p>Venho aqui propor uma solução simples e eficaz para este problema.&lt;/p></description></item><item><title>Change pointers</title><link>https://abapinho.com/2009/03/change-pointers/</link><pubDate>Thu, 19 Mar 2009 17:07:02 +0000</pubDate><guid>https://abapinho.com/2009/03/change-pointers/</guid><description>&lt;p>Neste artigo tento explicar o que são &lt;em>change pointers&lt;/em> e revelar como são úteis e fáceis de usar.&lt;/p>
&lt;p>&lt;strong>O que é um change pointer&lt;/strong>
Um &lt;em>change pointer&lt;/em> é um mecanismo de registo de alteração de dados baseado em &lt;em>change documents&lt;/em> desenvolvido pela SAP especialmente para ALE. Permite saber, de forma simples e eficiente, quais os registos alterados em uma ou nas várias tabelas por ele monitorizadas. Os &lt;em>change pointers&lt;/em> são utilizados maioritariamente como gatilhos para a criação de IDOCs. Mas não devem ser vistos apenas como tal e espero que este artigo traga alguma luz a este mecanismo tão útil mas tão descurado no SAP.&lt;/p></description></item></channel></rss>