Alterando arquivo xml como array de bytes.

Olá...


Recentemente tive uma demanda de um cliente, com  uma banda de acesso muito pequena. Por tanto tive que gerar um executável muito pequeno para enviar para ele.

A principio utilizei as bibliotecas do Qt para ler um Xml e fazer as modificações. Por causa da lib do qt exigir dependências externas, e não achei como remover as dependências, meu executável ficou com quase 40Mb.
Isso mesmo! 40 Mb :-/ Imagina minha decepção.

Partir para a libxml2, biblioteca bem documentada (não conhecia mas me agradou muito). Só que o executável e as bibliotecas juntas geram um montante de 10Mb.

Sei o que vocês vão perguntar? Não poderia gerar executável estático, gerar uma nova lib com só o necessário, certificar que os usuário já tenham as principais bibliotecas na máquina.

Respondendo: Era tarde da noite e não tinha como ter essas "regalias". Tinha que gerar um executável para a manhã seguinte.

Eis minha solução... gerei um executável em C com as bibliotecas básicas: stdio.h, string.h e stdlib.h
O executável ficou minusculo... 100 kb. Isso mesmo! só que deu um trabalho danado para re-escrever algumas funções triviais das bibliotecas Qt e libxml2. E outra coisa, eu tratei o arquivo xml como um array de bytes ;-)

- Achei o texto relacionado a tag
- Alterei o texto
- Salvei em um novo arquivo

Após esta história, vem o motivo deste post... foi difícil achar na net implementações das funções em C, então segue meu código abaixo para quem quiser reaproveitar:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

FILE *pFile_old = NULL,
         *pFile_new = NULL;
static char strTag_new[4096] = {};
int size_new = 0;
static char strTag_old[4096] = {};
int size_old = 0;

static char xmlData[4096] = {};
int size_xml = 0;

static char text[] = "Texto\\\0";
int size_text;

/**
 * @brief getPositionBegin
 * @param source
 * @param substr
 * @return position where start substr in source
 */
int getPositionBegin(char *source, char *substr)
{
    char *tmp = strstr(source, substr);
    int pos = (tmp - source);
    return pos;
}

/**
 * @brief getPositionEnd
 * @param source
 * @param substr
 * @return  position where end substr in source
 */
int getPositionEnd(char *source, char *substr)
{
    char *tmp = strstr(source, substr);
    int pos = (tmp - source) + strlen(substr);
    return pos;
}

/**
 * @brief readFileBytes
 * @param name
 */
void readFileBytes(const char *name)
{
    pFile_old = fopen(name , "rb");
    if (pFile_old == NULL) {
        fputs ("File error",stderr);
        exit(1);
    }
    // obtain file size:
    fseek (pFile_old , 0 , SEEK_END);
    size_xml = ftell (pFile_old);
    rewind (pFile_old);

    // copy the file into the buffer:
    size_t result = fread (xmlData, 1, size_xml, pFile_old);
    if (result != size_xml) {
        fputs ("Reading error",stderr);
        exit(2);
    }
    xmlData[size_xml+1] = '\0';

    fclose(pFile_old);
    pFile_old = NULL;
}

/**
 * @brief writeFileData
 * @param name
 * @param data
 * @return
 */
int writeFileData (char *name, char *data)
{
    pFile_new = fopen(name, "wb");
    size_t result = fwrite (data , sizeof(char), strlen(data), pFile_new);
//    if (result > 0)
//        exit(3);
    fclose (pFile_new);
    pFile_new = NULL;
    return result;
}

char *substring(char *string, int position, int length)
{
    char *pointer;
    int c;

    pointer = malloc(length+1);

    if( pointer == NULL )
        exit(EXIT_FAILURE);

    for( c = 0 ; c < length ; c++ )
        *(pointer+c) = *((string+position-1)+c);

    *(pointer+c) = '\0';

    return pointer;
}

/**
 * @brief Insert substring into source
 * @param source
 * @param substr
 * @param position
 * @warning array start in 1
 */
void insert_substring(char *source, char *substr, int position)
{
    char *f, *e;
    int length;

    length = strlen(source);

    // get text before 'substr'
    f = substring(source, 1, position - 1 );
    // get text after 'substr'
    e = substring(source, position, (length-position)+1);

    strcpy(source, "");
    strcat(source, f);
    free(f);
    strcat(source, substr);
    strcat(source, e);
    free(e);
}

/**
 * @brief remove_substring
 * @param source
 * @param substr
 */
void remove_substring(char *source, char *substr)
{
    int begin = getPositionBegin(source, substr);
    int end = getPositionEnd(source, substr);

    while( source = strstr(source, substr) )
        memmove(source,source+strlen(substr), 1+strlen(source+strlen(substr)));
}

void *replace_str(char *source, char *_old, char *_new)
{
    int pos = getPositionBegin(source, _old);
    remove_substring(source, _old);
    insert_substring(source, _new, pos);
}


Segue a função main:

int main(int argc, char* argv[])
{
    // reading xml file
    readFileBytes("c:\\exemplo.xml");

    // find position of tag
    int begin = 15 + getPositionBegin(xmlData, "<ReceiptFooter>");

    // find position of tag
    int end = getPositionBegin(xmlData, "</ReceiptFooter>");

    // define size of text
    size_old = (end-begin);
    int tam = (end-begin) - 1;

    // check text empty
    if (tam > 0) {

        // get the text
        strncpy(strTag_old, (xmlData+begin), size_old);
        strTag_old[size_old + 1] = '\0';

        //remove old tag text from xml
        remove_substring(xmlData, strTag_old);

        // Text split - remove lines that start with '--'
        char *pch = strtok (strTag_old,"\\");
        while (pch != NULL)
        {
            // check if string start with '--'
            int pos = getPositionBegin(pch, "--");
            if (pos != 0){
                // put in new string
                strcat(strTag_new, pch);
                size_new += strlen(pch);
                strcat(strTag_new, "\\");
                size_new++;
            }
            pch = strtok (NULL, "\\");
        }
        strTag_new[size_new+1] = '\0';
    }

    // find the text
    int pos = getPositionBegin(strTag_new, text);
    if (pos < 0) {
        //add text
        insert_substring(strTag_new, text, 1);
    }

    // remove old tag text and put new in xml
    insert_substring(xmlData, strTag_new, begin+1);
    writeFileData("c:\\exemplo2.xml", xmlData);

    // delete temporary files
    system("del c:\\exemplo.xml");
    system("del c:\\exemplo2.xml");

    return(0);
}


Utilizando esse código, com includes das bibliotecas básicas do C. Pudi criar um executável sem parâmetros para o GCC.

GCC main.c


Abraços

Funções anônimas. Quem sabe o que é?

Neste post vou falar de funções anônimas, a sua usabilidade e mostrar exemplos. Vou colocar um exemplo de python e JavaScript, mas poderia ser em C++, C#, PHP e até Delphi pelo que ouvi falar, o importante é o conceito.

Funções anônimas, também conhecidas com closures, permitem a criação de funções que não tem nome especificado.

Elas são mais uteis com os valores de parâmetros callback, mas pode ter outros usos. Isso para o programador iniciante parece complicado mas após alguma pratica fica fácil.

Talvez surja a pergunta aos novatos: mas se utilizamos as funções "normais" sem problema, qual seria a utilidade das funções anônimas?
Imagine o caso que você necessite utilizar uma função só que com parâmetros diferentes. Neste caso você precisaria, dependendo da linguagem, declarar uma outra função e fazer sua implementação, para utiliza-la uma vez só as vezes. Com as funções anônimas, e caso a linguagem suporte closure ganhamos uma maior simplicidade de código.

Cálculo do número N da sequência de Fibonacci.
- usando funções normais Python

def fibonacci(N):
return N if N < 2 else fibonacci(N-1) + fibonacci(N-2)
print fibonacci(10)

- usando funções anônimas Python

fibonacci = lambda N: N if N<2 else fibonacci(N-1) + fibonacci(N-2)
print fibonacci(10)

- usando funções normais JavaScript

function myFunction() {
alert("Hello world!");
}

- usando funções anônimas JavaScript

var myFunction = function() {
alert("Hello world!");
}

Algumas peculiaridades de Python para JavaScript mas da para ter uma ideia.
Assim que tiver mais tempo, escrevo sobre expressões lambda. De onde originou as funções anônimas.

Criando um plugin para Chrome

O browser Chrome hoje é um dos mais utilizados (para mim o mais utilizado, não conheço programadores que não o estão usando), por isso, outro dia estava pensando em como desenvolver um plugin para o meu chrome para minhas necessidades. Eis que acho um tutorial básico na revista PROGRAMAR edição 44.


Eis uma "psicografia" :-D do artigo da revista.


O plugin que vamos criar, mostrara as dimensões do browser.

Para isso você deve conhecer um pouco de HTML, CSS e JavaScript.

Todas as extensões (plugins) para o chrome, web app ou temas tem um arquivo formatado, chamado de manifest. Neste caso manifest.json, que fornece importantes informações.

Segue nosso código do manifest.json abaixo. Os únicos campos realmente necessários são: name e version.

{
"manifest_version": 2,
"name": "Ruller",
"description": "Este plugin diz-nos quais as medi- das atuais do nosso browser.",
"version": "1.0",
"icons": {
"16": "icons/16x16.png",
"48": "icons/48x48.png",
"128": "icons/128x128.png" },
!
"browser_action": {
"default_icon": {
"19": "icons/19x19.png",
"38": "icons/38x38.png" },
"default_title": "Ruller" },
! "background": {
"scripts": ["background.js"] }, !
"content_scripts": [ {
"matches": ["http://*/*", "https://*/*"],
"js": ["jquery.min.js","content.js"] } ]
} ! 

Após isso, criaremos o arquivo background.js, definido no manifest. Ele serve como "vigia", fica na espera que o utilizador o chame. Vocês podem notar que estamos a espera do evento de clique.

chrome.browserAction.onClicked.addListener
(function(tab)
{
chrome.tabs.getSelected(null, function(tab)
{
chrome.tabs.sendMessage(tab.id, "");
});
});

No código acima, como nós vimos, estamos esperando o clique do mouse. O utilizador clica no nosso plugin e envia uma mensagem, mas para quem? Para isso nós definimos o nosso arquivo content.js, segue abaixo o código.

chrome.extension.onMessage.addListener
(function()
{
var width = $(window).width();
var height = $(window).height();
alert("Largura:" + width + "\nAltura: " + height);
}); 

Agora nós já temos todos nosso código, só precisamos nos atentar a duas coisas: esse plugin necessita o framework JQuery, logo temos de importar primeiro o JQuery. E fazer um teste do nosso plugin.

Vou colocar esse dois passos no meu próximo post.

9 Motivos para aprender a programar.

Ola pessoal


Estava lendo meus feeds outro dia, enquanto esperava a compilação do framework da empresa, e achei esse texto. Achei super interessante, então resolvi compartilhar com vocês.

Por que ser programador? Este site trás 9 motivos ;-) Espero que gostem.

Alias! Parabéns ao pessoal da Mafagrafos pelo excelente artigo.


http://www.mafagrafos.net/2012/08/29/9-motivos-para-aprender-a-programar/

9 Motivos para Aprender a Programar

Publicado em 29/08/2012 
Categoria: Misc, Software Livre | Tags: Opinião | 14 Comments e 17 Reactions

Eu sou suspeito para falar de programação, já que comecei quando era muito novo e até hoje me fascino com o assunto. Para mim, programação é universo fantástico, até um pouco distante da nossa realidade.

E eu acredito que existem diversos motivos pelos quais alguém deveria aprender a programar. Por isso, criei essa lista com 9 motivos pelos quais eu acredito que vale a pena aprender a programar.

1. Uma Ótima Carreira Profissional

A carreira profissional de programação é bastante interessante, já que o Brasil é ainda bastante carente na área. Cada vez mais as pessoas consomem tecnologia, principalmente conforme o acesso a internet e a aparelhos móveis crescem no país. E o Brasil precisa de programadores capazes de suprir essa demanda.

Por causa disso, o salário de programadores é bastante interessante, principalmente para bons programadores situados nas grandes cidades. Mas hoje, através da internet, é possível ter uma carreira profissional independentemente de onde você mora.

Se você quiser saber mais sobre a carreira profissional de programação, sugiro escutar oNerdcast – Profissão: Programador. Para quem não conhece, o Nerdcast é um arquivo de áudio lançado semanalmente onde o pessoal do Jovem Nerd e convidados discutem diversos assuntos.

2. Criar Coisas Fantásticas

Sabendo programar é possível criar softwares dos mais diversos tipos. Na verdade, um programador pode, potencialmente, trabalhar com qualquer tipo de software, seja desenvolvendo Apps para iOS e Android, softwares para Mac OS, Linux e Windows ou até mesmo trabalhar no desenvolvimento de sistemas para grandes empresas.

Assim é possível criar softwares fantásticos em diversas áreas. Por exemplo, Mark Zuckenberg começou a trabalhar no Facebook enquanto estava na faculdade, Linus Torvals criou o Linux enquanto era estudante na Finlândia e o Angry Birds foi criado por uma empresa fundada em 2003 e já teve mais de 1 bilhão de downloads.

Ou seja, através da programação é possível criar coisas simplesmente incríveis. É claro que muitas vezes é necessário ter toda uma equipe trabalhando para criar um novo produto e que existem diversas dificuldades e problemas, mas saber programar é o que permite que tais coisas ganhem vida.

3. Poder Modificar o Que Já Existe

Os softwares livres trouxeram uma oportunidade incrível para os programadores. Qualquer pessoa pode baixar e alterar um software livre. Dessa forma é possível criar a partir do que os outros já criaram.

Assim você pode adicionar novas funcionalidades ao softwares, corrigir bugs que encontrar ou então fazer modificações nesses softwares. E, na maioria das vezes, existe toda uma comunidade de programadores por trás desses softwares que está disposta a ajudar nesses processos e que é bastante aberta a colaboração de outras pessoas.

4. Entender Melhor a Tecnologia

Programadores costumam entender melhor a tecnologia como um todo. Isso porque eles estão acostumados a entender tanto aspectos de software quanto de hardware, além das dificuldades em se realizar algumas tarefas.

Além disso, quem sabe programar normalmente consegue “prever” como as coisas funcionam. Assim, se for necessário consertar ou configurar alguma coisa, muitas vezes não é necessário pesquisar o assunto, basta usar a “intuição” adquirida com o passar do tempo.

5. Aprender a Resolver Problemas

Programar é resolver problemas. Se eu quero fazer um jogo como o Angry Birds, eu preciso resolver diversos problemas (usando programação) para ter o resultado desejado.

Eu preciso resolver o problema de como colocar as imagens na tela, como capturar os movimentos feitos pelo usuário, como fazer animações, como descobrir se um passarinho bateu em um porco, como tocar uma música e efeitos sonoros, etc…

No final das contas, eu tenho um grande problema e quebro ele em problemas menores que precisam ser solucionados. E os programadores aprendem a transpor isso para a vida. Diversos problemas que encontramos na vida pode ser fragmentados em problemas menores e resolvidos com raciocínio lógico.

6. Desenvolver sua Imaginação

A programação é uma ferramenta de criação. E talvez seja uma ferramenta de criação totalmente diferente das outras que existem, já que não requer matéria prima além do conhecimento e o acesso a um computador.

Para fazer uma estátua de mármore ou um quadro, eu preciso de ferramentas e materiais caros que me permitam fazer esse trabalho, além do conhecimento de como fazer. Além disso, o processo de produção consome esses materiais e eu preciso comprar materiais novos para a próxima obra. Mas para criar um software, eu preciso apenas de um computador e conhecimento.

Você pode imaginar qual software ou qual App de celular ou site você quer fazer. E mesmo que você não chegue de fato a faze-lo, a programação permite que você imagine sem que aquilo seja impossível. Você pode imaginar um software e se achar que a ideia é boa, você pode programa-la e se você se empenhar poderá tirar esse software da sua imaginação e traze-lo para o mundo real.

7. Se Divertir

Para quem gosta, programar pode ser muito divertido. Muitos programadores conseguem passar horas seguidas programando, já que é uma atividade que mistura desafio com recompensa.

Várias partes da programação são grandes desafios, que nos faz pensar durante muito tempo e falhar diversas vezes. Mas conseguir passar por esses desafios é bastante recompensador.

8. Melhorar a comunicação com pessoas da área

Para aqueles que não são da área de programação, mas precisam trabalhar ao lado de programadores é muito útil saber programar. Para os empreendedores da área de software isso significa saber o que pode e o que não pode ser feito, além de permitir lidar melhor com a sua equipe.

Mas existem várias outras profissões que precisam trabalhar com programadores. No começo do ano quando ministrei o curso de verão Introdução à Computação na USP, tive vários alunos de áreas da biologia que precisavam entender o que os programadores faziam para entender o andamento da pesquisa.

9. Deixar a Vida Mais Prática

Uma coisa extremamente útil de saber programar é poder agilizar diversos aspectos da sua vida.

Por exemplo, eu já mencionei o uso de Torrent para fazer downloads, o software Plexque permite assistir filmes e séries no Windows e no Mac Os e sobre como colocar legendas em vídeos baixados na internet.

Mas todo o processo de baixar filmes, colocar na pasta correta juntamente com a legenda pode ser bem chato, por isso eu criei um pequeno programa que faz tudo isso para mim. Ele automatiza todo esse processo e me faz perder menos tempo nesse processo.

E esse é apenas um pequeno exemplo de diversos softwares que criei na minha vida para resolver problemas do dia a dia.

Aprendendo a Programar

A Internet é um recurso inesgotável sobre como aprender a programar. É possível encontrar livros, videos, blogs e muitos outros recursos sobre o assunto.

Se você mora em São Paulo (ou próximo), o Instituto de Matemática e Estatística da USP oferece anualmente um curso de verão de Introdução à Computação que é muito bom e bastante acessível.

Além disso, o Coursera oferece cursos gratuitos online (em inglês) relacionados à computação com professores de Stanford, Princeton e outras universidades.

E para aqueles que querem aprender a desenvolver para Android, o nosso parceiro Blog do Android publicou um artigo muito interessante intitulado Desenvolvimento para Android: Como Começar? que vale a pena ser lido.

Espero que esses itens acima ajudem a motivar os leitores do Mafagrafos a aprender a programar. E aproveito para perguntar para aqueles que já sabem programar:

Qual o décimo motivo para aprender a programar que você colocaria nessa lista?

Duvidas bobas: Java rodando aplicação externa.

Ola Pessoal!


Começando a escrever alguns posts sobre o que considero "Dúvidas bobas!" rs

Acredito que muitos de vocês, assim como eu ja passaram por isso, consideram umas implementações  "bobas" e que uma Goolgada resolveria rapidamente. Só que acabamos deixando pra depois, esquecemos e não são implementadas.

Ontem a noite, estava lendo meus feeds de noticias e encontrei este post do blog programandoronline.blogspot.com.br. Era uma coisa que eu queria para um programa: achei "boba", deixei pra depois e acabei esquecendo de implementar rs.

Segue o link do post e o código da solução:
http://programadoronline.blogspot.com.br/2012/06/executar-aplicacoes-externas-java.html?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed:+ProgramadorOnline+(Programador+Online)


Como rodar aplicações externas usando o Java (neste caso vamos abrir o IE do Windows).

Segue o código para tal tarefa:

import java.io.*


class Programa01
{
    public static void main(String[] args)
    {
        try {
            Process exec = Runtinme.getRuntime().exec("C:\\Program Files\\Internet Explorer\\iexplorer.exe");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
};


É isso ai pessoal!

Até a próxima e comprimentos ao blog programadoronline.blogspot.com.br pelo belo post (me ajudou ;-) )

Data por extenso

Ola pessoal!


Uma sacada bacana que eu aprendi outro dia com um amigo.

Pra gerar a data por extenso eu utilizava uma função, mas esse amigo me mostrou uma grande sacada que a Borland fez ;-)

Em apenas uma linha você obtém a data por extenso: FormatDateTime('dddddd',now);

Os incríveis 6 (d)'dês" retornam a data por extenso sem precisar de nenhuma função adicional.


Abraços, Emanuel

Problema com o arquivo midas.dll

Ola pessoal


Estava com esse problema a uma semana, sofrendo pra saber o porque.

Peguei o arquivo na internet. Coloquei na pasta Systems do Windows. No home do projeto. Em tudo que é lugar :-s

Até que li um post em um blog (desculpe! mas não me lembro o nome) que me salvou a vida.

O blog dizia o seguinte:

A partir do Delphi 6, sempre que vocês utilizam ClientDataSet - ele requer a biblioteca midas.

Pra vocês não sofrerem que nem eu ;-) No USES da interface adicione a biblioteca MidasLib. NÃO usem o arquivo midas.dll. Pelo menos pra mim não funcionou.


Abraços