Archive

The Confusing Case of Git Signatures on GitHub March 2025
An explanation of some of the things GitHub does to smooth out the sharp edges of commit signing and one of the gotcha's with their process.

When NTP Interactions Go Wrong August 2024
A walkthrough of an issue with interactions with NTP that lead to vastly incorrect dates

Microsoft Gets A Firm Reprimand From the Cyber Safety Review Board April 2024
A review of the CSRB report on Microsoft's summer 2023 Exchange intrusion.

Modern Methods for Cross Site Request Forgery (CSRF) Protection February 2024
A dive into different methods to protect against cross site request forgery (CSRF). Including custom headers, signed double-submit cookies, and cookie settings.

The Next.js Conf Picture That Blew People's Minds October 2023
Seeing a SQL statement in a React component has caught the internet's attention in both good and bad ways. Let's discuss the different camps people have ended up in.

Building a FIPS-140 Compliant HTTPD Server October 2023
A dive into how to setup a FIPS-140 compliant Apache HTTPD server in Linux. A missing guide if you will that I wish I would have found when I had to take this journey

McKinsey Has Solved Developer Productivity Measurement August 2023
A critical view of a recent McKinsey article about measuring developer productivity.

Mechanical Sympathy in Software Development May 2023
Modern software abstractions are great but that doesn't discredit the benefit of understanding what happens beneath those abstractions.

When Proof of Concepts Become Production Code April 2023
Proof of concepts are invaluable in software development. If we allows ourselves to ship these POCs to production we introduce many risks.

The Transition to a Cloud-Native Developer March 2023
A look at what being a cloud-native developer means and some of the skills you will need to improve/gain to be successful.

ArchUnit: Testing the Design of Your Library January 2023
An overview of the ArchUnit library that allows the testing of the design of your Java code.

Coding is Not Enough: The Importance of Investing in Domain Knowledge January 2023
A discussion of the importance of gaining domain knowledge in software development as well as some ideas of how to gain domain knowledge.

The Different Types of Software Architects January 2023
There are many types of software architects. Let's consider a few of them and their strengths and weaknesses.

Comparing Different Ways to Build Proxies In Java December 2022
Comparing performance of various actions using inheritance, ByteBudy, and cglib in Java to create a proxy object.

DynamoDB And Incomplete Result Sets November 2022
A dive into an issue where results were not being returned by a query of a DynamoDB table and the results of the investigation.

Steps to Fast Track Your Growth As a Software Engineer October 2022
Concrete and proven steps you can take to speed up your career development no matter where you are in your career.

Programmer’s Writer Block: Make It Work, Make It Right, Make It Fast September 2022
A dive into the developer mantra of Make it work, make it right, make it fast. What it means and the affect it can have our your process.

Understanding The Dates Through the Julian and Gregorian Calendars September 2022
The interesting history of the Julian and Gregorian calendars and how it can affect developers in their work.

The Story Of The System, Discovering the “Why” Behind The System August 2022
There are many ways to document the reasonings behind why an application is built in a particular way. Let's review some options.

Java Virtual Threads, Millions of Threads Within Grasp August 2022
A dive into the Java 19 preview feature of virtual threads. What are they good for, what are they not good for, and more.

Mitigating SQL Injection in The Non-Standard Ways August 2022
A look into some of the less talked about SQL injection mitigation strategies that can be utilized in an application.

Analyzing New Unique Identifier Formats (UUIDv6, UUIDv7, and UUIDv8) August 2022
A dive into the new proposed UUID versions. What do they offer and how do they work.

Performance Differences of Java Streams July 2022
A benchmark comparison between different collection grouping in Java across different Java versions.

Applying the Composite Design Pattern July 2022
Using ElasticSearch and Jackson we explore the composite design pattern and how it can be useful in our development.

Modern Software Engineering by Dave Farley Book Review June 2022
A review of Dave Farley's Modern Software Engineering Build Better Software Faster.

An Argument For a Four-Year College Computer Science Degree May 2022
An argument set forth of the merits of a "traditional" computer science education.

Applying Wayfinding to Your Code Structure May 2022
Applying the process of wayfinding to development of code.

The Opportunity of Designing Within Technical Constraints April 2022
A look at technical constraints through the lens of them being an opportunity to grow, learn, and be creative.

Ideas on Performing High Value Code Reviews April 2022
Tips and tricks for performing high-value code reviews and affecting organizational change.

Make the Easy Thing the Right Thing April 2022
Discussion of exploiting human nature by making the right thing the easy thing when building systems.

The Case For Trying Completely Different Technologies March 2022
An explanation of why trying totally different technologies can be beneficial.

Pitfall When Using Java Okta SDK JWT Verifier March 2022
Quick explanation of a issue with the use of the Okta JWT verification code in Java and how to avoid it.

Imposter Syndrome - The Good Parts March 2022
A dive into some of the positives that can be recognized when we are presented with imposter syndrome.

Diving Into Kafka Partitioning By Building a Custom Partition Assignor March 2022
Digging into the details of partition assignment in Kafka as well as implementing our own custom partition assignment system.

Microservices Patterns by Chris Richardson Book Review February 2022
Review of Chris Richardson's "Microservice Patterns" book. Who it is for and what you can learn from it.

Effective Java! Consider Serialization Proxies Instead of Serialized Instances February 2022
A dive into chapter 90 of Effective Java

Supporting Cross Node Interactive Queries In Kafka Streams February 2022
By default interactive queries in Kafka streams does not support querying across nodes, let us change that.

Effective Java! For Instance Control, Prefer Enum types to readResolve February 2022
A dive into chapter 89 of Effective Java

How the Kafka Avro Serializer Works February 2022
Deep dive into how the Confluent Schema Registry and Kafka collaborate in order to use Avro in Kafka.

Understanding Avro Compatibility February 2022
Digging into the different compatibility levels of Avro that can be used and what they actually mean.

Effective Java! Write readObject Methods Defensively February 2022
A dive into chapter 88 of Effective Java

Cracking a Password Via a Side Channel January 2022
Explanation of how to build a website to help solve Wordle puzzles by analyzing how the game works.

Building a Wordle Solver January 2022
Explanation of how to build a website to help solve Wordle puzzles by analyzing how the game works.

Effective Java! Consider Using a Custom Serialized Form January 2022
A dive into chapter 87 of Effective Java

Effective Java! Implement Serializable With Great Caution January 2022
A dive into chapter 86 of Effective Java

Effective Java! Prefer Alternatives To Java Serialization January 2022
A dive into chapter 85 of Effective Java

Effective Java! Don't Depend on the Thread Scheduler December 2021
A dive into chapter 84 of Effective Java

Effective Java! Use Lazy Initialization Judiciously December 2021
A dive into chapter 83 of Effective Java

Effective Java! Document Thread Safety December 2021
A dive into chapter 82 of Effective Java

Effective Java! Prefer Concurrency Utilities Over wait and notify November 2021
A dive into chapter 81 of Effective Java

Effective Java! Prefer Executors, Tasks, and Streams to Threads November 2021
A dive into chapter 80 of Effective Java

Effective Java! Avoid Excessive Synchronization November 2021
A dive into chapter 79 of Effective Java

Effective Java! Synchronize Access to Shared Mutable Data November 2021
A dive into chapter 78 of Effective Java

Effective Java! Don't Ignore Exceptions October 2021
A dive into chapter 77 of Effective Java

Effective Java! Strive for Failure Atomicity October 2021
A dive into chapter 76 of Effective Java

Effective Java! Include Failure-Capture Information in Detail Messages September 2021
A dive into chapter 75 of Effective Java

Effective Java! Document All Exceptions Thrown By Each Method September 2021
A dive into chapter 74 of Effective Java

Effective Java! Throw Exceptions Appropriate To The Abstraction September 2021
A dive into chapter 73 of Effective Java

Effective Java! Favor The Use of Standard Exceptions August 2021
A dive into chapter 72 of Effective Java

The Wild World of Unique Identifiers (UUID, ULID, etc) August 2021
A whirlwind tour of different identifier generation algorithms and the benefits and downsides to them.

Effective Java! Avoid Unnecessary Use of Checked Exceptions August 2021
A dive into chapter 71 of Effective Java

Effective Java! Use Checked Exceptions for Recoverable Conditions August 2021
A dive into chapter 70 of Effective Java

Effective Java! Use Exceptions for Only Exceptional Circumstances July 2021
A dive into chapter 69 of Effective Java

Effective Java! Adhere to Generally Accepted Naming Conventions July 2021
A dive into chapter 68 of Effective Java

Effective Java! Optimize Judiciously July 2021
A dive into chapter 67 of Effective Java

Effective Java! Use Native Methods Judiciously June 2021
A dive into chapter 66 of Effective Java

Effective Java! Prefer Interfaces To Reflection June 2021
A dive into chapter 65 of Effective Java

Effective Java! Refer to Objects By Their Interfaces June 2021
A dive into chapter 64 of Effective Java

Effective Java! Beware the Performance of String Concatenation May 2021
A dive into chapter 63 of Effective Java

Building an S3 Lowercaser May 2021
Leveraging S3 event notifications and AWS Lambda to automatically lower case all object keys in a bucket

Effective Java! Avoid Strings When Other Types Are More Appropriate April 2021
A dive into chapter 62 of Effective Java

How I Built an Overengineered Serverless Uptime Checker April 2021
Walk through of some of the design decisions around an service uptime tracker on AWS Lambda.

Effective Java! Prefer Primitive Types to Boxed Types April 2021
A dive into chapter 61 of Effective Java

Effective Java! Avoid Float and Double If Exact Answers Are Required March 2021
A dive into chapter 60 of Effective Java

Effective Java! Know and Use the Libraries March 2021
A dive into chapter 59 of Effective Java

Effective Java! Prefer for-each loops to traditional for loops February 2021
A dive into chapter 58 of Effective Java

Effective Java! Minimize The Scope of Local Variables February 2021
A dive into chapter 57 of Effective Java

Effective Java! Write Doc Comments For All Exposed APIs January 2021
A dive into chapter 56 of Effective Java

Effective Java! Return Optionals Judiciously December 2020
A dive into chapter 55 of Effective Java

Effective Java! Return Empty Collections or Arrays, Not Nulls December 2020
A dive into chapter 54 of Effective Java

Effective Java! Use Varargs Judiciously December 2020
A dive into chapter 53 of Effective Java

Effective Java! Use Overloading Judiciously November 2020
A dive into chapter 52 of Effective Java

Effective Java! Design Method Signatures Carefully November 2020
A dive into chapter 51 of Effective Java

Effective Java! Make Defensive Copies When Necessary November 2020
A dive into chapter 50 of Effective Java

Effective Java! Use Caution When Making Streams Parallel October 2020
A dive into chapter 48 of Effective Java

Effective Java! Prefer Collection To Stream as a Return Type October 2020
A dive into chapter 47 of Effective Java

Effective Java! Prefer Side-Effect-Free Functions in Streams October 2020
A dive into chapter 46 of Effective Java

Effective Java! Use Stream Judiciously October 2020
A dive into chapter 45 of Effective Java

Effective Java! Favor the Use of Standard Functional Interfaces September 2020
A dive into chapter 44 of Effective Java

Effective Java! Prefer Method References to Lambdas September 2020
A dive into chapter 43 of Effective Java

Effective Java! Prefer Lambdas to Anonymous Classes September 2020
A dive into chapter 42 of Effective Java

Effective Java! Use Marker Interfaces to Define Types September 2020
A dive into chapter 41 of Effective Java

Effective Java! Check Parameters for Validity September 2020
A dive into chapter 49 of Effective Java

Effective Java! Consistently Use the Override Annotation August 2020
A dive into chapter 40 of Effective Java

Effective Java! Prefer Annotations to Naming Patterns August 2020
A dive into chapter 39 of Effective Java

Effective Java! Emulate Extensible Enums With Interfaces August 2020
A dive into chapter 38 of Effective Java

Effective Java! Use EnumMap instead of Ordinal Indexing August 2020
A dive into chapter 37 of Effective Java

Effective Java! Use EnumSet Instead of Bit Fields August 2020
A dive into chapter 36 of Effective Java

Effective Java! Use Instance Fields Instead of Ordinals July 2020
A dive into chapter 35 of Effective Java

Effective Java! Use Enums Instead of int Constants July 2020
A dive into chapter 34 of Effective Java

Effective Java! Consider Typesafe Heterogenous Containers July 2020
A dive into chapter 33 of Effective Java

Effective Java! Combine Generics and Varargs Judiciously July 2020
A dive into chapter 32 of Effective Java

Effective Java! Use Bounded Wildcards to Increase API Flexibility June 2020
A dive into chapter 31 of Effective Java

Effective Java! Favor Generic Methods June 2020
A dive into chapter 30 of Effective Java

Effective Java! Favor Generic Types June 2020
A dive into chapter 29 of Effective Java

Effective Java! Prefer Lists to Array June 2020
A dive into chapter 28 of Effective Java

Effective Java! Eliminate Unchecked Warnings June 2020
A dive into chapter 27 of Effective Java

Effective Java! Don't Use Raw Types May 2020
A dive into chapter 26 of Effective Java

Effective Java! Limit Source Files to a Single Top-Level Class May 2020
A dive into chapter 25 of Effective Java

Effective Java! Favor Static Members Classes over Non-Static May 2020
A dive into chapter 24 of Effective Java

Effective Java! Prefer Class Hierarchies to Tagged Classes May 2020
A dive into chapter 23 of Effective Java

Effective Java! Use Interfaces Only to Define Types April 2020
A dive into chapter 22 of Effective Java

Effective Java! Design Interfaces for Posterity April 2020
A dive into chapter 21 of Effective Java

Effective Java! Prefer Interfaces to Abstract Classes April 2020
A dive into chapter nineteen of Effective Java

Effective Java! Design and Document Classes for Inheritance or Else Prohibit It. April 2020
A dive into chapter nineteen of Effective Java

Effective Java! Favor Composition Over Inheritance March 2020
A dive into chapter seventeen of Effective Java

Effective Java! Minimize Mutability March 2020
A dive into chapter seventeen of Effective Java

Effective Java! In Public Classes, Use Accessors, Not Public Fields March 2020
A dive into chapter sixteen of Effective Java

Effective Java! Minimize the Accessibility of Classes and Member March 2020
A dive into chapter fifteen of Effective Java

Effective Java! Consider Implementing Comparable February 2020
A dive into chapter fourteen of Effective Java

Effective Java! Override clone judiciously February 2020
A dive into chapter twelve of Effective Java

Effective Java! Override toString February 2020
A dive into chapter eleven of Effective Java

Effective Java! Obey the hashcode contract January 2020
A dive into chapter ten of Effective Java

Effective Java! Obey the equals contract January 2020
A dive into chapter seven of Effective Java

Effective Java! Prefer try-with-resources November 2019
A dive into chapter seven of Effective Java

Effective Java! Avoid Finalizers and Cleaners! November 2019
A dive into chapter seven of Effective Java

Effective Java! Don't Leak Object References! October 2019
A dive into chapter seven of Effective Java

Effective Java! Avoid Creating Unnecessary Objects! October 2019
A dive into chapter six of Effective Java

Effective Java! Prefer Dependency Injection! October 2019
A dive into chapter five of Effective Java

Effective Java! Utility Classes! October 2019
A dive into chapter four of Effective Java

Effective Java! Singletons! October 2019
A dive into chapter three of Effective Java

Effective Java! The Builder Pattern! September 2019
A dive into chapter two of Effective Java

Effective Java! Let's Consider Static Factory Methods September 2019
A dive into chapter one of Effective Java

Creating a Multi-Node Websocket Service with Spring August 2018
Walk through of how to get a multi-node Spring STOMP websocket service started.

Creating a Safe Culture of Rollback May 2018
As an organization transitions to having a devops culture one of the many things that we have to overcome is the culture to be able to rollback.

Dev, Test, Prod: How Similar is Good Enough March 2018
We all know that your development environment should mirror your production environment, but what does that actually mean? How close is close enough?

Negotiation in Guiding Architecture March 2018
There are many soft skills to being an architect.

Working Around Classpath Issues January 2018
Working in a legacy codebase can lead difficulty with conflicts on the classpath. This article details a solution taken to get around this issue.

Should Architects Code December 2017
An often asked question of whether Software Architects should code.

A Serverless Christmas List December 2017
Experience building an (almost) completely serverless application and lessons learned.

The Reason Why November 2017
The power of knowing the reason why you are building something can totally change the way software is built.

Being a Young Architect August 2017
I have been thrust into a role as an architect at a young age and with very limited experience. This post serves as a bit of a diary of my struggle with imposter syndrome.

Rummikub and Refactoring August 2017
Recently when discussing refactoring at work I was reminded of an experience of playing a board game with my family. That game was Rummikub.

The Need For Intentional Design August 2017
In the current software development community Agile is kind and agile puts it's weight behind emergent architecture. So is intentional architecture dead?

Choosing Technology that is Right, Not Cool August 2017
Developers love to play with the latest technology, however we must remember that it is not cool that pays the salary but delivering value to customers.

JSON Grammar July 2017
A JSON grammar exists and some of the things are shocking

The Flexibility of Open Source July 2017
The options that are opened up when a developer has access to the source code really are endless.