sábado, 11 de outubro de 2014

Novo curso de FireDac - Desenvolvimento para Banco de Dados com Delphi XE7

Iniciado um novo curso de minha autoria, publicado através do portal DevMedia. O curso trata do desenvolvimento de aplicações de banco de dados com FireDac. O FireDac é uma biblioteca de componentes para acesso universal aos mais importantes bancos de dados relacionais do mercado, como SQL Server, Oracle, DB2, Firebird, SQLite, PGSQL, IB, MySQL e outros. Além disso, com ele é possível criar aplicações para Windows, Mac, Android e iOS, usando o mesmo engine de acesso. É compatível com a VCL e também com a biblioteca multi-device FireMonkey (FMX), além de estar presente na linguagem C++ do RAD Studio. É considerado o substituto do dbExpress. Comece hoje mesmo o curso. Não perca tempo e se atualize para o mercado. Caso sua empresa tenha necessidade de suporte e treinamento em FireDac e DataSnap, seja para evoluir sistemas legados em Delphi ou para qualificar a equipe de desenvolvimento, entrar em contato pelo e-mail guinther@gpauli.com.

quarta-feira, 8 de outubro de 2014

Treinamento - Infoecia - Londrina - PR

Ministrei um treinamento avançado em Delphi XE7 à equipe de desenvolvimento da Infoecia Software, na cidade de Londrina - OR. O treinamento teve como principal objetivo a evolução de sistemas Delphi, bem como o uso de técnicas de desenvolvimento ágil, programação orientada a objetos e padrões de projeto, a fim de se obterem benefícios como facilidade de manutenção, evolução, inclusão de novos requisitos, migração / evolução para novas plataformas (como Android) dentre outros. O programa do curso incluiu o seguintes tópicos: Programação Orientada a Objetos com Delphi, Técnicas de Desenvolvimento Ágil com Delphi, Refatoração - melhorando arquitetura e código, Qualidade de software e Testes Unitários, Evitando Bad Smells (problemas em código), Code Clean - programando com código limpo, Refatoração para Padrões, Design Patterns - Padrões de Projeto em Delphi, Finalizando com o desenvolvimento de aplicações Mobile para Android usando as tecnologias FireMonkey, LiveBindings, SQLite e FireDac, além dos novos recursos do IDE como o FireUI designer.

Sobre a Infoecia

esde 1995 a INFOECIA SOFTWARE vêm provendo soluções em tecnologia da informação e gestão empresarial para clientes dos mais variados portes e ramos de atividades, envolvendo as áreas comerciais, industriais, atacadistas e serviços, aumentando a qualidade e a competitividade das empresas e agilizando a obtenção do retorno do investimento em informática. Além disso, a INFOECIA SOFTWARE dispõe hoje da mais alta tecnologia para desenvolvimento de seus produtos, bem como para atendimento e suporte de seus clientes espalhados por todo o Brasil. A INFOECIA SOFTWARE é uma empresa moderna, com uma equipe de profissionais altamente capacitados e treinados para desenvolvimento de seus software e atendimento aos seus clientes de forma rápida e eficaz. Seja no suporte on-line, seja em seus treinamentos remotos, seja na eficiência da sua equipe administrativa que trabalha continuamente de forma arrojada, na busca da melhoria contínua. Nosso principal objetivo é a transformação da informação em conhecimento agregando inteligência aos negócios dos nossos clientes na busca incessante por melhores resultados.

sexta-feira, 26 de setembro de 2014

Tech Business Talk

Workshop voltado a Tecnologia, Inovação e StartUPs. Assuntos abordados: Como se começa uma empresa? Como buscar o diferencial no mercado? Exemplos práticos de como se faz software hoje, de forma ágil e funcional, usando métodos ágeis para tentar minimizar o risco do desenvolvimento de software em curtos períodos, para futuramente evoluir o sistema, etc. Com a presença de Fábio Câmara e Guinther Pauli, com suas reconhecidas trajetórias e grandes experiências que certamente trouxeram a este evento e seus participante um marcante momento de aprendizado. Fonte: Eventos Faculdade Antonio Meneghetti.




sexta-feira, 12 de setembro de 2014

Padrões de Projeto Comportamentais - Artigo Revista ClubeDelphi 160

Neste artigo publicado na Revista ClubeDelphi edição 160 mostro os padrões de projeto do tipo comportamentais (behavioral). Em especial, os padrões de projeto da categoria comportamentais são extremamente úteis para criar softwares mais fáceis de serem mantidos, evoluídos, promovendo reutilização de código, uso de boas práticas de programação orientada a objetos, redução de custos com manutenção, já que permitem que alterações em um determinado sistema de software não quebrem outras funcionalidades, reduzindo a dependência entre classes, através do uso intensivo de abstrações. Enquanto os padrões criacionais resolvem problemas relacionados à criação de objetos, e os estruturais aos modelos de estruturas de classes, os padrões comportamentais resolvem problemas relacionados principalmente à interação e comunicação entre objetos, que normalmente causam forte acoplamento e dependência. Para cada padrão de projeto, serão apresentados as suas intenções, benefícios, vantagens e participantes conforme definidos no livro do GoF. A seguir, será apresentado um exemplo prático em Delphi mostrando como criar um framework com as classes de cada padrão e uma aplicação que consome este framework. Entre os padrões apresentados está o Observer. A intenção do padrão Observer é definir uma dependência um-para-muitos entre objetos, de modo que quando um objeto muda de estado, todos os seus dependentes são notificados e atualizados automaticamente. No Delphi, a classe TComponent implementa o padrão Composite, permitindo que um objeto seja formado a partir da composição de vários outros componentes, guardando internamente uma coleção que referencia cada uma destes, chamada FComponents, do tipo TList (coleção genérica de componentes). Isto permite, por exemplo, que o Delphi implemente o mecanismo de componente “proprietário”, mais conhecido como Owner, que gerencia o ciclo de vida de um objeto conforme a composição. TComponent define ainda uma lista de observadores, armazenados no atributo FObservers, do tipo TObservers (você pode verificar esta estrutura na unit System.Classes). Podemos notar uma implementação mais antiga do padrão Observer em TComponent, através do mecanismo de Notification (notificação). O método Notification de TComponent recebe como parâmetro um componente e uma operação, do tipo TOperation (opInsert, opRemove). FreeNotication é um método que faz uso do padrão Observer para monitorar quando um componente é excluído, por exemplo, do form designer. É graças a esse mecanismo de observação que, por exemplo, quando excluímos uma instância de algum TDataSet como um ClientDataSet que esteja sendo referenciado na propriedade DataSet de um TDataSource, o mesmo receberá uma notificação informando que houve uma exclusão, removendo assim a referência ao objeto e evitando um Access Violation. Já o padrão State permite que um objeto altere seu comportamento quando seu estado interno muda. O padrão pode ser aplicado: quando o comportamento de um objeto depende do seu estado e ele pode mudar seu comportamento em tempo de execução, dependendo desse estado; operações têm comandos condicionais grandes, de várias alternativas, que dependem do estado do objeto. O Strategy tem por objetivo definir uma família de algoritmos, encapsular cada uma delas e torná-las intercambiáveis. Strategy permite que o algoritmo varie independentemente dos clientes que o utilizem. Esse padrão pode ser aplicado quando muitas classes têm propósitos semelhantes e divergem apenas no seu comportamento (implementação). Ou ainda, quando é necessário encapsular a solução para um problema resolvido por um ou mais algoritmos, dos quais classes clientes não devem tomar conhecimento. Este padrão traz alguns benefícios, como a eliminação de comandos condicionais para a seleção de um comportamento desejado (algoritmo) para resolver um problema. Ao usar herança, Strategy encapsula esses comportamentos em subclasses e usa polimorfismo (que é dinâmico) para substituir as condicionais estáticas, abrindo inclusive a arquitetura para fácil inclusão de novas estratégias para solucionar o mesmo problema. Vamos a um exemplo no próprio Delphi. A classe TDataSource possui uma referência a um TDataSet, a qual existe desde o Delphi 1, portanto, adaptável a mudanças (estamos no XE6 e ela ainda existe). TDataSet é uma abstração, que possui dezenas de implementações concretas. Quando você chama o método Post, por exemplo, de qualquer tipo de TDataSet, está na verdade chamando um método virtual polimórfico. Normalmente, quando construímos formulários base de cadastro em Delphi, colocamos apenas um TDataSource em tela, mantendo TDataSets de acesso a dados separados em um TDataModule. Estes TDataSets são implementações concretas da abstração, como TClientDataSet (DataSnap), TADOQuery (ADO) ou TFDQuery (FireDac). Agora imagine que neste formulário base você precisa invocar o método Post para gravar os dados do formulário, de forma a tornar a implementação aberta independente de qual engine de acesso a dados utiliza. Facilmente podemos fazer uma chamada como DataSource1.DataSet.Post(). Ou seja, chamamos o método Post do DataSet que está sendo atualmente referenciado pelo TDataSource do formulário base, não importa qual tipo de TDatSet seja (TClientDataSet, TFBQuery etc). Em tempo de execução, o método Post da correta classe concreta será invocado, através de polimorfismo, sem a necessidade de testes condicionais. Veja que neste caso, TDataSource “esconde” a estratégia de gravação usada para persistir dados de Data Controls a ele vinculados, algo muito semelhante ao que sugere o padrão Strategy. De fato, se feita uma boa arquitetura, é perfeitamente possível substituir todo um engine de acesso a dados mantendo formulários intactos. Você troca de um TADOQuery configurado para persistir dados em um banco SQL Server por um TFDQuery, dessa forma, fazendo o intercâmbio dos “algoritmos”, atingindo o mesmo resultado esperado (gravar no SQL Server) usando uma outra estratégia. O Template Method tem por objetivo definir o esqueleto de um algoritmo em uma operação, postergando alguns passos para as subclasses. Template Method permite que as subclasses redefinam certos passos de um algoritmo sem mudar a estrutura do mesmo. Este padrão pode ser aplicado quando existe um algoritmo que resolve um problema a partir de uma série de operações (partes), chamadas da mesma forma, porém estas formas podem variar. Esta variação é então explicitada em subclasses, usando polimorfismo. Um método na classe base nesse caso funciona como um “template”, que chama operações em pontos específicos do código, de forma apropriada. Subclasses então apenas se encarregam de dar uma forma concreta a estes pontos já chamados. É uma espécie de inversão de controle, pois nesse caso é a classe base que chama indiretamente métodos das classes filhas, e não o contrário. Um benefício do uso do padrão é evitar redundância de código, nesse caso, a chamada a vários métodos em sequência. E finalmente, o artigo mostra o padrão Visitor. Este padrão tem por objetivo representar uma operação a ser executada nos elementos de uma estrutura de objetos. Visitor permite definir uma nova operação sem mudar as classes dos elementos sobre as quais opera. Este padrão pode ser aplicado quando é necessário executar operações em objetos concretos, porém esses objetos contêm uma estrutura com muitas classes com interfaces diferentes. Ou seja, no caso em que essas operações distintas necessitam ser executadas sem causar um acoplamento entre a classe cliente e elementos concretos. A solução proposta por este padrão consiste na criação de duas hierarquias de classes, uma para os elementos que recebem as operações e outra para os visitantes que definem as operações. Este padrão traz benefícios como a facilidade na adição de novas operações que dependem de objetos complexos. Clique aqui para ler o artigo completo.

segunda-feira, 1 de setembro de 2014

Tech Business Talk

Participe no Tech Business Talk, dia 27 de Setembro de 2014, das 9am as 7pm, a ser realizado na Faculdade Antonio Meneghetti, localizada no Centro Internacional de Arte e Cultura Humanista Recanto Maestro, com a presença de Guinther Pauli e Fabio Camara. Entre os assuntos abordados, estão Inovação Tecnológica, Gestão de Times, Start Ups e Liderança. Realização do Curso de Sistemas de Informação da AMF.



quinta-feira, 28 de agosto de 2014

Treinamento - HCAA - Hospital de Caridade Dr. Astrogildo de Azevedo

Ministrei um treinamento avançado em Delphi XE6 à equipe de desenvolvimento do HCAA - Hospital de Caridade Dr. Astrogildo de Azevedo, na cidade de Santa Maria - RS. O treinamento teve como principal objetivo a migração e evolução da atual solução da instituição para versões mais atualizadas do Delphi, incluindo migração de tecnologias de acesso a dados, adaptações na arquitetura a fim de facilitar a inclusão de novas plataformas como Web e Mobile, bem como o uso de técnicas de desenvolvimento ágil, programação orientada a objetos e padrões de projeto, a fim de se obterem benefícios como facilidade de manutenção, evolução, inclusão de novos requisitos, migração / evolução para novas plataformas dentre outros. O programa do curso incluiu o seguintes tópicos: Programação Orientada a Objetos com Delphi, Abstração, Polimorfismo, Herança e Encapsulamento, Delegação, Associação, Composição, Interfaces, Classes Estáticas, Classes Helpers, Generics Diretivas de Compilação, Tratamento Estruturado de Exceções, Pacotes, BPLs, Componentes e Modularização, Auditoria e Métrica de Código, Modelagem Orientada a Objetos e UML, Técnicas de Desenvolvimento Ágil com Delphi, Refatoração - melhorando arquitetura e código, Qualidade de software e Testes Unitários, Evitando Bad Smells (problemas em código), Code Clean - programando com código limpo, Refatoração para Padrões, Design Patterns - Padrões de Projeto em Delphi, Abstract Factory, Factory Method, Singleton, Template Method, Facade, Composite, Proxy, Adapter, Strategy, Chain of Responsibility, Observer, Acesso a Dados no Delphi e Multicamadas, Modelo Client/Server vs. MultiTier (Multicamadas), ClientDataSet, FireDac e DataSnap, Migração do BDE Oracle para FireDac, REST, Web Services, XML e  JSON, Novidades do Delphi XE2, XE3, XE4, XE5 e XE6, CodeSite, FinalBuilder, AQTime, Documentação, SVN, Controle de Versão, Gerência de Configuração, FireMonkey, Visual Live Bindings, Desenvolvimento Web e Mobile.

Se o time de desenvolvimento de sua empresa também estiver interessado em treinamentos, seja para capacitação, reciclagem, evolução, migração e manutenção de sistemas Delphi, entre em contato pelo email guinther@gpauli.com



quarta-feira, 27 de agosto de 2014

Pós-Graduação em Programação e Gestão em Tecnologia da Informação - Horus Faculdades

O curso de Pós-Graduação em Programação e Gestão em Tecnologia da Informação da Horus Faculdades, de Pinhalzinho - SC, contou com uma disciplina ministrada por mim, sobre a Programação Orientada a Objetos com Delphi, incluindo técnicas avançadas e boas práticas. Especial atenção dada ao correto emprego dos princípios SOLID, o uso e aplicação prática dos Padrões de Projeto - Design Patterns, uso de técnicas de desenvolvimento Ágil como Refatoração e Testes, além de exemplos práticos que mostraram os conceitos básicos da POO como Abstração, Encapsulamento, Herança e Polimorfismo, além da Delegação. Outros tópicos foram abordados, como utilização de Interfaces, Generics, Coleções, Pacotes, Componentes, RTTI, Live Bindings, um estudo aprofundado da hierarquia das classes do núcleo da VCL e FireMonkey, incluindo TObject, TPersistent, TComponent, TControl etc. A disciplina contou com a participação de profissionais de empresas da região, incluindo JB Software, Agência4, Grupo Dass, Zetta Brasil Web Sites e Sistemas de Gestão, Cresol Central SC/RS, Eletro Zagonel, Ceraçá e H2J Innovative Solutions.

Participação recebeu destaque na imprensa local

Referência no Brasil em Delphi ministra aula na Horus Faculdades
A pós-gradução em Programação e Gestão da Tecnologia da Informação da Horus Faculdades recebeu para aula no último fim de semana (13 e 14/06) o professor Guinther Pauli, considerado uma das maiores referências do Brasil em linguagem de programação Delphi. A disciplina ministrada foi Programação orientada a objeto com Delphi. Guinther Pauli possui diversas certificações e é autor do livro Delphi - Programação para Banco de dados e Web. Além de extensa publicação, o professor foi um dos responsáveis pela criação do software de gerenciamento das contribuições do programa Criança Esperança, realizado pela ONU, com apoio da rede Globo. Para o coordenador do curso de sistemas de informação, professor Eduardo Urnau, receber o professor Guinther Pauli foi uma honra pelo conhecimento e número de certificações que possui. “A presente do professor Guinther vem contribuir ainda mais com a qualidade da pós-graduação da Horus Faculdades e com a formação dos profissionais que participam dela”, destacou. O objetivo da explanação da aula, segundo o professor Guinther Pauli, foi atualizar os participantes com programação a programação orientada a objeto, em virtude da grande predominância, entre os programadores, da criação de softwares a partir de casos de uso. “Com a programação orientada a objeto, o software se torna melhor, com uma base mais sólida, podendo ter mais atualizações ou novos componentes”, explicou.
Fonte - Jornal A Sua Voz


terça-feira, 26 de agosto de 2014

Treinamento - JB Software

Ministrado um treinamento na JB Software na cidade de Pinhalzinho - SC, capital nacional da amizade. O encontro, que contou com a participação dos engenheiros da equipe de desenvolvimento e gerência da empresa, tratou da evolução e manutenção de aplicações Delphi, incluindo o emprego de técnicas de refatoração, padrões de projeto, refatoração para padrões de projeto e técnicas de desenvolvimento ágil.




Sobre a JB Software

Tendo em mente encontrar algo que facilitasse o dia-a-dia dos escritórios de contabilidade de três irmãs e da esposa, o contador por formação, Roque Bach, em 1990 começou por "hobby", em suas horas vagas, a criar um programa para computador, enfocando a área contábil, (visando proporcionar uma maior agilidade e facilidade no cotidiano dos escritórios contábeis). Até meados de 1993 o aplicativo então criado, denominado JB Software, foi usado nos escritórios da família: em Maravilha no de Elisabete Jussara e Bernadete Bach e em Pinhalzinho por Luísa Cecília Rüdiger Bach e Salete Bach. Vendo a qualidade do sistema e vislumbrando uma grande oportunidade de negócios neste ramo, foi convidado o Sr. Júlio Roberto Rüdiger, o qual em setembro de 1993 passou a integrar o grupo a fim de atuar no departamento comercial, instalação e suporte técnico da aplicação. A partir desta data a programação foi transferida para Srta Elisabete Bach (Bete), que na época continuou na administração de seu escritório em Maravilha. De "hobby" o programa JB entrou em escala industrial, competindo de igual para igual com as maiores "softhouses" do segmento contábil do país. A empresa disparou comercialmente, embalada pelo sistema inovador criado. O destaque estava em ser o primeiro software no país com integração instantânea (on line) entre os aplicações de: Contabilidade, Escrita Fiscal, Patrimônio, Impostos e Lalur. Desta forma, com um único lançamento o contador contemplava todos os módulos relacionados,evitando a manipulação e digitação repetitiva de documentos e dados. Novos mercados foram conquistados, concessionários adquiridos e a participação em eventos do segmento passou a ser constante. Com isso, chegou a necessidade crescente de profissionais tanto na área de consultoria, quanto na área de produção (hoje o maior Ativo da empresa). E assim, em outubro de 1995, o escritório contábil de Maravilha foi vendido, quando a Srta Bernadete Bach passou a fazer parte da área de software, fortificando a empresa pinhalense. Hoje, passados 23 anos, a JB tem um nome. E o seu sobrenome Pinhalzinho. Com sede própria sita na Av. Belém, 2084, conta com mais de 40 colaboradores internos, mais de 30 franquias, distribuídas no território nacional, com alocação de mais de 250 colaboradores. Atualmente possui mais de 10000 sistemas instalados, levando o nome de Pinhalzinho - Capital da Amizade - para todo Brasil. Agora a JB comemora seu sucesso nos bastidores do mundo empresarial regional, pois suas atividades não são visíveis uma vez que não se vêem chaminés, barracões industriais, movimentação de materiais, caminhões ou operários, o que existe no entanto, e é uma realidade, é um sistema de qualidade, criado em Pinhalzinho. É a Inteligência colocada a serviço da classe contábil/empresarial. Todo o trabalho e esforço foi coroado quando a empresa sagrou-se Campeã do Premio Talentos Empreendedores 2008, sendo assim reconhecida como MELHOR empresa de médio porte do ramo de Tecnologia da Informação no estado de Santa Catarina.

domingo, 24 de agosto de 2014

SQL Server e .NET: Performance de acesso a Dados

Nesse video mostro como melhorar a performance de aplicações de acesso a dados com .NET e SQL Server. São apresentadas dicas simples, voltadas a desenvolvedores que não têm tanta experiência em database administration (DBA), como análise dos planos de execução, uso correto de índices, tipos de índices, boas práticas na escrita de comandos SQL, boas práticas na criação de Views, Triggers e Stored Procedures, entre outras dicas gerais de desempenho como campos LOB, Full Text Search, Fetch on Demand, cursores e tempo de execução (query cost). Dicas simples que podem fazer a diferença na performance da solução como um todo.

quarta-feira, 30 de julho de 2014

Consumindo objetos Win32 a partir de aplicações .NET

Nesse video mostro como consumir objetos Win32 a partir de aplicações .NET. Mostra como criar uma classe utilizando uma plataforma e linguagem para Win32 seguindo o padrão COM (Component Object Model), a seguir, mostra como consumir esta classe (chamada co-class) importando sua biblioteca de tipos, o que chamamos de type library. Uma classe proxy é então gerada para facilitar o consumo dos métodos do objeto a ser acessado, facilitando a interoperabilidade entre as diferentes plataformas. Usando essa abordagem, não é necessário redeclarar cada um dos métodos da interface da type library, podendo ainda o vínculo ser feito estaticamente com apoio do Intellisense do Visual Studio.

quarta-feira, 23 de julho de 2014

Padrão de Projeto State na prática com .NET / C#

Nesse video mostro como trabalhar como criar um pequeno sistema de processamento de folha de pagamento de funcionários de uma empresa - setor de RH. Mostra como criar um framework que define colaboradores e suas classes descendentes, através de herança e abstração. Um método polimórfico então permite calcular o salário de cada colaborador de acordo com sua função (Estagiário, Funcionário, Gerente etc.). O problema ocorre quando um colaborador muda de cargo, ou seja, passa da situação de estagiário para funcionário. O estado deste objeto, como as informações sobre nome, CPF e data admissão permanecem os mesmos, porém a regra de cálculo, que é o método polimórfico, precisa mudar. Como separar neste caso estado e comportamento? A solução é aplicar o padrão de projeto State para prover a delegação polimórfica externa deste cálculo.

terça-feira, 22 de julho de 2014

Unit Tests - Testes Unitários com .NET

Nessa video mostro como trabalhar com testes unitários na plataforma .NET através da integração presente no IDE do Visual Studio. Testes automatizados provam que funcionalidades estão corretamente implementadas. Testes mantêm seu valor com o passar do tempo. Permitem que outras pessoas verifiquem se o software ainda está funcionando após mudanças. Melhora a confiança e a qualidade da aplicação. A filosofia é deixar que os desenvolvedores escrevam os testes e tornar fácil o desenvolvimento de testes. Inicie com “o mais simples que possa funcionar”, faça primeiro o teste e depois escreva o código para passar neste teste. Refine o projeto através do uso de padrões e aplicação de refatorações constantes. Tentar quebrar o ciclo: mais pressão, menos testes, gastando menos tempo com atividades de depuração.

sexta-feira, 18 de julho de 2014

Serializando Objetos em XML com C#

Nesse video mostro como serializar objetos escritos em C# para arquivos XML, usando a classe XmlSerializer do namespace System.Xml.Serialization. Mostra como criar uma classe Cliente definindo seus respectivos atributos, bem como uma relação de Contatos (1 para muitos), representado por uma coleção genérica. A classe XmlSerializer através do método Serialize e um objeto StreamWriter pode então persistir seu estado em disco, mantendo a hierarquia de relação entre cliente e contatos. O processo inverso também é mostrado, como desserializar objetos usando o método Deserialize usando um objeto FileStream.

quarta-feira, 16 de julho de 2014

POO e Desenvolvimento Ágil no Delphi XE6 - Artigo Revista ClubeDelphi 158

Neste artigo publicado na Revista ClubeDelphi edição 158 mostro alguns recursos de programação orientada a objetos com Delphi, como herança, abstração e polimorfismo, aplicados em um exemplo prático. Através do uso de boas práticas, veremos como estes fundamentos podem tornar um software mais fácil de ser mantido e evoluído, usando ainda algumas técnicas de desenvolvimento ágil associada a design patterns, como a refatoração rumo a padrões de projeto. Veremos como resolver problemas comuns encontrados em código fonte (bad smells, ou “maus cheiros”), usando uma abordagem de desenvolvimento corretiva e evolutiva. Uma introdução ao desenvolvimento ágil evolutivo é apresentada, como forma de unir estas técnicas de orientação a objeto com as técnicas atuais de engenharia de software, demonstradas em um exemplo prático com Delphi XE6.

quinta-feira, 10 de julho de 2014

ADO .NET: Performance no Acesso a Dados

Nesse video mostro como melhorar a performance de acesso a dados em aplicações com Visual Studio e C#. As técnicas apresentadas incluem o uso de cache, cursores undirecionais, stored procedures, relacionamentos, datasets, visualizações de dados, parâmetros e filtros em memória, a fim de otimizar o desempenho de aplicações Web, que possuem um nível crítico de performance. O video mostra como detectar estes gargalos de performance e aplicar as soluções ideais para resolver estes problemas, otimizando o resultado da solução como um todo, usando recursos nativos da plataforma .NET.

quarta-feira, 9 de julho de 2014

Bad Smells (Code Smells)

Nesse video mostro o que são os bad smells (“mau cheiros”) no código, que dificultam a sua manutenção. O video apresenta um catálogo dos principais bad smells presentes no código, que são estruturas que precisam ser refatoradas, ou seja, ter sua arquitetura melhorada sem alterar o comportamento externo observável, a fim de tornar o sistema de software mais fácil de manter, evoluir e incluir novas funcionalidades, livre de bugs. Entre os principais bad smells podem citar: código duplicado, legibilidade, complexidade e sentenças condicionais. O video apresenta também a solução (refatoração) para cada um destes problemas.

quarta-feira, 2 de julho de 2014

Packet Records em ambiente Multicamadas / DataSnap

Nesta videoaula mostro como utilizar o recurso de PacketRecords em ambiente multicamadas com o novo DataSnap. Apresenta como funciona a obtenção de pacotes sob demanda e como o life cycle do DSServer influencia no uso deste recurso. Mostra como usar o uso de pacotes com fetch automático e usando o método GetNextPacket do ClientDataSet. PacketRecords permitem otimizar o tráfego de registros entre servidor de aplicação e cliente, mas deve ser usado com cuidado, pois ele prende o cursor de dados no servidor de banco de dados (SGBD), apesar de IAppServer oferece mecanismos stateless para recuperar o estado do cursor sem prendê-lo.

terça-feira, 1 de julho de 2014

Criando o Banco de Dados - CRUD com FireDAC, Firebird e DataSnap

Nesta videoaula mostro como construir uma aplicação de cadastro de produtos e relacionamento, com a implementação das operações CRUD (Create / Insert, Read / Retrieve, Update e Delete) usando os componentes de acesso do novo FireDAC do Delphi XE5 / XE6. Mostra a criação do banco de dados com as tabelas e views no Firebird, bem como as constraints. Mostra a configuração da conexão no Data Explorer do IDE do Delphi e também do Connection Definition no Firedac Explorer. Dessa forma, deixaremos a arquitetura independente do DBExpress, que após a introdução do Firedac, deixou de ser o principal engine de acesso a dados do Delphi.

terça-feira, 24 de junho de 2014

Versionando Assemblies no GAC e evitando o DLL Hell em .NET

Neste video mostro como trabalhar de forma correta com o versionamento e assinatura de assemblies (strong names e keys) na plataforma .NET com Visual Studio e C#. O recurso permite definir uma versão (ex. 1.0.0.0) para um determinando assembly (ex. DLL ou EXE) e a seguir fazer com que outros assemblies utilizem a versão “assinada” pelo manifesto de assembly, evitando o problema de uma diferente versão de uma mesma DLL quebrar funcionalidades de outros aplicativos que a usam, problema conhecido como DLL Hell. Mostra como a plataforma .NET resolve isto através do uso do GAC - Global Assembly Cache.

domingo, 22 de junho de 2014

Criando Class Helpers em .NET

Publicado no portal DevMedia um video onde mosto como criar Class Helpers em C#, que permitem reduzir a duplicação de código, através da definição de classes e funções que encapsulam a complexidade de tarefas cotidianas, como enviar e-mails, executar comandos no banco de dados, abrir arquivos, o que normalmente tende a replicar código, pois várias classes precisam realizar tarefas únicas para se obter um comportamento final. A técnica de criação de Helpers é muitas vezes associada a aplicação do padrão de projeto - design pattern - conhecido como Facade, que encapsula a complexidade de um framework tornando o mais simples de utilizar. Clique aqui para visualizar.

Relacionamentos N para N com Entity Framework

Publicado um video no portal DevMedia onde mostro como trabalhar com relacionamentos N para N no Entity Framework 6.1 no Visual Studio em projetos C#. O recurso permitirá associar duas entidades de acordo com uma multiplicidade muito para muitos (* *), de forma que uma ocorrência em uma entidade condiciona a existência de vários objetos relacionados em outra, que também possui N correspondências na entidade de origem. Por exemplo, um pedido que possui N produtos e produtos que estão presente em N pedidos. O video mostra como definir este tipo de relação na modelagem de modelos do EF e como isto é transformado em tabelas de um sistema relacional no SQL Server. Clique aqui para acessar.

quinta-feira, 12 de junho de 2014

Associação e Tipos Complexos no Entity Framework

Publicado no Portal DevMedia um video onde mostro como trabalhar com associações no Entity Framework 6.1 no Visual Studio em projetos C#. O recurso permitirá associar duas entidades de acordo com uma data multiplicidade, por exemplo, 1 para N (*), criando-se uma relação master-detail. O video mostra como o EF é capaz de gerenciar toda a complexidade para inserir dados relacionados no banco de dados, manipulando chaves primárias, foreign keys e mantendo a integridade da relação, tudo em um nível abstraído de orientação a objetos, ocultando detalhes inerentes ao SQL Server. Já os tipos complexos permitem criar subtipos formados a partir de tipos primitivos que são agregados a uma entidade no  Entity Framework, reaproveitando código. Clique aqui para acessar o video (somente para assinantes).

quarta-feira, 11 de junho de 2014

Herança no Entity Framework: do modelo Orientado a Objetos ao Sistema de Banco de Dados Relacional

Publicado um video no Portal DevMedia onde mostro como trabalhar com o recurso de herança entre entidade do Entity Framework 6.1 no Visual Studio em projetos C#. Isso permite o maior reaproveitamento de código, visto que atributos comuns podem ser herdados de classes superiores. Porém, mostramos também que o uso de herança no Entity Framework, assim como na OO, pode criar complexidade extra, principalmente porque no Entity Framework, dependendo da estratégia de geração de código, cada herança será mapeada para uma relação de foreign key (1 para 1) no SQL Server ou banco utilizado, exigindo o uso de joins. Lembrando que herança é um recurso da orientação a objetos e não existe equivalência direta em bancos de dados relacionais tradicionais. O video mostra como fazer esta relação de herança, ressaltando os benefícios, cuidados e vantagens. Clique aqui para visualizar (acesso somente para assinantes).

quinta-feira, 5 de junho de 2014

Definindo Arquitetura de Soluções em Camadas em C#

Publicado um video no Portal DevMedia onde mostro como definir a arquitetura de soluções em camadas de projetos C# com Visual Studio, usando as ferramentas de Layer Diagram e Architecture. Em cima de um cenário, que demonstra a complexidade de se distribuir diferentes tipos de aplicações clientes na internet usando diferentes tecnologias e plataformas, o video mostra como um arquiteto de software pode definir uma solução ótima para um determinado problema, identificando corretamente as camadas e como elas se relacionam e trocam informações, como o servidor de aplicação, banco de dados, aplicações clientes, web, e protocolos.

quarta-feira, 4 de junho de 2014

Collections em C# - ArrayList, HashTable, List, Dictionary, Stack e Queue

As coleções em .NET desempenham um papel fundamental no tratamento de conjuntos de objetos em memória, dispensando o uso de arrays primitivos, propiciando alocação dinâmica de memória e vários métodos para manipulação de dados. As principais coleções da plataforma .NET estão concentradas nos namespaces System.Collections e System.Collections.Generics. Coleções do tipo ArrayList são simples e não tipadas (no sentido de não serem genéricas), têm crescimento dinâmico, implementam a interface IEnumerable, armazenam objetos (Object), possuem métodos para adição, remoção etc. Porém, não consegue tipar objetos ao armazenar, logo é necessário type casting para remover (operador AS), ou se usa reflexão. São estruturas mais fáceis de trabalhar do que comparadas a vetores tradicionais com sintaxe primitiva e controle manual de alocação e dimensões, a alocação é gerenciada pela CLR do .NET Framework. Já List é genérica, é uma coleção tipada com uso de Generics, tem crescimento dinâmico, implementa a interface IEnumerable, armazenam qualquer tipo de objeto, porém com informação estática de tipo, possuem métodos para adição, remoção etc, além de métodos adicionais através de extensões LINQ e lambda expressions, porém com informações de tipo. Permitem o uso de delegates genéricos e expressões lambda para operações comuns, escritas normalmente em uma linha, como buscar objetos que satisfação determinada condição. Possuem melhor performance do que arraylists. HashTables funcionam como “tabelas” simples não tipadas em memória em aplicações C#, têm crescimento e alocação de memória dinâmica, são baseadas no conceito de par de chave / valor (key pair value), armazenam objetos (Object) tanto para Key quanto Value. Não consegue tipar objetos ao armazenar, logo é necessário type casting para remover, ou reflection. São estruturas rápidas para recuperar valores, já que os valores (value) são buscados na tabela hash diretamente pelo valor da sua chave (key). Dictionary, ou dicionários, funcionam como “Tabelas” simples, porém tipadas em memória em aplicações C# através do uso generics, têm crescimento e alocação de memória dinâmica, são baseadas no conceito de par de chave / valor (key pair value), armazenam objetos tipados tanto para Key quanto Value. São estruturas rápidas para recuperar valores, já que os valores (value) são buscados na tabela hash diretamente pelo valor da sua chave (key). Basicamente é uma combinação de List com HashTable. Pilhas (stacks) em C# são um tipo especial de coleção (collection) na plataforma .NET. Stacks são coleções que permitem “empilhar” objetos. Possuem a versão clássica chamada Stack, que trabalha com objects, a versão Stack (genérica). Segue o modelo LIFO – Last In First Out, ou seja, o último elemento e entrar é o primeiro a sair. Possui os métodos Push – Adicionar elemento; Pop – Lê e retira elemento; Peek– Lê mas não retira elemento. Também possuem alocação dinâmica de memória e podem armazenar diferentes tipos de objetos, porém necessita de type cast ao remover o objeto. Queues (filas) em C# possuem a versão clássica chamada Queue, que trabalha com objects, a versão Queue (genérica). Segue o modelo FIFO – First In First Out, ou seja, o primeiro elemento e entrar é o primeiro a sair. Possui os métodos Queue – Adicionar elemento; Dequeue – Lê e retira elemento; Peek– Lê mas não retira elemento. Também possuem alocação dinâmica de memória e podem armazenar diferentes tipos de objetos, porém necessita de type cast ao remover o objeto. A versão genérica já permite tipar o objeto.  Foram publicadas videoaulas no portal DevMedia que mostram como usar estas coleções na prática, clicando nos links (somente para assinantes): ArrayList List HashTable Dictionary Stack Queue

Exemplos de uso:

ArrayList

var turma = new ArrayList();
turma.Add("Guinther");
turma.Add("Rudolfo");
turma.Add(new DataSet()); // é possível colocar qualquer objeto
foreach (var item in turma)
  Console.WriteLine(item);
// a capacidade é alocada por páginas
Console.WriteLine("Capacidade: " + turma.Capacity); 
// count é o número real de elementos
Console.WriteLine("Count: " + turma.Count);
List
public class Cliente: Object
{
  public int Codigo;
  public string Nome;
  public string CPF;
  public override string ToString()
  {
    return Codigo.ToString() + " - " + Nome;
  }
}
class Program
{
  static void Main(string[] args)
  {
    // cria três clientes
    var c1 = new Cliente() { Codigo = 123, Nome = "Guinther", CPF = "123" };
    var c2 = new Cliente() { Codigo = 234, Nome = "Rudolfo", CPF = "456" };
    var c3 = new Cliente() { Codigo = 456, Nome = "Fabio", CPF = "789" };
    // adiciona com collection intializer
    var lista = new List<Cliente>() { c1, c2, c2 };
    // também poderia adicionar um por um
    //lista.Add(c1);
    //lista.Add(c2);
    //lista.Add(c3);
    // mostra o CPF do primeiro cliente
    Console.WriteLine(lista[0].CPF);
    // varre coleção, mostra item, ToString com override mostrará todos os dados
    foreach (var item in lista)
      Console.WriteLine(item);
    // expressão lambda para obter cliente com determinado CPF
    var cli = lista.FirstOrDefault(c => c.CPF == "456");
    Console.WriteLine(cli.Nome);
  }
}

HashTable

public class Aluno
{
  public int Matricula;
  public string Nome;
  public override string ToString()
  {
    return Matricula.ToString() + ":" + Nome; 
  }
}
class Program
{
  static void Main(string[] args)
  {
    var alunos = new Hashtable();
    var a1 = new Aluno() { Matricula = 123, Nome = "Guinther" };
    var a2 = new Aluno() { Matricula = 456, Nome = "Rudolfo" };
    alunos.Add(123, a1);
    alunos.Add(456, a2);
    // mostra aluno com key = 123, necessário type cast
    Console.WriteLine((alunos[123] as Aluno).Nome);
    // método para verificar se lista contém objeto com chave
    if (lista.ContainsKey(123))
      Console.WriteLine(lista[123]);
    // varredura pelas chaves
    foreach (var obj in lista.Keys)
      Console.WriteLine(obj);
    // varredura pelos values
    foreach (var obj in alunos.Values)
      Console.WriteLine(obj);
  }
}

Dictionary

public class Pedido
{
  public int CodPedido;
  public string Cliente;
  public double Valor;
}
class Program
{
  static void Main(string[] args)
  {
    var pedidos = new Dictionary<int, Pedido>();
    var p1 = new Pedido() { CodPedido = 1, Cliente = "Guinther", Valor = 1234.56 };
      var p2 = new Pedido() { CodPedido = 2, Cliente = "Rudolfo", Valor = 3456.23 };
      var p3 = new Pedido() { CodPedido = 3, Cliente = "Fabio", Valor = 6789.01 };
    pedidos.Add(1, p1);
    pedidos.Add(2, p2);
    pedidos.Add(3, p3);
    Console.WriteLine("Nomes dos clientes que fizeram pedidos:");
    foreach (Pedido p in pedidos.Values)
      Console.WriteLine(p.Cliente);
    Console.WriteLine("Pedidos:");
    foreach (KeyValuePair<int, Pedido> kvp in pedidos)
      Console.WriteLine(kvp.Key + " = " + kvp.Value.Cliente);
    Console.WriteLine("Soma dos pedidos:");
    var valor = pedidos.Sum(p => p.Value.Valor);
    Console.WriteLine(valor.ToString());
  }
}

Stack

public class Documento
{
  public int Codigo;
  public string Tipo;
  public string Nome;
}
class Program
{
  static void Main(string[] args)
  {
    // LIFO - Last in First Out
    var d1 = new Documento() { Codigo = 1, Nome = "Planilha", Tipo = "xls" };
    var d2 = new Documento() { Codigo = 2, Nome = "Artigo", Tipo = "doc" };
    var d3 = new Documento() { Codigo = 3, Nome = "Apresentacao", Tipo = "ppt" };
    var pilha = new Stack<Documento>();
    pilha.Push(d1);
    pilha.Push(d2);
    pilha.Push(d3);
    var obj = pilha.Pop();
    while (pilha.Count > 0)
      Console.WriteLine(pilha.Pop().Nome);
    Console.WriteLine(pilha.Count);
    // Pop obtém o objeto e retira da pilha
    var obj1 = pilha.Pop();
    Console.WriteLine(obj1.Nome);
    var obj2 = pilha.Pop();
    Console.WriteLine(obj2.Nome);
    Console.WriteLine(pilha.Count);
   // Peek obtém o objeto e mantém da pilha
    var obj3 = pilha.Peek();
    Console.WriteLine(obj3.Nome);
    Console.WriteLine(pilha.Count);
  }
}

Queue

public class Correntista
{
  public string Agencia;
  public string Conta;
  public string Nome;
  public override string ToString()
  {
    return "Agência: " + Agencia + " - Conta: " + Conta + " - " + Nome;
  }
}
// Programa que simula uma fila de correntistas aguardando chamada
class Program
{
  static void Main(string[] args)
  {
    var p1 = new Correntista() { Agencia = "123", Conta = "456", Nome = "Guinther" };
    var p2 = new Correntista() { Agencia = "456", Conta = "123", Nome = "Rudolfo" };
    var p3 = new Correntista() { Agencia = "789", Conta = "000", Nome = "Fabio" };
    var fila = new Queue<Correntista>();
    fila.Enqueue(p1);
    fila.Enqueue(p2);
    fila.Enqueue(p3);
    //fila.Enqueue(10); // não pode porque agora é tipada
    Console.WriteLine("Correntistas aguardando na fila:");
    foreach (var c in fila)
      Console.WriteLine(c);
    Console.WriteLine("Primeiro da fila: " + fila.Peek().Nome);
    while (fila.Count > 0)
    {
      Console.WriteLine("Pressione uma tecla para chamar correntista");
      Console.ReadKey();
      Console.WriteLine("Chamando: " + fila.Dequeue());
    }
    Console.WriteLine("Fila vazia");
  }
}

terça-feira, 3 de junho de 2014

Before Update Record e o processo de Resolving em DataSnap

Veja nessa videoaula publicada no portal DevMedia como utilizar o evento BeforeUpdateRecord do DataSetProvider para receber atualizações enviadas em data packets pela aplicação cliente, de forma a serem manipulados no app server antes que essas modificações sejam realmente efetivadas no banco de dados (processo conhecido como Resolving). Esse evento é ideal para alterar informações de um registro antes que as mesmas sejam aplicadas no SGBD, por exemplo, para fornecer valores default para campos, ou mesmo aplicar regras de negócio e validações centralizadas no server, sem replicação nas aplicações clientes, que não precisam ser alteradas / recompiladas / redistribuídas caso a regra mude.
Abaixo um exemplo da arquitetura de funcionamento do processo de Providing, Resolving e Reconcile do DataSnap.





















Abaixo um exemplo de código com os parâmetros passados para o evento e alteração feita em um registro:

procedure TSM.dspBeforeUpdateRecord(
  Sender: TObject;
  SourceDS: TDataSet; // dataset apontado pelo DSP
  DeltaDS: TCustomClientDataSet; // registro modificado
  UpdateKind: TUpdateKind; // tipo de atualização
  var Applied: Boolean // true se você atualizou manualmente
);
begin
  // se for inserção
  if (UpdateKind = ukInsert) then 
  begin
    DeltaDS.Edit();
    DeltaDS.Fields[1].AsString := 'Valor Default';
    DeltaDS.Post();
  end;
end;

Mestre-detalhe em ambiente Multicamadas com DataSnap

A natureza state-less das aplicações Web ou Multicamadas faz com que se precise ter cuidado ao desenvolver aplicações com cadastros no estilo mestre-detalhe (master-detail), principalmente devido a necessidade do tratamento de transações e manutenção da integridade referencial, podendo dados de vários datasets relacionados precisarem ser colocados em cache simultaneamente. Trabalhar com vários resultsets desconectados do database e aplicar atualizações em uma única transação é vital para ambientes distribuídos que precisam obter o máximo de performance, compartilhar conexões (pool) e otimizar o consumo de recursos do SGBD. E o relacionamento master-detail é peça crítica nesse sentido. Em um relacionamento desse tipo, uma tabela detalhe estará relacionada pela chave-estrangeira com uma chave-primária da tabela master, usando o recurso de Master Source ou Data Source de um DataSet, recurso que existe no DB framework do Delphi desde a época do BDE com Paradox. No caso do TClientDataSet, pode-se utilizar um único DataPacket para guardar informações de ambos os conjuntos de dados, gerenciados em uma única transação, otimizando o uso de recursos e a comunicação na rede. Este recurso é ideal para manter o controle automático sobre os relacionamentos e filtros em aplicações DataSnap com ClientDataSets, sem a necessidade de código adicional. Outro é o uso do recurso de DataSetFields do ClientDataSet em relacionamentos Master Detail em ambientes multicamadas, usando campos TFields no DataSet que representa um conjunto inteiro de dados, que neste caso, é a tabela detalhe, fazendo parte do próprio DataSet principal (Master). Pode-se utilizar alguns recursos para modificar dados do detalhe como se fosse parte do Dataset principal. As atualizações de ambos as tabelas são então aplicadas em uma única transação gerenciada automaticamente por IAppServer, em um único DataPacket, otimizando também o tráfego de dados. Confira a solução nestes dois vídeos publicados no Portal DevMedia (somente assinantes).
DataSetField em ambiente Multicamadas
Master Detail em DataSnap

segunda-feira, 2 de junho de 2014

CONVITI - I Congresso Virtual de Tecnologia de Informação

De 23 a 29 de junho será realizado o I Congresso Virtual de Tecnologia de Informação (CONVITI), sendo que nesta primeira edição ministrarei uma palestra sobre "Desenvolvimento de Soluções Multicamadas com Delphi XE6, FireDac e DataSnap". O evento é on-line e gratuito. Clique aqui para realizar a inscrição.



quarta-feira, 28 de maio de 2014

Refatoração para Padrões de Projeto - Palestra ministrada no X Simpósio Brasileiro de Sistemas de Informação

O Simpósio Brasileiro de Sistemas de Informação é um evento para a apresentação de trabalhos científicos e discussão de temas relevantes na área de Sistemas de Informação, aproximando estudantes, pesquisadores, profissionais e empresários da comunidade de Sistemas de Informação. Os sistemas de informação são estratégicos para as organizações contemporâneas, pois automatizam os processos de negócios, construindo vantagem competitiva por possibilitar: análise de cenários, apoio ao processo de decisão, definição e implementação de novas estratégias organizacionais. Contudo, a incorporação da Tecnologia de Informação nas organizações provoca o surgimento de novos problemas que demandam pesquisas voltadas aos aspectos conceituais e práticos. As pesquisas em Sistemas de Informação combinam aspectos multidisciplinares das áreas da Ciência da Computação, Matemática, Ciência da Informação, Administração, Comportamento Organizacional, entre outras. A aplicação dos diversos domínios de conhecimento na busca por soluções aos problemas envolvendo os Sistemas de Informação é o que motiva a realização deste evento. Na edição deste ano, apresentei uma pesquisa sobre como buscar oportunidades de refatoração para aplicação de padrões de projeto, mais especificamente, para o padrão de projeto Strategy. Manter e adaptar código mal escrito apresentando problemas em sua estrutura é uma tarefa difícil. As técnicas de refatoração são usadas para melhor o código e a estrutura de aplicações, tornando-as melhores e mais fáceis de serem modificadas. Padrões de Projeto - Design Patterns - são soluções reutilizáveis usadas para resolver problemas comuns em sistemas orientados a objetos, então não é necessário recriar estas soluções. A aplicação de padrões de projeto dentro do contexto de refatorações usando uma abordagem corretiva se torna uma atividade interessante no ciclo de vida de um sistema de software. Contudo, para projetos de larga-escala, examinar manualmente os artefatos de software para encontrar problemas e oportunidades para aplicar um dado padrão de projeto é uma tarefa árdua e difícil. Nesse contexto, apresento uma função baseada em métricas que permite detectar onde um padrão de projeto pode ser aplicado em um determinado código-fonte, mais especificamente, o padrão de projeto Strategy, que usa em seu núcleo dois dos principais fundamentos da orientação a objetos: abstração e polimorfismo (além de delegação). Para avaliar a função desenvolvi uma ferramenta que avalia código-fonte e exibe possíveis oportunidades para aplicar uma refatoração rumo ao padrão Strategy. Essa ferramenta foi desenvolvida através do uso de ASTs (Abstract Syntax Trees), procurando por oportunidades de refatoração, indicando o local exato no código fonte onde o padrão é sugerido, mostrando ainda algumas evidências usadas para a detecção. A edição deste ano do simpósio foi organizada pelo Departamento de Computação da Universidade Estadual de Londrina - PR, com o apoio do CNPQ, CAPES e da Sociedade Brasileira de Computação (SBC), com patrocínio da SERPRO - Serviço Federal de Processamento de Dados.