Ganho “fácil” de performance com paralelismo
Olá, Há tempos, sou adepto de escrita de código com formato e estrutura potencialmente paralelizáveis. Hoje fui espetacularmente compensado por isso. Em meu sistema, tenho esses dois métodos: Que foram … Continuar lendo
Você sabia que C++ é tão expressivo?
Olá! C++ é uma linguagem famosa por ser difícil de aprender. Entretanto, quem a usa defende que essa “dificuldade” é mais do que compensada pelo poder do compilador e pela … Continuar lendo
Arquitetura na Prática – RavenDB
Como já anunciei, estou trabalhando com Ayende e com o time do RavenDB. Nesse post compartilho alguns detalhes de arquitetura desse software. Se você ainda não conhece o RavenDB – … Continuar lendo
Melhorando a responsividade da interface com Reactive Extensions
Olá! Estou escrevendo um compilador para uma DSL externa. Visando testar o “tokenizer”, criei uma aplicação playground simples, com um editor RTF, onde faço highlighting do código na medida em … Continuar lendo
Dynamic Code Generation in .NET (resposta a um post do Ayende)
Olá! Ainda hoje, Ayende publicou um post muito interessante em seu blog. O objetivo era, nas palavras dele: Given a Dictionary, convert that dictionary into a type in as performant … Continuar lendo
Two Loops!
Olá! Achei nas redes sociais uma referência para este post anunciando a excelente performance do código em Java quando comparado com Ruby. Escrevi uma versão do código proposto em C#. … Continuar lendo
RavenDB 101 – Parte 2 – Incluindo/modificando documentos com HTTP PUT
Olá. No post anterior, mostrei como obter o RavenDB, iniciar uma base de dados de exemplo e algumas consultas simples com HTTP. Nesse post, mostro como incluir/modificar documentos usando a … Continuar lendo
RavenDB 101 – Parte 1 – Criando um banco de dados de exemplo e fazendo consultas HTTP
Olá, Este é o primeiro post da série em que apresento os fundamentos do RavenDB. Mostro os primeiros passos para utilizar RavenDB através de HTTP. Instalando e iniciando RavenDB Para … Continuar lendo
Quando testes simples podem previnir falhas críticas
Olá. Ayende me apontou um paper bastante interessante: Simple Testing Can Prevent Most Critical Failures: An Analysis of Production Failures in Distributed Data-Intensive Systems. O paper trata de descobertas em … Continuar lendo
Parceria com Ayende e mais uma vez Microsoft MVP
Olá. Estou escrevendo esse e-mail para compartilhar duas ótimas novidades logo no primeiro dia de 2016. Para começar, fui reconhecido, mais uma vez, como Microsoft Most Valuable Professional. Sinto-me verdadeiramente … Continuar lendo
Encontrando o início de um Loop em uma Linked List
Olá! No post de hoje, vamos ver como detectar o nodo de início de um Loop em uma lista encadeada. Escolhi Java para implementação por estar estudando a linguagem. Entretanto, … Continuar lendo
Decorator Design Pattern using lambdas (C# version)
Olá. Minha proposta, nesse post, é compartilhar uma implementação em C# para o código Java disponível aqui. Recomendo fortemente que você veja o post original antes de continuar a leitura … Continuar lendo
Amazing JAVA – Parte 5 – Tipos anônimos, mas com sobrenome
Olá! Diferente de C#, tipos anônimos em Java podem implementar interfaces ou herdar de outras classes. O exemplo abaixo é extraído deste post.. No exemplo, os dois métodos estáticos retornam … Continuar lendo
Amazing JAVA – Parte 4 – Implementações default em interfaces
Olá. Continuo compartilhando features curiosas de Java. Nesse post falo sobre suporte a implementações default em interfaces. Vejamos: Como você pode ver, a interface Foo (ainda tentando me acostumar a … Continuar lendo
Amazing JAVA – Parte 3 – Static Blocks (melhor ou pior do que os construtores estáticos de C#?!)
Olá, Continuo minha “cruzada” pelo (mais do que eu esperava) desconhecido e surpreendente reino de Java. Eis que me deparo com o seguinte código: Pois bem! Java parece não ter … Continuar lendo
Amazing JAVA – Parte 2 – Ainda mais sobre Enums
Olá! No post anterior, mostrei o quanto os Enums de Java se afastam de C#. Dessa vez, vamos um pouco mais longe (outra vez, seguindo exemplo presente no excelente Effective Java): … Continuar lendo
Amazing JAVA – Parte 1 – Enums
Olá, Até que enfim consigo reunir um pouco de tempo para estudar Java! Há tempos conheço os fundamentos, mas, agora resolvi “saber de verdade”. Claro que há muitas semelhanças entre … Continuar lendo
Primeiros passos de uma empreendedora!
Olá. Nessa semana descobri que uma colega, Camila Remonato, resolveu dar um passo importante. Resolveu assumir ainda mais o “protagonismo” de sua carreira iniciando um negócio novo e muito bacana. … Continuar lendo
Primeiros passos com RavenDB
Olá, Com a aproximação do QCON SP e da participação confirmada do Ayende, resolvi aprender um pouco mais sobre RavenDB (principal produto do cara). O que é o RavenDB? Segundo … Continuar lendo
Um brinde a expressividade do TypeScript!
Olá! Estou compartilhando, todos os dias, uma “brincadeira” com TypeScript. A última foi uma breve implementação do sistema de Lindenmayer. An L-system or Lindenmayer system is a parallel rewriting system … Continuar lendo
Everyday Javascript (ou TypeScript)
Olá. Mais uma brincadeira. Vez ou outra, escrevo um Javascript que considero bacana. Vou tentar compartilhar diariamente. O primeiro já está on-line. Era isso.
Uma nova forma de me relacionar com as comunidades técnicas
Olá! Há alguns dias abri um novo espaço de comunicação: minha página pessoal, totalmente reformulada, no Github. Acesse: elemarjr.github.io. Para uma versão em inglês, acesse elemarjr.github.io/en.html Criei essa página porque … Continuar lendo
Sobre as vantagens de alguém sempre revisar seus Pull Requests
Olá. No meu último post, mostrei um passo-a-passo para implementar uma correção ao CodeCracker. Pois bem, eis o feedback que recebi para meu PR. No Code-Cracker, mesmo os committers submetem … Continuar lendo
Passo-a-passo de como corrigi um bug no Code-Cracker
Olá. Tudo certo? Nesse post mostro todas as etapas que percorri para corrigir um bug no codecracker. Escolhendo um issue para trabalhar Comecei indo até a lista de issues filtrando … Continuar lendo
Primeiros passos com .NET Core no Ubuntu
Olá. Os tempos, definitivamente, mudaram. A Microsoft, além de abrir o código de um bocado de coisas, tem feito esforço real para que suas soluções sejam compatíveis com outras plataformas … Continuar lendo
Compiladores com FluentIL: Suportando funções!
Olá, No post anterior, mostrei como suportar variáveis. Sofremos um pouquinho para escrever o parser, mas acho que valeu a pena. Agora, vamos adicionar suporte a funções (os fontes estão … Continuar lendo
Compiladores com FluentIL: Suportando variáveis
Olá, No post anterior, mostrei como suportar expressões matemáticas e lógicas facilmente graças a capacidade do FluentIL de gerar CIL a partir de strings. Agora, vamos adicionar suporte a variáveis … Continuar lendo
Um Active Pattern para reconhecer nomes válidos de variáveis. Ele poderia ser mais simples?
Olá, Veja o seguinte fragmento de código: Trata-se de um active pattern que reconhece nomes válidos de variáveis no início de uma cadeia de caracteres. Ele poderia ser mais simples?!
Compiladores com FluentIL: Expressões matemáticas e lógicas, Discriminated Unions do F# no C#
Olá. Tudo certo? No post anterior, mostrei como suportar comentários. Não havia nada de FluentIL, especificamente. O que fizemos foi criar um “parser” simples em F# que reconhecia comentários e … Continuar lendo
Compiladores com FluentIL: Algum parsing com F#
Olá. Em um post anterior, mostrei como converter um arquivo texto em executável. O que esse executável fazia era escrever o conteúdo do arquivo texto (nosso fonte) no console. Hoje … Continuar lendo
QCON SP terá mais .NET do que nunca
Olá. QCON SP tem novidades interessantes esse ano para quem utiliza tecnologia Microsoft. Para começar, há uma track específica para .NET (algo impensável anos atrás quando fui o único “MS” falando … Continuar lendo
Compiladores com FluentIL: Convertendo Texto em Executável
Olá. Gerar código executável, no braço, não é tarefa simples. Felizmente, .NET oferece uma biblioteca nativa de emitting. Infelizmente, essa biblioteca não é muito fácil de usar. FluentIL é um … Continuar lendo
Pelo retorno do VoidPodcast!
Olá amigos. Tudo bem?! Você conhece o void podcast? Gostaria que ele voltasse a ativa? Então, clique aqui e mande um tweet para sensibilizar o @leandronet. Se a gente conseguir … Continuar lendo
Um avaliador de expressões matemáticas em F# (usando Active Patterns)
Olá. Nesse post vamos implementar, passo-a-passo, um avaliador de expressões matemáticas em F#. Para isso, utilizaremos “Active Patterns” – um dos conceitos mais interessantes da linguagem. Se não está familiarizado … Continuar lendo
Quando o básico não é suficiente – Usando “HackerRank” para validar soluções do “Project Euler” (F#)
Olá. Juan Lopes (sempre ele) recomendou, em comentários de um post anterior, o HackerRank como meio de verificação das soluções que estou propondo para os desafios do “Project Euler“. Resolvi seguir a … Continuar lendo
Usando o “Project Euler” para aprender F# – Problemas 6, 7, 8, 9 e 10
Olá. Continuo minha cruzada para aprender F#. Como ando sem tempo para um projeto “grande”, como o de Xadrez, estou resolvendo os problemas propostos pelo “Projeto Euler“. Se ainda não conhece, … Continuar lendo
Eu APOIO, sim, a causa feminista!
Olá. Fico muito triste sempre que ouço um relato de abuso (de qualquer natureza). Fico ainda mais triste quando percebo que esse abuso foi sofrido por alguém próximo, confesso. Mas, … Continuar lendo
Usando o “Project Euler” para aprender F# – Problemas 1, 2, 3, 4 e 5
Olá. Continuo minha cruzada para aprender F#. Como ando sem tempo para um projeto “grande”, como o de Xadrez, resolvi começar a resolver os problemas propostos pelo “Projeto Euler“. Se … Continuar lendo
Acessando a base de dados do WorldBank e o poder da linguagem R a partir do F#
No post anterior, mostrei a versatilidade do F# para exploração de dados provenientes de fontes externas sem sacrificar os benefícios da tipagem estática. Agora, vamos explorar alguns usos criativos de … Continuar lendo
F# Type Providers – Trazendo um pouco da flexibilidade de linguagens dinâmicas para uma linguagem estática.
Este post é inspirado em um exemplo encontrado no excelente livro Machine Learning Projects for .NET Developers de Mathias Brandewinder. Quando consumimos dados de uma fonte externa (ao nosso código), … Continuar lendo
O que é “mais funcional”?
Olá, Estou desenvolvendo um solver para problemas de Xadrez e os fontes estão no Github. Eu uso um uint64 para armazenar que casas no tabuleiro estão ocupadas. Como tenho 64 … Continuar lendo
Para não esquecer! Em F# use Records com moderação
Olá. Tudo certo? Resolvi aprender F# escrevendo algo um pouco mais complexo que um “Hello World”. Estou escrevendo um “solver” para problemas de xadrez. Minha ideia é expor minha “vergonha” … Continuar lendo
Escrevendo um “Solver” de problemas de Xadrez para … aprender F#
Olá. Tudo bem? Há alguns dias proponho problemas de Xadrez em minha conta no Twitter. O primeiro foi esse aqui: A solução é relativamente simples: 1) Nh6! gxh6 2) g7+ … Continuar lendo
Encontrando o “Bit menos significativo ligado” em F# (usando Magic Bitscan)
Olá. Há algum tempo escrevi um post explicando os fundamentos de Magic Bitscan. Aqui, compartilho código para encontrar o bit menos significativo de um longo sem sinal, em F#. Era … Continuar lendo
Implementando “Actor Model” com Akka.net – Parte 3 – Criação de um Actor
Olá. Bem-vindo ao terceiro post da série em que apresento fundamentos para implementação do “Actor Model” usando Akka.net. Se está chegando agora, recomendo fortemente que você veja os posts anteriores … Continuar lendo
Implementando “Actor Model” com Akka.net – Parte 2 – Um exemplo muito simples
Olá. No post anterior, falei um pouco sobre alguns conceitos fundamentais para Akka.net. Recomendei dar uma olhada em um exemplo que já implementado. Entretanto, acho fiquei devendo algo um pouco mais … Continuar lendo
Implementando “Actor Model” com Akka.net – Parte 1 – Fundamentos
Olá. Já faz tempo que não escrevo uma série didática de posts aqui no blog. Estou retomando o hábito com essa série sobre Akka.net. Preliminares O que é Akka.net Pegando … Continuar lendo
F# Behind the Scenes – Desvendando o uso de “Discriminated Unions” para representar hierarquias de objetos
Olá. F# é uma linguagem que conquista por sua expressividade. Consideremos o código que segue: Aqui encontramos um exemplo comum de utilização para “Discriminated Unions”. Fazendo um paralelo com C#, … Continuar lendo
F# Behind the Scenes – Implementação ingênua (do compilador) ou Interpretação Ingênua (minha)
Olá pessoal Considere o código que segue em F#. Bonito, não? Quando compilado, o código IL gerado pode ser convertido para algo assim em C# A parte que me deixa … Continuar lendo
F# Behind the Scenes – O segredo dos módulos e do currying
Olá. Tudo certo? Algumas coisas que F# faz parecem mágica. Concorda? Então, vamos dar uma olhada no que ocorre “behind the scenes” para entender um pouco o que ocorre. Vejamos … Continuar lendo
Primeiros passos com “Actor Model” (usando F# e Akka.net)
Olá. Tudo certo? Como você já deve ter percebido, pelos últimos posts, comecei a estudar “Actor Model”. Para ter algo “prático”, escrevi um primeiro programa, bem simples, em Scala. Depois … Continuar lendo
Primeiros passos com “Actor Model” (usando C# e Akka.net)
Olá pessoal. Tudo certo? Ontem comecei meus estudos sobre “Actor Model”. Comecei usando Scala e sua biblioteca padrão. Depois, enriqueci o modelo mostrando uma implementação usando Scala com o framework … Continuar lendo
Primeiros passos com “Actor Model” (usando Scala + Akka)
Olá pessoal, Esta é uma releitura de meu post anterior (por favor, veja o texto do post anterior para entender os conceitos). Antes, havia feito minha implementação usando a biblioteca padrão … Continuar lendo
Primeiros passos com “Actor Model” (usando Scala)
Olá pessoal. Tudo certo? Este post é uma das “heranças” do QCon São Paulo. Ele apresenta o início dos meus estudos sobre “Actors Model”. Deverei retornar ao assunto, com alguma frequência, … Continuar lendo
Sobre o projeto “Enquadrando Ideias”
Olá. Tudo certo? Se me acompanha nas redes sociais, viu que iniciei a divulgar um novo blog: “Enquadrando Ideias” Do que trata Os temas discutidos no blog serão: Gestão e Liderança … Continuar lendo
Escrevendo testes de unidade com F#
Olá pessoal. Tudo certo? Semana passada ajudei a organizar e palestrei no QCON. Do evento, trouxe como “tema de casa” a tarefa de voltar a estudar algumas tecnologias. Dentre elas, … Continuar lendo
Sobre Desenvolvimento Poliglota
Olá pessoal. Tudo certo? Estou participando, mais uma vez, do QCON. Acho este evento fantástico por me proporcionar a oportunidade de ter contato com diversas tecnologias, sempre com grandes autoridades. … Continuar lendo
Spheres! com TypeScript
Olá. Como no post anterior, estou pegando um exemplo antigo, originalmente em JavaScript, e reescrevendo em TypeScript. Spheres! Let’s code! Adorando TypeScript! Era isso.
Jornada nas Estrelas (Starfield) com TypeScript
Olá amigos. Há algum tempo, escrevi um pequeno “Starfield” em Javascript puro. Hoje, refaço esse exemplo usando TypeScript. Por que TypeScript? Adoro JavaScript. Considero JS extremamente poderosa e sei de … Continuar lendo
Como ‘foreach’ é resolvido pelo compilador C#
Olá. Tudo certo? Considere esse código: ele é escrito pelo compilador assim: Que tem correspondência exata para: Repare que não há qualquer relação com as interfaces IEnumerable, IEnumerable, IEnumerator e … Continuar lendo
Como o switch é resolvido pelo compilador do C#
Olá. Nesse post pretendo apresentar algumas informações sobre como o compilador do C# resolve o switch. O que eu vou apresentar é baseado em interpretações do código IL gerado pelo compilador. … Continuar lendo
O que eu aprendi colaborando com um projeto Open Source
Olá. O projeto CodeCracker tem pouco mais de um mês. Entretanto, parece ter mais. Ele me proporcionou muito aprendizado. Neste post, pretendo compartilhar algumas das coisas que aprendi. Pessoas motivadas … Continuar lendo
Entendendo a compilação do C# (csc.exe e JIT)
Olá pessoal. Em tempos de Roslyn, nunca é demais voltar a discutir o processo de compilação do .NET. Nesse post, apresento um exemplo inspirado em uma apresentação de um engenheiro … Continuar lendo
Considere métodos de criação “ReplaceXXXX” e “WithXXXX” em objetos somente leitura
Olá. Tudo certo? De uns tempos para cá, certamente influenciado pelo paradigma funcional, venho adotando com grande frequência objetos somente leitura. Um exemplo de objeto somente leitura (em tempo, todo … Continuar lendo
CodeCracker – Parte 8 – Make a variable const whenever it’s possible
Tudo certo, pessoal? Nesse post, apresento a implementação do issue #79 do CodeCracker. A ideia é converter toda variável em constante quando for possível. Analyzing Abaixo, a implementação para identificar … Continuar lendo
CodeCracker – Parte 7 – Suggest switch if you have 3 or more nested if / else statements
Olá. Tudo certo? No post de hoje apresento a implementação de mais um analyzer e codefix desenvolvido para o projeto CodeCracker: Suggest switch if you have 3 or more nested … Continuar lendo
Multiplicação divertida (em C#)
Olá. Tudo certo? Como multiplicar dois números positivos sem usar o operador de multiplicação? A abordagem mais simples, ao meu ver seria: Entretanto, essa abordagem está longe de ser eficiente. … Continuar lendo
Pensando produtos inteligentes e conectados (IoT) e a competição
Olá. Tudo certo? É pouco provável que você ainda não tenha ouvido falar em Internet das Coisas. De qualquer forma, é muito interessante pensar no impacto nos negócios que esta … Continuar lendo
CodeCracker – Parte 6 – On Linq clauses move predicate from Where to First, Single, etc when applicable
Olá. Tudo certo? No post de hoje apresento a implementação de mais um analyzer e codefix desenvolvido para o projeto CodeCracker: On Linq clauses move predicate from Where to First, … Continuar lendo
CodeCracker – Parte 5 – Always use ‘var’
Olá. Tudo certo? Agora que já cobri os fundamentos para que você possa entender e colaborar com o projeto CodeCracker, vou começar a mostrar algumas implementações que estamos fazendo. Começo … Continuar lendo
CodeCracker – Parte 4 – Depurando e Testando
Olá. Tudo certo? Se você já baixou o Visual Studio 2014 Preview, instalou as extensões recomendadas no site do Roslyn e clonou o repositório do CodeCracker, então, já está pronto … Continuar lendo
CodeCracker – Parte 3 – “Arrumando” o código (CodeFix)
Olá. Tudo certo? Na parte anterior, mostrei como “detectar” código que pode ser melhorado através de Diagnostic Analyzers. Agora, vou mostrar como escrever o “CodeFix” para o código detectado. O … Continuar lendo
CodeCracker – Parte 2 – Construindo um Analyzer
Olá. Tudo certo? Nesse post, apresento uma breve introdução ao desenvolvimento de “Diagnostic Analyzers” usando Roslyn. O que é um Roslyn Diagnostic Analyzer? Um code analyzer é um “artefato” que … Continuar lendo
CodeCracker – Parte 1 – O que é? Como colaborar?
Olá. Tudo certo? Bem-vindos ao CodeCracker. Uma ferramenta open source, iniciada por brasileiros, que melhora a experiência de codificação no Visual Studio 2015 (ainda em preview, já disponível para download). … Continuar lendo
Resolvendo o problema do Caixeiro Viajante usando algoritmos genéticos
Olá. Tudo certo? Este post é uma releitura, em .NET, desse post. Trata-se de uma implementação simples de um algoritmo genético para encontrar soluções boas para o problema do caixeiro … Continuar lendo
Resolvendo o problema do caixeiro viajante usando Simulated Annealing
Olá. Este post é uma releitura, em .NET, desse post. Quero apresentar uma implementação muito simples da metaheurística “Simulated Annealing” para encontrar soluções boas para o problema do caixeiro viajante. Você … Continuar lendo
Tentando superar “Buy now with one-click” com uma “Wish list”
Olá pessoal. Tudo certo? Eu sempre gostei de ler, estudar e aprender. Mas, já há algum tempo, vinha comprando mais livros do que conseguia ler. Também estava perdendo tempo demais … Continuar lendo
A busca (não tão) insana pela dívida técnica e o retorno (sofrido) ao Greenfield!
Olá, Alguns fatos sobre a forma como faço o meu trabalho Em busca da dívida técnica Fato 1 No meu trabalho, desenvolvo soluções com considerável complexidade técnica. Meus algoritmos não … Continuar lendo
Static Analysis 101 – Parte 2 – Acoplamento aferente e acoplamento eferente (com NDepend)
Olá. Nesse post, sigo discussão sobre análise estática de código. Aqui, trato de acoplamento aferente e acoplamento eferente. Há algum tempo, Leandro Daniel escreveu um ótimo post conceituando os termos. … Continuar lendo
Quando o contexto (enganoso) torna as decisões arquiteturais (bem) mais difíceis (Teenage Sex Pattern)
Olá, Esse post é resultado de uma “provocação” que encontrei no excelente livro Microsoft .NET – Architecting Applications for the Enterprise (2nd edition). Vou compartilhar com vocês e gostaria de … Continuar lendo
Static Analysis 101 – Parte 1 – O que é?
Olá pessoal. Tudo certo? Este é o primeiro post da série onde apresento técnicas e ferramentas para análise estática de código. O que é análise estática? Segundo a definição da Wikipedia: … Continuar lendo
O que há de novo no C# 6 – Parte 9 – nameof operator
Olá. Este é o nono post da série onde apresento as novidades do C# 6. Nesse post, apresento o operador nameof. Nunca gostei de ter que usar “strings mágicas” para representar … Continuar lendo
O que há de novo no C# 6 – Parte 8 – Expression Bodied Members
Olá. Este é o oitavo post da série onde apresento as novidades do C# 6. Nesse post, apresento Expression Bodied Members. Observe o seguinte código: Reparou Length e Scale? Bacana não? São … Continuar lendo
O que há de novo no C# 6 – Parte 7 – Dictionary Initializer
Olá. Este é o sétimo post da série onde apresento as novidades do C# 6. Nesse post, apresento um novo formato para inicialização de dicionários. Como é no C# 5 Nunca … Continuar lendo
O que há de novo no C# 6 – Parte 6 – Exception Filters
Olá. Este é o sexto post da série onde apresento as novidades do C# 6. Nesse post, apresento Exception Filters: Até o C# 5, caso desejássemos implicar alguma condicional para o … Continuar lendo
O que há de novo no C# 6 – Parte 5 – Null-propagating operator
Olá, Este é o quinto post da série onde apresento as novidades do C# 6. Nesse post, apresento uma das novidades mais bacanas (IMHO) do C#6: Null-propagating operator. Esse código do … Continuar lendo
O que há de novo no C# 6 – Parte 4 – using static
Olá, Este é o quarto post da série onde apresento as novidades do C# 6. Aqui, apresento um recurso muito interessante: fazer “using” de classes para poder evocar membros estáticos … Continuar lendo
O que há de novo no C# 6 – Parte 3 – Relação entre Explicit Constructors e Primary Constructors
Olá. Tudo certo? Este é o terceiro post da série onde apresento as novidades do C# 6. Aqui, apresento a relação entre explicit constructors (tradicionais) e primary constructors (novidade no … Continuar lendo
(WITHDRAWN) O que há de novo no C# 6 – Parte 2 – Primary Construtors
Olá. Tudo certo?! UPDATE: A Microsoft parece ter desistido de implementar essa funcionalidade nessa versão do C# Bem-vindo ao segundo post da série onde apresento as novidades do C# 6 … Continuar lendo
O que há de novo no C# 6 – Parte 1 – Auto-property initializers
Olá. Tudo certo? Este é apenas o primeiro post da série em que apresento o que há de novo no C# 6. Para testar cada uma das novidades que relaciono, … Continuar lendo
Encapsulando APIs de nível mais baixo
Olá. Tudo certo? As vezes, precisamos utilizar APIs de nível mais baixo do que aquele que estamos utilizando na aplicação. O que fazer? Isolar ao máximo essa API do restante … Continuar lendo
Potencial de paralelismo: Sequencial, “Por tarefa” e “Por dados”
Olá. Tudo certo?! Identificar o potencial de paralelismo de nossos códigos pode nos ajudar a escrever programas mais rápidos e que aproveitam melhor o hardware que temos a disposição. Existem, … Continuar lendo
Tente outra vez … (Retry Pattern)
Olá. Tudo certo?! O que fazemos (ou deveríamos fazer) quando, devido a condições circunstanciais, geralmente relacionadas a um instante de execução, vemos nossas aplicações falharem em completar uma tarefa? Tentamos outra vez! Para isso, … Continuar lendo
Service Health Checking (e Health Monitoring Endpoint Pattern)
Olá pessoal. Tudo bem?! No último post, tratei do “Circuit breaker pattern”, cujo a implementação consiste em uma espécie de proxy que “blinda” recursos externos evitando requisições em momentos de instabilidade e/ou recuperação. … Continuar lendo
Circuit Breaker Pattern
Olá pessoal. Tudo certo?! Nesse post, falo de um pattern que melhora a estabilidade percebida de nossas aplicações. Trata-se do “Circuit Breaker Pattern”. Ele indica uma forma de tratar instabilidades … Continuar lendo
Regras! Regras! Regras! – Exemplo trivial de “Business Rule Engine” [Revisado e sem reflection]
Olá pessoal, Esse post é uma revisão do anterior. Graças ao feedback do meu amigo @juanplopes, percebi que o reflection acabou adicionando um bocado de complexidade de implementação. Segue versão … Continuar lendo
Regras! Regras! Regras! – Exemplo trivial de “Business Rule Engine”
Olá pessoal. Tudo certo?! Nesse post, falo de “rules engines”. Se o conceito é novo para você, recomendo a leitura desse post do Martin Fowler (bem básico, mas didático o … Continuar lendo
Como obter os “bytes” de um tipo primitivo (double, por exemplo)
Olá pessoal. Tudo certo? Quase todo mundo que programa com C# sabe que um double ocupa 8 bytes de memória. Certo?! Mas, como, a partir de um valor, podemos saber … Continuar lendo
Uma “outra” abordagem para blindar “entidades”…
Olá pessoal. Tudo certo? Há tempos atrás eu propus uma solução “inventiva” e considera, por muitos, complexa para “blindar” entidades. Hoje, apresento outra abordagem, bem mais simples, que não é, … Continuar lendo
Aplicativos que fazem diferença: Moves e Audible
Olá pessoal. Tudo certo? Diferente do que faço normalmente, hoje quero compartilhar com vocês dois aplicativos que estão incrementando minha rotina: Moves (Facebook) e Audible (Amazon) MOVES Genial! Segundo o … Continuar lendo
Weak Event Patterns – Parte 3 – Especialização de WeakEventManager (WPF)
Olá pessoal. Tudo certo?! Esse é o terceiro post da série onde explico como implementar “weak events” em .Net. Recapitulando, Weak Events são um “afrouxamento” na relação entre Senders e … Continuar lendo
Weak Event Patterns – Parte 2 – Generic Event Wrapper
Olá pessoal. Tudo certo? No post anterior, apresentei uma alternativa para “aliviar” o acoplamento entre objetos que “disparam” eventos e aqueles que “escutam” eventos. Entretanto, a abordagem que eu disponibilizei … Continuar lendo
Weak Event Patterns – Parte 1 – Event Wrapper
Olá pessoal. Tudo certo? Eventos são uma abstração extremamente inteligente e poderosa. A sintaxe oferecida pelo C# para suporte de eventos é bela e simples de entender. Entretanto, tem algumas … Continuar lendo
E o void voltou…
Olá amigos, Estou muito feliz em anunciar que o Void Podcast está retomando, aos poucos, suas atividades. Ouça e comente o último episódio se deseja que retomemos o projeto. Em … Continuar lendo
C++/CX – Parte 9 – Exceptions
Olá pessoal. Tudo certo? Este é o nono post da série onde estamos explorando C++/CX – o conjunto de extensões da Microsoft, no C++, para o desenvolvimento de aplicações modernas. O … Continuar lendo
Descobrindo Owin e Katana – Parte 8 – Lendo o “Response Body”
Olá pessoal. Tudo certo? Este é o oitavo post da série onde “descobrimos” Owin e Katana. Hoje, mostro como ler o response body. O problema Considere o seguinte código de exemplo. Responda … Continuar lendo
C++/CX – Parte 8 – Delegates
Este é o oitavo post da série onde estamos explorando C++/CX – o conjunto de extensões da Microsoft, no C++, para o desenvolvimento de aplicações modernas. Os temas desse post … Continuar lendo
C++/CX – Parte 7 – Propriedades e Enums
Este é o sétimo post da série onde estamos explorando C++/CX – o conjunto de extensões da Microsoft, no C++, para o desenvolvimento de aplicações modernas. Os temas desse post … Continuar lendo
C++/CX – Parte 6 – Interfaces
Olá. Tudo certo? Este é o sexto post da série onde estamos explorando C++/CX – o conjunto de extensões da Microsoft, no C++, para o desenvolvimento de aplicações modernas. Básico … Continuar lendo
Descobrindo Owin e Katana – Parte 7 – Lendo o Request Body em múltiplos Middlewares
Olá pessoal. Tudo certo? Este é o sétimo post da série onde “descobrimos” Owin e Katana. Hoje, mostro como acessar o request body em vários Middlewares. O Problema Considere que … Continuar lendo
C++/CX – Parte 5 – Herança
Olá pessoal. Tudo certo? Este é o quinto post da série onde estamos explorando C++/CX – o conjunto de extensões da Microsoft, no C++, para o desenvolvimento de aplicações modernas. … Continuar lendo
Descobrindo Owin e Katana – Parte 6 – Cara, cadê o meu header?
Olá pessoal. Tudo certo? Esse é o sexto post da série onde “descobrimos” o que é Owin e o que é Katana. O que já temos: Primeiros passos Criando um … Continuar lendo
C++/CX -Parte 4 – Utilização de tipos padrões
Olá pessoal. Tudo certo? Nesse momento, já sabemos um bocado sobre como criar ref classes. Nesse post, vamos dar uma olhada sobre como utilizar (mesclar, na verdade) tipos padrões do … Continuar lendo
Descobrindo Owin e Katana – Parte 5 – Escrevendo Middleware em uma classe separada
Olá pessoal. Tudo certo? Esse é o quinto post da série em que estamos “descobrindo” OWIN e Katana – tecnologias da Microsoft para desenvolvimento de módulos Web que pretende aliviar … Continuar lendo
Descobrindo Owin e Katana – Parte 4 – Suporte para encadeamento de Middlewares
Olá. Tudo certo? Continuamos nossa jornada de descoberta para Owin e Katana. Nesse post, mostro como encadear a execução de Middlewares. Perceba, até aqui, estávamos levantando servidores com apenas um … Continuar lendo
C++/CX – Parte 3 – ref class/struct vs value class/struct
Olá pessoal. Tudo certo? Esse é o terceiro post da série onde apresento as modificações feitas no C++ para suportar o desenvolvimento de aplicações modernas. No primeiro post, tratei dos … Continuar lendo
Descobrindo Owin e Katana – Parte 3 – Facilitando o desenvolvimento do Middleware
Olá. Tudo certo? Esse é o terceiro post da série onde “descobrimos” OWIN e o Katana. Se está chegando agora, talvez deva considerar dar uma olhada no primeiro e no … Continuar lendo
C++/CX – Parte 2 – Classes e Estruturas
Olá pessoal. Tudo certo? No post anterior, comecei a apresentar os fundamentos básicos de C++/CX. Nesse post, apresento como definir tipos de referência e de valor em C++/CX. Ideia básica … Continuar lendo
Fibonacci na velocidade da luz (Binet’s formula)
Olá pessoal. Tudo certo? Esse post é só para descontrair mesmo! Quem nunca implementou um algoritmo recursivo para determinar o valor de um elemento da sequencia de Fibonacci? E a … Continuar lendo
Descobrindo Owin e Katana – Parte 2 – Criando um Host personalizado
Olá. Tudo certo? No post anterior, comecei a tratar de OWIN e Katana – Projetos que objetivam reduzir o acoplamento de módulos Web com o IIS. Usamos o host fornecido … Continuar lendo
Descobrindo Owin e Katana – Parte 1 – Primeiros passos
Olá pessoal. Tudo certo?! Esse é o primeiro post de uma série onde pretendo explicar fundamentos dos projetos OWIN e Katana. O que é OWIN? Pegando a definição do site … Continuar lendo
C++/CX – Parte 1 – Fundamentos
Olá pessoal. Tudo certo? Nessa série, apresento os fundamentos de C++/CX – a extensão da Microsoft, na linguagem C++, para o desenvolvimento de aplicações modernas. Tentarei manter os posts pequenos … Continuar lendo
Fui assaltado!
Olá amigos, Não tenho escrito tanto aqui no blog, mas, com o tempo, pretendo retomar o ritmo. Minha vida mudou um bocado nos últimos tempos. Alguns episódios positivos, outros nem … Continuar lendo
Entendendo GetHashCode
Olá. Tudo certo? Outro dia vi alguém sugerir o uso de GetHashCode para identificar um objeto. Essa não é uma boa ideia e no post de hoje pretendo explicar o … Continuar lendo
Na busca da envoltória convexa – parte 1 (em Javascript)
Olá pessoal. Tudo certo? Sabe o que é uma envoltória convexa? Não, boa leitura. Agora que sabe, vamos tentar escrever algo para determinar a envoltória para um conjunto qualquer de … Continuar lendo
Uma abordagem para blindar entidades fora de um contexto (o que você acha?)
Olá. Tudo certo? Há tempos venho pensando em como controlar alterações a entidades. Há cenários onde desejo que elas sejam imutáveis, outros em que desejo permitir alteração. Nesse post, apresento … Continuar lendo
É potência de dois?!
Olá. Dando uma pausa em posts mais densos, que tal brincarmos um pouco? Nesse post, procuro uma forma eficiente de determinar se um número é, ou não, uma potência de … Continuar lendo
Event Sourcing – Parte 3 – Application Services
Olá. Tudo certo? No post anterior mostrei como modelar, de forma mais adequada, os eventos de domínio agregando mais semântica ao Event Stream. Agora, vamos ver como tornar o acesso … Continuar lendo
Event Sourcing – Parte 2 – Planejando Eventos de Domínio
Olá. Tudo certo? No post anterior, apresentei uma visão simplificada de Event Sourcing. Agora, melhoro o exemplo do post anterior aprimorando a modelagem dos eventos de domínio. Revisitando a entidade … Continuar lendo
Event Sourcing – Parte 1 – Fundamentos
Olá pessoal. Tudo certo? Event Sourcing é um nome “novo” para uma prática relativamente velha. Recentemente, foi popularizado por Greg Young que demonstrou sua aplicabilidade combinada a DDD. Embora não … Continuar lendo
Hexagonal Architecture (Ports and Adapters)
Olá. Tudo certo? Nesse post, trato de um estilo arquitetural proposto por Alistair Cockburn. Recomendo fortemente que você veja o artigo dele que detalha este estilo. Fundamentos De forma simplificada, … Continuar lendo
Apresentando “mooble.com”. Espero (e conto com) o seu feedback!
Olá pessoal. Tudo certo?! Há tempos não escrevia nada por aqui. De certa forma, esse post explica o motivo. Criamos uma plataforma para design de interiores, on-line e sem plugins. … Continuar lendo
Aprendendo WebSocket – Parte 2 – The Opening Handshake
Olá. Esse é o segundo post da série onde compartilho meus aprendizados sobre o protocolo WebSocket. No post anterior, indiquei do que trata o protocolo e apresentei uma descrição sucinta … Continuar lendo
Aprendendo WebSocket – Parte 1 – API no cliente
Olá. Assisti a uma palestra do @brunoborges, em Goiânia, no Join Community 2013, que me motivou a estudar o novo protocolo WebSocket. Nessa série, compartilho meu “caminho das pedras” O que … Continuar lendo
Linguagem de máquina
Olá. Continuo minhas “aventuras” no excelente curso nand2tetris, recomendado pelo @qmx. Esse curso está disponível on-line! Se desejar fazer o curso, recomendo a aquisição do livro texto relacionado. Na etapa do curso … Continuar lendo
Sequential Logic – Projetando módulos de memória RAM (em HDL)
Olá. Continuo minhas “aventuras” no excelente curso nand2tetris, recomendado pelo @qmx. Hoje, mostro meus projetos para construção de chips de memória. Guardando um bit Uma das coisas mais legais em … Continuar lendo
Enfim, 34!
Olá. Há um ano, comemorava meus 33 anos. Parece que isso aconteceu ontem, mas, estou chegando aos 34. Como sempre, tive meus dias bons e ruins. Não fui sempre “o … Continuar lendo
Aritmética booleana (HDL e C#)
Olá. Tudo certo? Seguindo meus estudos no curso proposto em www.nand2tetris.org, influenciado pelo grande @qmx, apresento o projeto de alguns chips para suporte a aritmética booleana em HDL. Também apresento algum código escrito … Continuar lendo
HDL madness – Nand chips!
Olá. Nos posts anteriores, mostrei como implementar operações lógicas a partir de um único operador (nos exemplos, NAND e NOR). Com esse conhecimento, sabemos como criar hardware, usando apenas “gates” … Continuar lendo
Coding 4 Fun – Ele criou a “Nor Gate”
Olá. Este post segue a mesma ideia do anterior: demonstrar a possibilidade de implementar qualquer operação lógica através de operadores com functional completeness. Já demonstramos o poder do Nand. Agora, … Continuar lendo
Coding 4 Fun – Ele criou a “Nand Gate”!
Olá. Tudo certo? A excelente palestra do @qmx no DNAD 2013 me motivou a fazer o curso proposto em Nand2tetris.org. A ideia é passear por todas as áreas da ciência … Continuar lendo
Implementando Basic Authentication com Web API
Olá. Tudo certo? Nesse post, mostro como implementar Basic Authentication para serviços desenvolvidos com ASP.NET Web API. A idéia fundamental dessa estratégia de autenticação é verificar se há nos cabeçalhos … Continuar lendo
Criptografia assimétrica em .NET (usando certificados)
Olá. Tudo certo? Em um post anterior, mostrei como implementar criptografia simétrica com .NET. Agora, vamos ver como implementar criptografia assimétrica. Ou seja, onde a criptografia ocorre através de uma … Continuar lendo
Um mecanismo simples de assinatura em .NET
Olá. Tudo certo? No post anterior, mostrei uma implementação simples para criptografia simétrica utilizando .NET. As vezes, não nos importamos em “ocultar” uma mensagem. Entretanto, temos interesse em garantir sua … Continuar lendo
Criptografia simétrica em .NET
Olá. Tudo certo? Nesse post, apresento um wrapper simples para facilitar a adoção de criptografia simétrica (com uma única chave) usando .NET. Vamos lá: Aqui, apresento duas sobrecargas para o … Continuar lendo
Claims-based Access Control com Claims no .NET 4.5
Olá. Tudo certo? No post anterior, falei sobre a relevância de Claims no .NET 4.5. Indiquei, inclusive que RBAC é implementado usando Claims. Agora, falo sobre Claims-based Access Control. Claims-based … Continuar lendo
RBAC usando Claims no .NET 4.5
Olá pessoal. Tudo certo? A Microsoft aposta tanto em “Claim-based authentication” que trouxe a sua implementação básica para o core do .NET Framework. As classes ClaimsIdentity e ClaimsPrincipal estão agora … Continuar lendo
CORS Preflight Requests (com ASP.NET Web API)
Olá. Tudo certo? No post anterior, falei sobre como deixar nossos serviços operantes em domínios diferentes daquele onde estão hospedados. O que apresentei é suficiente para operações de GET e … Continuar lendo
Cross-Origin Resource Sharing (CORS) com ASP.NET Web API
Olá. Tudo certo? Same-origin policy! Uma restrição simples, imposta por browsers, para evitar que scripts de um domínio tenham acesso a recursos de um outro. Parece ser uma boa ideia, … Continuar lendo
Melhorando o tratamento de exceptions usando ASP.NET Web API
Olá. Tudo certo? Se você desenvolve há algum tempo com WebAPI já sabe que quando uma exception é disparada no servidor, uma resposta de código 500 (Internal Error) é retornada … Continuar lendo
SNIPPET: Uma interface fluente para dicionários de dados
Olá. Tudo certo? Nunca gostei do “Add” dos dicionários de dados. Ou seja, o código que segue não me agrada: Sou fã de interfaces fluentes. Prefiro algo assim: Implemento essa … Continuar lendo
HTTP Method Overriding (usando X-HTTP-Method-Override) com ASP.NET Web API
Olá. Tudo certo? APIs baseadas em HTTP permitem que seus clientes interajam com recursos através dos métodos GET, PUT, POST e DELETE (entre outros). Destes, GET e POST são suportados … Continuar lendo
Image Effects com C++ AMP – Blur
Olá. Tudo certo? Agora que já tratamos dos fundamentos de C++ AMP, está na hora de começar a botar as “mãos na massa” e fazer algo de útil. Para começar, … Continuar lendo
Introdução a Tiling com C++ AMP – Parte 4 (final) – tile_static e tile_barrier
Olá. Tudo certo? Este é o quarto e último post de uma pequena série introdutória sobre tiling com C++ AMP. Antes de seguir a leitura, recomendo que você leia os … Continuar lendo
Elemar DEV 