Kevin Sookocheff
Cryptography for the Everyday Developer: Understanding AES - The Advanced Encryption Standard
Cryptography for the Everyday Developer: Understanding DES - The Data Encryption Standard
Cryptography for the Everyday Developer: Confusion, Diffusion, and Substitution-Permutation Networks
Using V2 CloudFront Logs via CloudFormation
Fixing display flicker for Dell monitors on Apple Silicon
Cryptography for the Everyday Developer: Measuring Security in Bits
Cryptography for the Everyday Developer: Modular Arithmetic
Cryptography for the Everyday Developer: Random Number Generators
Cryptography for the Everyday Developer: Security Goals
Cryptography for the Everyday Developer: Encryption Basics with Classical Ciphers
Clustering a DSM Using Simulated Annealing
In the Cloud, Cost is Everything
The Developers Guide to FIPS 140 Compliance
Near infinite scaling with the scale cube and cell-based architecture
Developing an Aya-rs eBPF application using devcontainers
Building a FIPS Compliant Kubernetes Cluster on AWS
Surveying the eBPF Developer Ecosystem
Routing Users to a Login Page Based on Geolocation
What is eBPF and Why is it Important?
Disaster Recovery with DynamoDB Global Tables
Supporting disaster recovery with a multi-region EKS deployment
FSBench: A filesystem benchmarking utility
Benchmarking AWS CSI Drivers
Picking the right AWS CSI driver for your Kubernetes application
Leveraging eBPF in the Kubernetes Networking Model
Trust your users — they’re usually right
Generating Large Test Files
Generating JSON Web Token Assertions
Tackling Technology Strategy with Portfolio Management
Making Sense of Kubernetes Metrics
Project Management for Software Engineers
Increased virtualization performance with the AWS Nitro System
Using Neovim as a Java IDE
Distributed System Models in the Real World
Write-ahead logging and the ARIES crash recovery algorithm
How to kill a process that is a using port on macOS
Progress is a lake, not a line
Why Systems Work So Well
Java For The Experienced Beginner
Behaviour Parameterization
What complex systems can teach us about building software
Hybrid Logical Clocks
HybridTime
TrueTime
Vector Clocks
Lamport Clocks
How Does NTP Work?
Local Kubernetes Development with microk8s
Why Foxes Make Better Decisions Than Hedgehogs
Connecting Technology to the Needs of the Business
The False Dichotomy of Design-First and Code-First API Development
The Most Important Criteria for Choosing a Programming Language
Augmenting Spring Data REST with Additional Endpoints
Making Modular Monoliths Work
Unpacking the eight fallacies of distributed computing
Handling the rudder as an organization grows
The Cathedral, The Bazaar, and the API Marketplace
Marrying RESTful HTTP with Asynchronous and Event-Driven Services
Running a Dapr Application on Kubernetes
Local Kubernetes Development with Tilt
Local Kubernetes Development with kind
There and Back Again: The Unexpected Journey of a Request
VoltDB
Understanding Spring's Environment Abstraction
What is the OCaml toplevel?
Building a Modern Java Web App with Spring Boot
Inversion of Control, Dependency Injection, and the Spring IoC Container
Starting a new OCaml project using Dune and Visual Studio Code
A Tour Through OCaml with Project Euler
Getting Started with opam, the OCaml Package Manager
The OCaml Compiler Pipeline
Above-the-line and below-the-line
How Does DNS Work?
Building Learning Communities
Optimizing Processes Using a Design Structure Matrix
Interdependence and Self-Reliance
Improving Software Architecture Using a Design Structure Matrix
Using Little’s Law to Measure System Performance
Why I’m not (too) worried about Python 2
Riding the Architecture Elevator
How Does WebRTC Work?
How Does LTE Work?
How Does WiFi Work?
How Does Ethernet Work?
Wireless Networks and Shannon’s Law
Curate Don’t Dictate
Tied to Machines Podcast — Architecture
Principles of Architectural Leadership
How Does UDP Work?
Innovation with Constraints
How Does TCP Work?
How Do Websockets Work?
The Zero Bug Policy
How Does HTTP/2 Work?
Vendor Management is a Core Competency
Overambitious API gateways
Putting the R in D
Fault-Tolerance and Data Consistency Using Distributed Sagas
IaaS, PaaS, SaaS and Infrastructure
Alpha Conversion
Beta Reduction
Building Stateful Services with Kubernetes
Eta Reduction
Testing in Production — Building Observable Distributed Systems
Normal, Applicative and Lazy Evaluation
Representing Pairs and Lists in Lambda Calculus
Typed Lambda Calculus
A Guide to the Kubernetes Networking Model
Infrastructure in an Age of Commodities
Recursive Lambda Functions the Y-Combinator
Simplifying Lambda Syntax
Introducing Lambda Calculus
A Principled Approach to Architecture
Range, Domain, and Codomain
Functional Microservices
A Functional Programming Learning Plan
Practical Differences Between Functional and Imperative Programming
Why Functional Programming? The Benefits of Referential Transparency
Overcoming Optimism with a Premortem
What is Functional Programming?
Cloze Deletions
Improving Test Coverage Using Exploratory Outcomes
Bulk Generating Cloze Deletions for Learning a Language with Anki
Building Empathic Software Using Specification by Example
How Fast Does it Need to be Anyways? The QUPER Model of Analyzing Non-Functional Requirements
What is CQRS?
Dissecting SQS FIFO Queues — Does Ordered and Exactly Once Messaging Really Exist?
Learning a Language with Amazon Polly and a Serverless Chalice App
Evolving Messaging For Microservices: A Retrospective from Building Workiva’s Messaging Platform
How to create a functional VPC using CloudFormation
Compiling private Java code from Leiningen
Uploading Large Payloads through API Gateway
Getting Started With TLA+
Basic Math for TLA+
First Musings on TLA+
Paper Review: WebTables: Exploring the Power of Tables on the Web
Paper Review: Combining Systems and Databases: A Search Engine Retrospective
Publish-Subscribe Messaging Using Amazon SQS
Paper Review: The Anatomy of a Large-Scale Hypertextual Web Search Engine
Paper Review: Consistency Analysis in Bloom: a CALM and Collected Approach
SQS or Kinesis? Comparing Apples to Oranges
Software Architecture as Business Analysis
Paper Review: The CQL continuous query language: semantic foundations and query execution
Paper Review: BlinkDB: Queries with Bounded Errors and Bounded Response Times on Very Large Data
Paper Review: Informix under CONTROL: Online Query Processing
How Much is That Going to Cost Anyway? Calculating Cost of Goods Sold
Paper Review: An Array-Based Algorithm for Simultaneous Multidimensional Aggregates
Italics in Vim
Comparing Swagger with Thrift or gRPC
Being Good Enough
Yet Another S3 Static Site
Packaging a Custom Boomi Connector
Creating a Custom Dell Boomi Connector
Paper Review: Implementing Data Cubes Efficiently
Getting Started With Dell Boomi
Optimistic Locking in a REST API
Checking for null in an API Gateway transform
Effective Cache Control
Configuring REST-assured for Amazon API Gateway
Paper Review: Robust Query Processing through Progressive Optimization
Creating a Service Oriented Organization
Understanding API Gateway Payload Mappings
Securing a Swagger API with OAuth2
How to deploy a Swagger specification to Amazon API Gateway using CloudFormation
Designing a Swagger API
What is OSGi? Microservices for the JVM
Paper Review: The Volcano Optimizer Generator: Extensibility and Efficient Search
Paper Review: Dynamo: Amazon’s Highly Available Key-value Store
0 to Message in 60 Seconds: Getting Started with Amazon SQS
Paper Review: Cap Twelve Years Later: How the “Rules” Have Changed
Integrating Applications: From RPC to Messaging
Integrating Applications
Tests are Never Enough
The Problem with Point to Point Communication
A Guided Tour Through Thrift
Stability Anti-Patterns
Metrics-Driven Development
Testing a Producer-Consumer Design using a CyclicBarrier
Paper Review: Generalized Isolation Level Definitions
So you want to send a message using Apache Thrift?
Paper Review: DryadLINQ: A System for General-Purpose Distributed Data-Parallel Computing Using a High-Level Language
Paper Review: MapReduce: Simplified Data Processing on Large Clusters
Paper Review: OLTP Through the Looking Glass, and What We Found There
Getting Started with Amazon Flow Framework
Paper Review: Hekaton: SQL Server’s Memory-Optimized OLTP Engine
Paper Review: C-Store: A column-oriented DBMS
Concurrency: A Primer
Server-to-server OAuth with the Google OAuth Client Library for Java
Paper Review: Transaction Management in the R Distributed Database Management System
Paper Review: Concurrency Control Performance Modeling: Alternatives and Implications
Paper Review: Granularity of Locks and Degrees of Consistency in a Shared Data Base
Paper Review: ARIES: a transaction recovery method supporting fine-granularity locking and partial rollbacks using write-ahead logging
Deploying a static website with rsync
Thoughts On Google Cloud Platform Next
Paper Review: Access Path Selection in a Relational Database Management System
Paper Review: Eddies: Continuously Adaptive Query Processing
Paper Review: The Gamma Database Machine Project
Local Development with the Kinesis Client Library
Paper Review: The Design of POSTGRES
Paper Review: System R: Relational Approach to Database Management
The Five Stages of NoSQL
Paper Review: Architecture of a Database System
Generating Java with JCodeModel
Writing an Apache Beam Batch Sink
Deploying a Druid Cluster with Ansible
Paper Review: What Goes Around Comes Around
Deploying Zookeeper with Exhibitor to AWS using Ansible
Getting to Know Cloud Dataflow
Docker Step By Step: Containerizing Zookeeper
Why Java? Tales from a Python Convert
Including a local package as a Maven dependency
Configuring an Upstream Remote
Writing Repeated BigQuery records using the Java Client Library
From JSON to a Google API Client Library object
A Maven runner for vim-test
Deploying Kafka to Google Compute Engine
Kafka Quick Start Guide
Kafka in a Nutshell
Beginning Docker
A Review of the Coursera Data Science Specialization
Counting N-Grams with Cloud Dataflow
N-gram Modeling With Markov Chains
Modeling Natural Language with N-Gram Models
Structuring an Application using Model View Controller
Managed VMs and the Future of App Engine
Introducing CloudPyPI
App Engine Pipelines API - Part 6: The Pipeline UI
App Engine Pipelines API - Part 5: Asynchronous Pipelines
App Engine Pipelines API - Part 4: Pipeline Internals
App Engine Pipelines API - Part 3: Fan In, Fan Out, Sequencing
App Engine Pipelines API - Part 2: Connecting Pipelines
App Engine Pipelines API - Part 1: The Basics
Durabledict for App Engine
Continuous Delivery Distilled
Creating a BigQuery Table using the Java Client Library
Deploying R Studio on Compute Engine
Keeping App Engine Search Documents and Datastore Entities In Sync
Halting Python unittest Execution on First Error
Create a Google Cloud Dataflow Project with Gradle
A pypiserver Deployment Script
Downloading files from Google Cloud Storage with webapp2
Querying App Engine Logs with Elasticsearch
Parsing bash script options with getopts
Managing App Engine Dependencies Using pip
App Engine MapReduce API - Part 7: Writing a Custom Output Writer
The Bash String Operators
App Engine MapReduce API - Part 6: Writing a Custom Input Reader
Installing MySQL-Python on OS X Yosemite
Automatically Resizing a Compute Engine Disk
A Guided Tour of Google Compute Engine
Extracting the Start Sector of a Disk with fdisk
Packaging a Compute Engine Virtual Machine Image
Using the Google Prediction API to Predict the Sentiment of a Tweet
Suggested Searches with Google App Engine
Composing Asynchronous Functions With Tasklets
Working From Home: A Retrospective
Converting an ndb model to a BigQuery schema
Restoring an App Engine backup into a Big Query table
Bypassing ndb hooks with the RawDatastoreInputReader
Generating a C# client for an App Engine Cloud Endpoints API
Using Basic Authentication with Google Cloud Endpoints
Unit Testing Cloud Endpoints
Creating RESTful APIs with App Engine Cloud Endpoints
Running Multiple App Engine Modules Locally with dev_appserver.py
Downloading directories of code from Github using the Github API
How to bypass the auto_now property option during an ndb put
App Engine MapReduce API - Part 5: Using Combiners to Reduce Data Throughput
App Engine MapReduce API - Part 4: Combining Sequential MapReduce Jobs
Installing lxml on OS X Mavericks
App Engine MapReduce API - Part 3: Programmatic MapReduce using Pipelines
App Engine MapReduce API - Part 2: Running a MapReduce Job Using mapreduce.yaml
App Engine MapReduce API - Part 1: The Basics
Understanding JSON Patch
How to Version a REST API
When to Use HTTP PUT and HTTP POST
Stripe checkout opening in a new tab
How REST Constraints Affect API Design
On choosing a hypermedia type for your API - HAL, JSON-LD, Collection+JSON, SIREN, Oh My!
Three questions that define an ideal customer
How to get accepted to a business plan competition
Install node.js packages via npm with a Chef Cookbook
Photos is the Killer Feature of Google+
Apple has a Software Problem - Why I'll be Switching to Android
Creating a new file or directory in Vim using NERDTree
Submitting a Unity3d Game to the Mac App Store
Copying from Vim to the OS X Mountain Lion clipboard
Showing a local webpage in Unity3d using the Prime[31] etcetera plugin.
Using Unity3d with Version Control
Saving canvas data to an image file with JavaScript and PHP
Using Leiningen behind a Windows proxy
Date.now() in IE6
The JavaScript click event and hidden input elements
Dissecting jQuery's Fade Animation
An Argument Against JavaScript Minification
How to Display HTML5 Notifications
Constants in JavaScript
Understanding Closures in JavaScript
Safely remove the header from the WordPress TwentyTen theme
The future of mobile development
A cheap home server
And the winner is - Google Chrome!
How to install the real-time kernel in Ubuntu
How to get Pulse Audio to recognize your Delta 44 (and other ICE1712 cards)
Readability by Arc90
Share multiple mt-daap libraries
Mounting SAMBA shares from the command line
How to forward root users mail to an external address
How to monitor a RAID array in Ubuntu server