ResearchScale is here
The all-in-one tool to get your research organized.

Projeto e Análise de Algoritmos, minha experiência
Compartilhando minha experiência cursando a disciplina Projeto e Análise de Algoritmos (PAA) durante o programa de mestrado em Ciência da Computação (DCC/UFMG).

Re-evaluating Measurement Algorithms in Software
This paper demonstrates that simple hash tables are often more efficient than sketch and heap-based solutions for measurement algorithms used in network monitoring.

Traffic monitoring applications using eBPF programmable networks
Summary of a paper demonstrating that network traffic monitoring tools can be efficiently implemented using an SDN approach with an eBPF/BPFabric data-plane.

End-to-End Network Delay Guarantees for Real-Time Systems Using SDN
This paper demonstrates how it is possible to support critical network flows for Real-Time Systems in a Software Defined Network.

Running eBPF programs on Docker containers
Creating a Docker image to run BPF programs with libbpf, and troubleshooting Ubuntu issues.

How to Write a Paper Summary
Learn what is and how to write an effective scientific paper summary.

Autoscaling Tiered Cloud Storage in Anna
Summary of the paper presenting Anna, a distribuited KVS system designed to balance cost and latency requirements.

Scalability! But at what COST?
Summary of the paper presenting COST (Configuration that Outperforms a Single Thread), a metric to evaluate big data platforms in a different way.

GraphX: Graph Processing in a Distributed Dataflow Framework
Summary of the paper published in 2014 presenting GraphX, a distributed graph processing system that makes it possible to compose graphs with other collections by reducing the property graph to a pair of collections.

Distributed GraphLab: A Framework for Machine Learning and Data Mining in the Cloud
Summary of the article presenting GraphLab, a fault-tolerant system that provides a dynamic and asynchronous execution model for processing large-scale graphs.

Pregel: A System for Large-Scale Graph Processing
Summary of the paper presenting Pregel, Google's system for processing large Graphs using a simple computational model while being designed for efficiency and fault-tolerant execution.

Tachyon: Reliable, Memory Speed Storage for Cluster Computing Frameworks
Summary of the paper presenting Tachyon, the distributed file system that enables reliable data sharing at memory speed.

Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing
Summary of the paper published by University of California Berkeley researchers, presenting RDD, a distributed memory abstraction for computations on large clusters.

HDFS scalability: the limits to growth
Summary of Shvachko's article presenting Hadoop distributed file system HDFS and its scalability limitations.

MapReduce: Simplified Data Processing on Large Clusters
Paper from Google engineers presenting MapReduce, a model providing a robust yet simple interface for processing large datasets in distributed environments.

Enterprise Data Analysis and Visualization: An Interview Study
This paper presents an overview of the different competencies of data analysts, discussing the social and organizational context of companies that affects the outcome of analysts' everyday work.

Improving Datacenter Performance and Robustness with Multipath TCP
Paper presenting the MPTCP protocol which improves the performance on datacenters, providing an alternative for single-path transport.

Modeling TCP Throughput: A Simple Model and its Empirical Validation
Summary of the paper published in 1998 describing a TCP throughput prediction model that take timeouts into account.

TCP Slow Start, Congestion Avoidance, Fast Retransmit, and Fast Recovery Algorithms
Summary of the RFC 2001, discussing the TCP mechanisms to handle package transmissions during network congestion.

Congestion avoidance and control
Paper presenting an efficient algorithm for network congestion avoidance and control, as a response to the first Internet congestion collapses that happened back in 1986.

Analysis of the Increase and Decrease Algorithms for Congestion Avoidance in Computer Networks
Summary of the paper published in 1989 presenting different algorithms for Congestion Avoidance in computer networks.

Efficient virtual network isolation in multi-tenant data centers on commodity ethernet switches
This paper presents LANES, a system that provides network isolation for multi-tenant data center environments.

P4: Programming Protocol-Independent Packet Processors
Programming language designed for protocol and target independence allowing programmers to define packet processors in SDN environments.

B4: Experience with a Globally-Deployed Software-Defined WAN
Paper presenting Google's private WAN connecting its data centers through an SDN solution, allowing near 100% of hardware utilization.

Software Defined Traffic Measurement with OpenSketch
This paper presents a measurement architecture and prototype API for software-defined networks. It provides programmable measurement task implementations while maintaining high memory accuracy.

Ethanol: Software Defined Networking for 802.11 Wireless Networks
This paper presents Ethanol, an SDN architecture for dense wireless networks, enabling vendor-agnostic service-aware control algorithms and network-wide control of QoS, user mobility, and access point virtualization.

SoftRAN: Software-Defined Radio Access Network
Current distributed control plane for RANs are suboptimal on managing resources of dense wireless networks. SoftRAN presents as a software-defined, fundamental rethink of the radio access layer.

BPFabric: Data Plane Programmability for Software-Defined Networks
Paper published at IEEE Xplore presenting a new protocol for allowing increased programmability for software-defined networks data plane.

Software-Defined Networks: a systematic approach to the development of research in Computer Networks
Mini-course pubished at SBRC providing an overview on Software Defined Networks (SDN) with practical examples and applicabilities.

End-to-end Arguments in System Design
This paper presents the end-to-end argument, which comprehends most network applications and plays an important part in balancing the tradeoffs between low and high-level implementations.

The Design Philosophy of the DARPA Internet Protocols
Paper from 1988 by David Clark, demonstrating the main motivations behind the early internet protocols design.

Shenango: Achieving High CPU Efficiency for Latency-sensitive Datacenter Workloads
This paper presents Shenango, a system that provides microsecond-scale tail latencies while enabling unused CPU cycles to be used by latency-sensitive batch processing applications.

IX: A Protected Dataplane Operating System for High Throughput and Low Latency
This paper demonstrates the design and implementation of an OS that provides high throughput and low latency for packet processing while still maintaining the key advantage of strong protection offered by kernels.

Dune: Safe User-level Access to Privileged CPU Features
Paper produced by Stanford University researchers presenting Dune, a system that provides direct access to hardware features by taking leverage of Intel VT-x virtualization extension.

The Scalable Commutativity Rule: Designing Scalable Software for Multicore Processors
Paper produced by MIT CSAIL and Harvard University researchers proving the commutativity rule as a critical aspect of system's interface design to promote scalability.

The Google File System
This paper presents GFS, the scalable distributed file system implemented at Google to support data-intensive applications with fault tolerance mechanisms and high aggregate performance to a large number of clients.

Crash Consistency: FSCK and Journaling
Paper presenting the Journaling implementation in Linux file systems, along with the techniques used for allowing robust crash recovery from disasters during disk operations.

The Design and Implementation of a Log-Structured File System
Paper presenting Sprite LFS, a sytem implementing a new technique for disk storage management that speeds up both file writing and crash recovery.

RadixVM: Scalable address spaces for multithreaded applications
Paper from MIT CSAIL presenting RadixVM: a new virtual memory system design that enables fully concurrent operations on shared address spaces for multithreaded processes.

Practical, transparent operating system support for superpages
Paper presented on the 5th Symposium on Operating Systems Design and Implementation, describing a superpage management system that improves the performance of applications by increasing the TLB coverage and reducing TLB misses.

Non-scalable locks are dangerous
This paper shows that non-scalable locks can cause dramatic collapse in the performance of real workloads, even for very short critical sections, and demonstrates a replacement of the offending nonscalable spin locks with MCS scalable locks.

Eraser: A Dynamic Data Race Detector for Multithreaded Programs
This paper presents the design and implementation of Eraser, a tool for dynamically detecting racing conditions (data race) in lock-based multithreaded programs.

Serverless Computation with OpenLambda
This paper presents the advantages and main challenges of implementing OpenLambda, a platform for building applications using the serverless computation model.

The Singularity system
This paper shows how safe, modern programming languages let Microsoft rethink the architectural trade-offs in a experimental operating system.

Xen and the Art of Virtualization
This paper presents Xen, an x86 virtual machine monitor which allows multiple operating systems to share conventional hardware in a safe and resource managed fashion.

Exokernel: An Operating System Architecture for Application-level Resource Management
The paper written in 1995, presents the exokernel architecture an alternative OS architecture to address traditional kernel limitations.

The Evolution of the Unix Time-sharing System
The paper written in 1984, concentrates on the evolution of UNIX file system, the process-control mechanism, and the idea of pipelined commands.

The UNIX Time-Sharing System
The paper written in 1974, presents the main aspects of the UNIX Operating System with its file system, I/O operations, process synchronization, and the shell implementation.

Running Cypress end-to-end tests in parallel using AWS Codepipeline CI
Implementing an AWS Codepipeline for running end-to-end tests with AWS Cloudwatch scheduled events

Where and how to start the DevOps transformation journey
Tackling some uncertainties and reducing the risk of failing when starting a DevOps transformation journey within organizations.

Use Telemetry to amplify feedback and see problems as they occur
Collecting useful information from your system to quickly recover from failures, and being able to detect and respond to problems as they occur.

Deliver faster by applying the DevOps Flow techniques
Creating the foundations of your deployment pipeline and adopting the practices of the Flow to deliver software faster and safer.

The Principles of DevOps
Introducing the 3 principles of the DevOps culture, that allows us to deliver software faster and safer, creating a safe system of work with a hight trust culture.

Hosting private NPM packages for free
A simple and practical way to publish and host private NPM packages for free.

Boost your Cypress end-to-end Tests
4 simple tips to improve the speed and the maintainability of your cypress tests.

Continuous Integration with Github Actions and Cypress
Easily configuring a CI pipeline to run end-to-end tests with Cypress and Github Actions, posting comments on pull requests with test results.

The joy of learning new stuff has been stolen
When did developers start feeling so anxious about learning new things? Why learning is not as joyful as it seems before we start?

Validating user email domains with AWS Cognito
Here we will see how can we control users' sign-in using only allowed email domains, by using Cognito and Lambda Functions.

Securing Vuejs applications with Access Control List
Creating an Access Control List to secure your Vuejs application routes.

Securely centralized configuration with Spring Cloud Config
How to create a secure configuration server to centralize and externalize your configurations

Livros, blog posts e documentários que me influenciaram
Aqui está a lista dos conteúdos que mais influenciaram na minha forma de pensar e agir em relação a carreira, mercado e software.

O que é Memory Safety
Entendendo o significado de Memory Safety em linguagens e programas, com exemplos em C.

Entendendo e explorando Buffer Overflow
Como explorar e como funcionam vulnerabilidades Buffer Overflow em programas C e C++.

A usabilidade e segurança das senhas
Senhas seguras não precisam ser altamente complexas e difíceis de memorizar.

Integration tests with Docker
A more maintainable way to provision and manage the lifecycle of the dependencies that your application needs to run integration tests.

Sistemas de mensageria
Conhecendo a história dos sistemas de mensageria, seus conceitos básicos, pontos fortes e seus principais problemas.

Theros: CLI para deploy de sites estáticos
Usando Nodejs para criar uma interface de linha de comando para facilitar o processo de deploy de sites estáticos no S3.

Refactoring a RPG Game
Refactoring the RPG Game project that I have implemented a time ago for a job interview and documenting some lessons learned.

Bringing back OSGi
The basics about Open Services Gateway Initiative with a practical guide to create modular applications using Apache Felix OSGi container.

The internet master switch
How Google, Facebook and Amazon are creating internet monopolies, and how their huge influence is causing irreversible damages.

The shame of being a non-passionate developer
Thoughts about an emerging obsession of being passionate about coding.

OAuth Github web flow doesn't support CORS
When exchanging a code for an access token, there are an additional set of errors that can occur. Here is a workaround for a common one.

Creating page visit statistics using Redis
Easily creating page visit statistics using strings and bitmaps on Redis.

Sharing data across Vuejs components
Some easy approaches to share data across components built for Vuejs small and medium applications.

Port Scanner Chatbot - Parte 2: Criando a API e configurando o Slack App
No segundo e último post da série, criamos uma API para expor nosso serviço de port scan e configuramos o slack app.

Restrição de conteúdo e o futuro da internet
Nacionalistas e a extrema-direita em Charlottesville nos mostraram quem deve ser responsável por restringir conteúdo na internet?

Nem tudo precisa ser escalável
Reflexões sobre o preço de features que realmente escalam. Spoiler: Custam caro.

Port Scanner Chatbot - Parte 1: Construindo um Port Scanner com Java
No primeiro post da série, veremos a construção do serviço que escanea portas de um servidor utilizando APIs de concorrência do Java.

Como funciona o protocolo OAuth 2.0
Entendendo o protocolo OAUth 2.0 e seus principais aspectos.

Avaliando desenvolvedores: a falácia das métricas
Como saber se um desenvolvedor está fazendo um bom trabalho?

Dicas para rastrear falhas em microserviços
Dicas para evitar o caos na identificação de falhas em microserviços.

Autenticação com JWT no Spring Boot
Autenticação em aplicações stateless com JSON Web Tokens.

Qualidade de código e o developer Chaplin
O que qualidade de código tem ver com business? Tudo.

SSL gratuito com Cloudflare
Utilizando certificado SSL de forma gratuita.

Desventuras em processos de contratação
Refletindo sobre algumas coisas curiosas presentes em recrutamentos na área de software.

Melhores partes do TDD
Mais que apenas uma estratégia de testes, TDD é uma ferramenta de design!

Vamos ensinar beleza aos programadores
Bons programadores tem bom gosto estético.

Lidando com CORS no Spring
Habilitando Cross-Origin Resource Sharing em aplicações Spring boot.

Novos Filters do Vue.js 2
O que mudou em relação aos Filters da versão 1.

Diquinhas e truques legais pra usar no Git
Comandos úteis para salvar tempo.

Diga adeus ao Wordpress, conheça o Jekyll
Usando Jekyll para servir páginas estátiacas.