C/C++ Delphi Java Python
Marcelo Martins , , , ,
Threads para Raiz – Parte 1

Neste primeiro artigo, iremos estabelecer um projeto, que iremos desenvolver nos demais artigos.

Objetivo

A intenção deste projeto é apresentar solução em diversos linguagens de controle de threads com compartilhamento de informações entre elas.

Proposta de projeto

Imagine que temos 3 funcionários em um departamento público.

  • Recepção de Protocolo – Ele recebe os protocolos de serviço dos clientes.
  • Controlador de Serviço – Ele recebe os protocolos da recepção, colocando em ordem numérica em uma fila de execução. Por controlar e ordenar, sua atividade demora tempo mediano.
  • Executor de Serviço – Ele pega o serviço, por executar o serviço é o mais demorado de todos.
Fluxo de execução

Tempo de execução

Ao analisarmos o departamento, fizemos a seguinte constatação:

  • A recepção de protocolo, é o departamento mais rápido.
  • O Controlador de Serviço tem um tempo médio que é o dobro da recepção.
  • Executor de Serviço – Demora o dobro do tempo do controlador de serviço.

Agora que temos o projeto, podemos no próximo artigo começar sua implementação.

Espero voces no próximo artigo 😉

wordpress
Marcelo Martins ,
Chatbot no wordpress

[chatbot]

Objetivo

Neste tópico incluiremos o chatbot no wordpress, atraves de um shortcode.

Projeto GIT

O código deste projeto pode ser visto no git abaixo:

https://github.com/marcelomaurin/chatbot-wordpress

Ele permite criar um shortcode, que pode ser incluido nos posts.

Onde aparece uma pagina de chat, para que possa interagir.

[chatbot]

O chatbot pode ser incluído na página conforme o link acima.

O chatbot ja incluído nesta página

Nos próximos artigos iremos dar inicio ao código do chatbot, pois este esta apenas com a parte web atualmente.

Java
Marcelo Martins
Java sem nutela no Ubuntu – Parte 3

Estarei neste tópico apresentando como integrar linux com JAVA, de forma que possamos utilizar recursos do sistema operacional de forma que possamos ganhar maior agilidade.

Porque usar o SO

É interessante criar rotinas integráveis para o sistema operacional para ganhar agilidade e performace.

Como utilizar?

Podemos chamar aplicações:

  • shell script– Quando queremos agregar operações em lote, exemplo copiar uma pasta.
  • aplicação terceira – Quando queremos aproveitar features especificas da linguagem, exemplo uso de python para IA.

Quando não utilizar o SO

Existem muitos motivos para usar, e outros motivos que rejeitam o uso.

O mais importante motivo que rejeita seu uso, é quando queremos criar aplicações que não dependem do SO, podendo ser desacoplada de qualquer plataforma.

Aplicações

Aplicações de infra, necessárias para criação de serviços ou recursos, associados a um dado SO.

Podemos utilizar um serviço por exemplo para criar ambientes automatizados, criando ambientes de forma rápida e automática, replicando o que um operador faria em processos manuais.

Exemplos:

  • Clonagem de banco de dados
  • Copiar arquivos
  • Montagem de Serviços
  • Gestão de recursos do SO
  • Manipulação de containers ou serviços.
  • Gestão de testes integrados, etc

Como chamar aplicações

	public static int ProgExt(String Param01, String Param02)  throws IOException {
		int Resultado = 0;
		System.out.println ("Chamando ProgExt... ");
		Runtime rt = Runtime.getRuntime();
        String[] commandAndArguments = {"/home/mmm/projetos/meuproj/scripts/ScripExt.sh",  Param01, Param02 };
		System.out.println(commandAndArguments);
        try {
			String s;
			System.out.println ("ProgExt- Exec commandAndArguments completo");
			Process p = rt.exec(commandAndArguments);
			p.waitFor();
			Resultado = p.exitValue();
            System.out.println ("ProgExt- exit: " + Resultado);

            p.destroy();
		} catch(Exception ex) {
            ex.printStackTrace();
        }

		return Resultado;
	}

Ao Realizar a chamada o ScriptExt.sh, passamos os parâmetros, conforme o script abaixo:

#!/bin/bash

ORIGEM=$1
DESTINO=$2

PATH=/home/mmm/projetos/meuproj/scripts


echo "Inicio de Log" >  $PATH/logbkp.log
echo "Iniciando copia de arquivo" >>  $PATH/logbkp.log

/usr/bin/cp -r $ORIGEM $DESTINO >>  $PATH/logbkp.log

O modelo deste script, permite capturar pela shell script os parâmetros recebidos do JAVA, realizando tarefas via scripts, permitindo aproveitar o que o JAVA teria maior dificuldade em realizar.

De fato a automação de cópia, não se enquadra em tarefa difícil, porem em um processo didático exemplifica sua prática.

Outro Exemplo seria copia de banco de dados:

#!/bin/bash

#exemplo de teste
#sh -x  ./clonabanco.sh bancoorigem bancodest

PATH=/home/mmm/projetos/meuproj/scripts

echo "Script de replicação de banco"

databaserep=$1

database=$2

output="output.sql"


echo "Log de execucao da operacao de clonagem de banco" >>  $PATH/logbkp.log

echo "Origem:$databaserep" >>  $PATH/logbkp.log
echo "Destino:$database" >>  $PATH/logbkp.log
echo "Data:`/usr/bin/date`" >>  $PATH/logbkp.log



echo "Iniciando criacao de backup " >>  $PATH/logbkp.log
echo `/usr/bin/mysqldump -uroot -pSENHA $databaserep -r $PATH/output.sql` >> $PATH/logbkp.log


echo "Escrevendo script de copia" >>  $PATH/logbkp.log

echo "CREATE DATABASE $database;"> $PATH/copy.sql
echo "use $database" >> $PATH/copy.sql
echo "SOURCE $PATH/output.sql" >> $PATH/copy.sql

echo "Criando a base destino" >>  $PATH/logbkp.log

echo `/usr/bin/mysql -uroot -pSENHA < $PATH/copy.sql` >> $PATH/logbkp.log

echo "Fim de execução " >>  $PATH/logbkp.log

Podemos ver neste script, o uso de técnica de clonagem do banco de dados, permitindo a integração simples com JAVA.

Com este ultimo artigo, encerramos a série de artigos Java sem Nutela no Ubuntu, espero que tenham gostado.

wordpress
Marcelo Martins , , ,
Personalização do WordPress

Os templates tags são informações obtidas do wordpress, que facilitam a captura das informações pelo site.

A lista de templates é muito variada, e pode ser vista no site:

https://codex.wordpress.org/Template_Tags

Mas podemos destacar alguns:

  • the_tags – lista de tags marcados no post.
  • the_category – lista de categorias marcadas no post.

Rodando Querys

É possível rodar uma query incorporada, lendo informações do banco do wordpress, conforme exemplo:

global $wpdb;

$sql = "select * from $wpdb->posts where post_status = 'publish'");

$listagem = $wpdb->get_results($sql);

foreach ($listagem as $value){
    echo $value->post_title;
    echo $value->post_content;
}

Usando WP_QUERY

O WP_QUERY é um query modificado, permitindo fazer filtragens por parâmetros.

$posts = new WP_Query('posts_per_page=1&orderby=rand');

while($posts->have_posts()): $posts->the_post();
    echo the_title();
    echo the_content();
endwhile;

Estarei dando maior foco no WP_Query em outros posts.

Tornar um WORDPRESS restrito

Uma forma simples de restringir o conteúdo de um wordpress, é exigir autenticação.

Isso pode ser visto, se incluirmos no arquivo header.php o seguinte fragmento:

<?php
if (!is_user_logged_in() ){
Header( "location:wp-admin/" );
}
?>

HOOK – Ganchos

Add_Filter

O Add_filter permite interceptar um dado, antes da sua visualização na tela.

Ele utiliza um callback, que é chamado na ocorrência do evento.

Exemplo, exibição do titulo

<?php
add_filter('the_title','view_title', 10,2);

function view_title($value, $id){
  if ($value== "NOVO") {
    $value = "NEW";
  }
  return value;
}
?>

No exemplo toda vez que um Titulo vier com nome novo, ele será substituído por NEW.

Add_action

O add_action é um evento que ocorre no momento da execução do wordpress, que é disparado durante a execução de alguma etapa de montagem da página.

Exemplo, podemos chamar a função inicializa, no momento da inicialização da página.

<?php
add_action('init','inicializa');

function inicializa(){
  echo 'Inicializou';
}

Java
Marcelo Martins
Java sem nutela no Ubuntu – Parte 2

Neste segundo artigo, Java sem nutela, vamos explicar como desenvolver uma aplicação na mão, sem IDE.

No primeiro artigo, expliquei como gerar um hello world, sem nada.

GIT

https://github.com/marcelomaurin/Java-Hello-World

Neste segundo artigo iremos incluir um arquivo de biblioteca JAR alem de explicar o conceito do JAR.

O JAR na verdade é um pacote contendo vários arquivos java, alem de outras informações referentes a criação de um pacote.

Usando um JAR

Primeiro irei explicar como usar o JAR.

O Arquivo JAR deve estar localizado em uma pasta onde os .JAR sejam encontrados, de forma geral, o linux ou qualquer outro sistema operacional, precisa visualizar a variável CLASSPATH

Para isso, iremos alterar o Makefile, incluindo o caminho da nossa lib

JCC=javac
SOURCE= \
	hello.java

TARGET= HelloWorld
PATHLIB=$CLASSPATH:/~/Java-Hello-World/libs

DEBUG= -g

all: compile run

lib:
	export CLASSPATH=$(PATHLIB)

compile:

	$(JCC) $(DEBUG) $(SOURCE)

run:
	java $(TARGET)

A lib só deve ser chamada um unica vez podendo ser incluída nos scripts de inicialização.

make lib

Pronto agora é só incluir seu jar na pasta que vc definiu no script e importar ele no seu código.

Criando seu JAR

A criação do JAR é bem simples, parte do meu artigo foi baseado no git https://github.com/macagua/example.java.helloworld

Meu GIT

https://github.com/marcelomaurin/hello-java

Nele podemos ver o Makefile

JCC=javac
SOURCE= \
	./HelloWorld/Hello.java

TARGET= HelloWorld

CLASS=Hello

DEBUG= -g

all: compile run

compile:
	$(JCC) $(DEBUG) $(SOURCE)

jar:
	jar cfm $(CLASS).jar Manifest.txt  $(TARGET)/$(CLASS).class


run:
	java -cp . $(TARGET).$(CLASS)

runjar:
	java -jar $(CLASS).jar

São dois pontos importantes para discusão.

A criação do jar pelo comando:

jar cfm $(CLASS).jar Manifest.txt $(TARGET)/$(CLASS).class

O jar é o pacote responsável pela criação dos pacotes jar.

No exemplo seguinte, vemos o pacote executado

java -jar $(CLASS).jar

onde o comando testa o pacote.

Criação do Pacote

Criação do Manifest.txt, é o arquivo responsável por dizer o que é.

Manifest-version: 1.0
Created-By: 1.0 (Maurinsoft)
Main-Class: HelloWorld.Hello

Nele encontramos apenas a descrição da classe que será criada (MAIN-CLASS)

Por ultimo os fontes Hello.java

package HelloWorld;

// Meu primeiro programa
class Hello {
	public static void main(String[] args) {
        	System.out.println("Hello, World!");
        }
}

Verificamos neste artigo, que o empacotamento, de fato é uma atividade bem simples e fácil de ser realizada manualmente.

Java
Marcelo Martins , , , ,
Java sem nutela no Ubuntu

Muitas vezes em C temos que compilar o projeto na mão.

A maioria das linguagens tem essa opção, vou explicar como fazer isso sem IDE de desenvolvimento, usando o VI no java.

Instalação

Para instalar o java vamos chama o terminal

sudo apt install openjdk-17-jdk-headless

Temos agora o ambiente montado, para começar a montar nosso projeto.

Git

git do projeto montado.

https://github.com/marcelomaurin/Java-Hello-World

Criando o Hello World

Criaremos o famoso Hello World, pois existe a lenda que se não criarmos ele no começo, tudo dá errado. Então vamos seguir:

Fonte: hello.java

// Meu primeiro programa
class HelloWorld {
        public static void main(String[] args) {
                System.out.println("Hello, World!");
        }
}

Agora para testar, vamos executar ele direto, executando o script:

java hello.java

Segue o exemplo de sua execução:

Chamando o hello.java

Agora iremos criar o script para compilação:

Arquivo: Makefile

JCC=javac
SOURCE= \
        hello.java

TARGET= HelloWorld

all: compile run

compile:
        $(JCC) $(SOURCE)

run:
        java $(TARGET)

Para compilar, chamamos o make compile, e para executar o make run , conforme figura abaixo:

Debugando o java

Para debugar o fonte temos que compilar o projeto com a opção -g, conforme segue o script do Makefile alterado.

JCC=javac
SOURCE= \
        hello.java

TARGET= HelloWorld

DEBUG= -g

all: compile run

compile:
        $(JCC) $(DEBUG) $(SOURCE)

run:
        java $(TARGET)

O parametro -g, cria os espaços de debug necessários para o debug.

Ao compilar agora, podemos chamar o debug em Java.

O jdb é semelhante ao gdb do C, para executar o mesmo, chamamos o nosso programa conforme exemplo abaixo:

jdb HelloWorld

rodando com Debug

Podemos verificar que o código foi rodado inteiramente, pois não tinhamos breakpoints.

Para incluirmos o break point usamos o comando:

stop in [classe].[metodo]

Para rodar no debug use o comando:

run

Conforme figura abaixo:

Debug pela console

Para continuar usamos o step, e o print mostra a variavel.

Com isso, mostramos as funcionalidades básicas para analisar e rodar uma aplicação Java pelo terminal, sem necessidade de incluir uma IDE.

Espero que tenham gostado, críticas e comentários, fico no aguardo.

C/C++ Python
Marcelo Martins , , , ,
Cython – Integração entre Python e C/C++ – Segunda Parte

Neste segundo artigo, iremos criar um projeto em C, em seguida desenvolver um projeto Hello World em Python, que iremos chamar no C e compilar.

GITHUB

https://github.com/marcelomaurin/cython

Primeiramente vamos criar nosso projeto em C.

Primeiramente criamos um arquivo Makefile

CC= gcc
SAMPLE=sample.pyx
LIBS= `pkg-config --cflags --libs python3`
TARGET=hello
SOURCE= \
hello.c \
sample.c



all: clean compile install

clean:
	rm ./sample.c
	rm ./sample.h


compile:
	cython ./$(SAMPLE)
	$(CC) $(SOURCE) $(LIBS) -o ./$(TARGET)

install:
	cp ./$(TARGET) /usr/local/bin/

No exemplo acima, temos dois pontos chaves no nosso código.

A inclusão do sample.pyx que irá ser convertido em um sample.c e um sample.h, conforme script do compile.

Agora iremos mostrar o código do C, que chamará o python, nosso código: hello.c

#include <stdio.h>
#include "sample.h"

int main()
{
	call_hello();
}

Neste código vemos uma chamada para a lib sample.h, que será criada pelo cython a partir do script.

A função Call_hello é declarada já no python, e a seguir vemos como ela é apresentada.

Fonte: hello.pyx

from sam import sam

cdef public void call_hello():
	sam.hello()

Agora iremos escrever o sam.py, que será chamado:


def hello():
    print("Hello World")

Por fim, compilamos o script:

make compile

E rodamos o mesmo

./hello

Documentação de Apoio

https://riptutorial.com/Download/cython.pdf

Fóruns e Artigos coligados

Blog C/C++ Python
Marcelo Martins
Cython – Integração entre Python e C/C++

Cython é uma ferramenta de integração Entre Python e C/C++, permitindo criar interfaces integráveis entre as duas linguagens.

O uso do cython tende a auxiliar ambos os programadores dos dois mundos.

Para os programadores C/C++ o uso do python permite criar funções mais dinâmicas e rápidas de serem construídas. Permitindo acesso a tecnologias que o programador C demoraria mais para construir nas interfaces nativas.

Para o programador Python, permite utilizar todo o poder o C e C++ integrado com códigos rápidos e ágeis do Python.

Estaremos neste artigo, instalando o cython na máquina, e no próximo criando um case para que possamos utiliza-lo.

Abordaremos apenas a instalação do cython, pois entendemos que os demais ambientes são de responsábilidade dos desenvolvedores.

Instalação do Cython no Linux

Para instalar o cython é necessário ter o python 3.7 ou superior.

Caso tenha uma versão menor, será necessário atualizar sua versão.

A instalação é bem simples, basta digitar:

pip install cython

Lazarus MNote2
Marcelo Martins
Liberado a versão 2.10 Linux

Foi liberado a versão 2.10 linux, a versão 2.10 linux contem alguns ajustes na plataforma.

A versão pode ser baixada pelo repositório GIT no seguinte caminho:

https://github.com/marcelomaurin/MNote2/blob/master/bin/mnote2-2.10_amd64.deb

As modificações necessárias para compilar na 2.10 Linux, serão refletidas na 2.11 Windows.

E tratam de ajustes em macros de ambiente e modificações na integração entre synedit e TItem.

Os ajustes foram necessários pois o tamanho do ponteiro no linux do TSynedit não comportava o armazenamento de classe.

Então foi necessário modificar o Item, e o painel para armazenar o item, ao invés do Tsynedit, e desta forma referenciar ele no através do Titem.

MNote2
Marcelo Martins
MNote2 – Correções Versão 2.10

Estou preparando uma nova versão do editor MNote2.

Com algumas correções identificadas, o MNote2, vem com algumas melhorias.

  • Correção arquivos de Configuração
  • Correção nas rotinas associadas a TSynCompletion
  • Inclusão de rotinas associadas a TSynAutoComplete
  • Correção de carga de arquivos por parâmetros em prompt
  • Libs de acesso ao Banco Mysql/Postgres/Sqlite

Correção arquivos de Configuração

Este problema foi identificado, pois os arquivos de configuração estavam em pasta que exigia permissão de administrador para serem modificados.

Houve uma alteração no código dos arquivos de configuração, permitindo que os arquivos sejam gravados sem permissão especial. Tambem foi agregado condicionais de compilação (diretivas) para permitir customização caso necessário para ambientes heterogênios.

Fontes modificados:

  • setmain.pas
  • setbanco.pas
  • setFolder.pas
  • setMQuery.pas

Tipo de mudança

Foi criado uma variavel

 FPATH : string;

Foram adicionados os caminhos do FPATH, nas funções IdentificaArquivo e SalvaContexto, dos fontes acima.

Correção nas rotinas associadas a TSynCompletion

Este problema ocorre na indicação do código para apontamento da classe TSynCompletion.

O ponto correto é através da classe TItem, na propriedade synCompletion.

No código havia dois pontos divergentes.

Inclusão de rotinas associadas a TSynAutoComplete

Neste processo associado, inclui código da classe TSynAutoComplete, que é um complemento da estilização de código, onde o sistema propoem blocos associados a tipo.

Esta rotina fica criada na main.pas, mas é indicada na Item.pas.

AutoComplete : TSynAutoComplete;

O código é criado na função NovoItem, onde é criado o objeto, que posteriormente é manipulado diretamente pela classe TItem.

function TfrmMNote.NovoItem():TTabSheet;
var
   tb : TTabSheet;
   syn : TSynEdit;
   item : TItem;
   SynCompletion : TSynCompletion;
   synAutoComplet : TSynAutoComplete;
begin
  tb := pgMain.AddTabSheet();

  syn := TSynEdit.Create(tb);
  syn.Parent := tb;
  syn.Align:= alClient;
  syn.Lines.Clear;
  syn.PopupMenu := popSysEdit;
  syn.OnChange:= @synChange;
  (*Complete*)
  SynCompletion := TSynCompletion.Create(self);
  SynCompletion.Editor := syn;
  SynCompletion.OnCodeCompletion:=@SynCompletion1CodeCompletion;
  SynCompletion.OnExecute:=@SynCompletion1Execute;
  SynCompletion.OnSearchPosition:=@SynCompletion1SearchPosition;

  (*Autocomplete*)
  synAutoComplet := TSynAutoComplete.create(self);
  synAutoComplet.Editor := syn;

  tb.PopupMenu := popFechar;
  tb.Tag:= Integer(pointer(syn)); //Guarda o Sys
  tb.ImageIndex:=0;

  item := TItem.create();
  item.AtribuiNovoNome();
  item.synCompletion:= SynCompletion;    //Ponteiro de SynCompletion
  item.AutoComplete :=  synAutoComplet;  //Ponteiro de synAutocompletion

  syn.Tag:= longint(pointer(item));
  tb.Caption:= item.Name;
  pgMain.Refresh();
  application.ProcessMessages;
  result := tb;
end;

Correção de carga de arquivos por parâmetros em prompt

Neste problema, identificamos que ao tentar realizar a carga do programa por parâmetro o mesmo não era iniciado.

Após analise, identificamos que o problema do programa era associado ao painel.

O programa estava pegando sempre o item atual, desta forma ele modificava o item errado.

Uma correção foi implementada.

      tb := NovoItem();

      //tb := pgMain.ActivePage;
      syn := TSynEdit(tb.tag);
      try
        item := Titem(syn.tag);
        fSynCompletion := item.synCompletion;
        fAutoComplete := item.AutoComplete;
        syn.Lines.LoadFromFile(arquivo);

        item.ItemType := classificaTipo(arquivo);

Foi mudado o NovoItem, passando de Procedure para Function, onde passo o tb diretamente, sem necessidade de capturar.

tb := pgMain.ActivePage;

O erro era justamente na rotina acima. Que foi comentada nos testes e posteriormente apagado.

Libs de acesso ao Banco Mysql/Postgres/Sqlite

Preparação para próxima versão, onde já contempla libs de conexão de banco de dados.

Criação da Pasta Libs, contemplando arquivos de conexão há bancos de dados.

Revisão e lançamento das versões

As correções serão lançadas em master no git e estarão disponíveis na versão 2.10.

pt_BRPortuguese
en_USEnglish pt_BRPortuguese