<?xml version="1.0"?>
<rss version="2.0">
    <channel>
        <title>kdgregory.com</title>
        <link>https://www.kdgregory.com/index.php?page=home</link>
        <description>Keith Gregory's home page</description>
        <language>en-us</language>
        <lastBuildDate>Mon, 01 Dec 2025 13:23:47 +0000</lastBuildDate>
        <ttl>1440</ttl>


        <item>
            <title>A Year With Tabitha</title>
            <link>https://www.kdgregory.com/index.php?page=rv.tabitha</link>
            <pubDate>Mon, 01 Dec 2025 10:30:00 +0000</pubDate>
            <description>
                Tabitha is our 2025 nuCamp T@B 400 travel trailer. We brought her home on Black Friday 2024, and have spent the past year vacationing with her. This is the story of that experience, and the things we learned as newbie trailer owners.
            </description>
        </item>
        
        <item>
            <title>Green Peas on the Highway: A Week in a Rental Motorhome</title>
            <link>https://www.kdgregory.com/index.php?page=rv.rental</link>
            <pubDate>Mon, 01 Dec 2025 10:30:00 +0000</pubDate>
            <description>
                In 2020, we opted for a socially-distanced vacation. If you&#039;re thinking of doing the same, here are some things we learned.
            </description>
        </item>
        
        <item>
            <title>Asynchronous Operations in Swing</title>
            <link>https://www.kdgregory.com/index.php?page=swing.async</link>
            <pubDate>Sat, 12 Sep 2020 08:00:00 +0000</pubDate>
            <description>
                This article looks thread management in a Swing GUI. There&#039;s more to success than simply spinning up background threads for long-running operations: you need to get the results of these operations back to the user, control the sequencing of not-quite-independent operations, and provide feedback to the user while the operation is running.
            </description>
        </item>
        
        <item>
            <title>Using the Cognito Hosted UI with an Application Load Balancer</title>
            <link>https://www.kdgregory.com/index.php?page=aws.albCognito</link>
            <pubDate>Tue, 18 Aug 2020 08:30:00 +0000</pubDate>
            <description>
                The Application load balancer started life as a way to support micro-service back-ends from a single exposed endpoint. Since then it&#039;s added features such as support for Lambda as a back-end, fixed responses, and -- the focus of this article -- the ability to use Cognito or other identity providers to authenticate users before they even get to your application.
            </description>
        </item>
        
        <item>
            <title>Writing Log4J 2.x Plugins</title>
            <link>https://www.kdgregory.com/index.php?page=logging.log4j2Plugins</link>
            <pubDate>Sun, 05 Apr 2020 08:00:00 +0000</pubDate>
            <description>
                I recently implemented Log4J 2.0 support for my AWS appenders project. When I started, I was hoping to find some sort of &quot;here&#039;s how to implement a Log4J2 appender&quot; posting, either in the project docs or the open Internet. But either my Googling skills are getting worse, or there aren&#039;t any other independent postings on the subject. And as for the project documentation ... well, Apache projects aren&#039;t exactly known for the quality of their docs. So this is my distillation of how to write an appender, a layout, and a lookup.
            </description>
        </item>
        
        <item>
            <title>Building a Logging Pipeline on AWS</title>
            <link>https://www.kdgregory.com/index.php?page=aws.loggingPipeline</link>
            <pubDate>Wed, 25 Sep 2019 08:00:00 +0000</pubDate>
            <description>
                Moving to the cloud makes logging more difficult: not only do you have multiple instances of the same application, but your virtual machines start up and shut down based on load, and locally-stored logs disappear when that happens. Centralized log aggregation is the answer, and this article shows an implementation based on AWS managed services.
            </description>
        </item>
        
        <item>
            <title>Byte Buffers and Non-Heap Memory</title>
            <link>https://www.kdgregory.com/index.php?page=java.byteBuffer</link>
            <pubDate>Sun, 22 Jan 2017 10:00:00 +0000</pubDate>
            <description>
                Most Java programs spend their time working with objects on the JVM heap, using getter and setter methods to retrieve or change the data in those objects. A few programs, however, need to do something different. Perhaps they&#039;re exchanging data with a program written in C. Or they need to manage large chunks of data without the risk of garbage collection pauses. Or maybe they need efficient random access to files. For all these programs, a java.nio.ByteBuffer provides an alternative to traditional Java objects.
            </description>
        </item>
        
        <item>
            <title>Building a Maven repository by combining S3, Nexus, and Lambda</title>
            <link>https://www.kdgregory.com/index.php?page=maven.s3Deploy</link>
            <pubDate>Fri, 28 Oct 2016 09:00:00 +0000</pubDate>
            <description>
                A repository server, such as Sonatype Nexus, is incredibly useful if you use Maven (or any tool that uses Maven repositories, such as Gradle or Leiningen). However, you may have decided not to pursue this route due to the problem of credential management, and instead deploy directly to a bucket on Amazon S3. This article describes how to combine the two: publishing to S3, and then republishing to Nexus via an AWS Lambda process. It&#039;s also useful as a starter guide for Lambda.
            </description>
        </item>
        
        <item>
            <title>Java Serialization</title>
            <link>https://www.kdgregory.com/index.php?page=java.serialization</link>
            <pubDate>Thu, 10 Dec 2015 07:00:00 +0000</pubDate>
            <description>
                Java&#039;s built-in serialization mechanism has a bad reputation; everybody seems to have a story of serialization gone wrong. But I don&#039;t think it deserves that reputation. This article shows how, with a little care, Java serialization can be a useful tool for short-term data persistence.
            </description>
        </item>
        
        <item>
            <title>Practical XML: XPath</title>
            <link>https://www.kdgregory.com/index.php?page=xml.xpath</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                XPath is a way to select portions of an XML document, modeled on the paths of a filesystem, with the addition of tests on the content and attributes of each node. This article describes how to work with XPath from Java, and work around the pitfalls you&#039;ll find there.
            </description>
        </item>
        
        <item>
            <title>Practical XML: Parsing</title>
            <link>https://www.kdgregory.com/index.php?page=xml.parsing</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                Describes how to use the JDK&#039;s DOM parser, including validation using both DTD and XML Schema.
            </description>
        </item>
        
        <item>
            <title>Practical XML: Output</title>
            <link>https://www.kdgregory.com/index.php?page=xml.builder</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                XML output is surprising tricky to get right. Between entity escape rules and incompatible encodings, it&#039;s a wonder that there&#039;s any well-formed XML in the real world. This article describes some of the pitfalls, shows how to use the APIs built into the JDK, and then presents a simpler alternative.
            </description>
        </item>
        
        <item>
            <title>Practical Git: A Workflow to Preserve Your Sanity</title>
            <link>https://www.kdgregory.com/index.php?page=scm.git</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                Git is becoming the source control system of choice for many teams. It has some distinct advantages over centralized SCM tools such as Subversion, particularly for distributed teams and Agile processes. However, it also offers the opportunity for disaster, by giving developers the opportunity to live in their own little world, and will exacerbate any communication problems that a team already has. This article provides tips and techniques for working in a distributed, branchy world.
            </description>
        </item>
        
        <item>
            <title>JSP Refactoring via Static Includes</title>
            <link>https://www.kdgregory.com/index.php?page=jsp.refactoring</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                A large, monolithic JSP is the same as a large, monolithic method; refactoring can make both easier to manage. This article describes a technique similar to &quot;extract method&quot;, in which portions of the JSP are extracted into statically included fragments.
            </description>
        </item>
        
        <item>
            <title>So You Think You&#039;re Covered?</title>
            <link>https://www.kdgregory.com/index.php?page=junit.coverage</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                Coverage tools are great for telling you about code that you haven&#039;t tested. They&#039;re not so good at telling you what tests to write or what mainline code needs to be written. This article looks at the limitations of these tools, and how you can work around them.
            </description>
        </item>
        
        <item>
            <title>Refactoring Unit Tests</title>
            <link>https://www.kdgregory.com/index.php?page=junit.refactoring</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                Unit tests are often used to support refactoring mainline code, but tests themselves are candidates for refactoring. This article examines techniques for doing just that.
            </description>
        </item>
        
        <item>
            <title>Creating Mocks and Stubs with Reflection Proxies</title>
            <link>https://www.kdgregory.com/index.php?page=junit.proxy</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                Reflection proxies, introduced in JDK 1.3, allow you to write a class that implements only part of an interface. This can be very useful with unit tests, when you don&#039;t want to go to the time and trouble to implement a fully-functional collaborator, or where you need to stub out classes that aren&#039;t in a freely available mock objects package.
            </description>
        </item>
        
        <item>
            <title>A Controller-based Approach to Swing Applications</title>
            <link>https://www.kdgregory.com/index.php?page=swing.controller</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                Far too many Swing applications follow the anti-pattern of subclassing a JDK container class in order to add components. This article describes an alternative, in which a controller class builds the UI and manages external interaction with its components.
            </description>
        </item>
        
        <item>
            <title>Understanding OutOfMemoryError</title>
            <link>https://www.kdgregory.com/index.php?page=java.outOfMemory</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                OutOfMemoryError is a frustrating exception: usually it indicates a bug in your code, but sometimes it happens when your have plenty of free space in the Java heap. This article looks at the different causes of OutOfMemoryError, and what you can do about them.
            </description>
        </item>
        
        <item>
            <title>Enum: Not Just a Constant With a Pretty Face</title>
            <link>https://www.kdgregory.com/index.php?page=java.enum</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                The typesafe enum pattern was made part of the Java language with the 1.5 release. This article looks at programming techniques that exploit the fact that enums are in fact Java objects, not simply named constants.
            </description>
        </item>
        
        <item>
            <title>Effective Logging</title>
            <link>https://www.kdgregory.com/index.php?page=java.logging</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                This article covers techniques to make logging more useful as a debugging tool, and less intrusive to the logical flow of your program code.
            </description>
        </item>
        
        <item>
            <title>Java Reference Objects</title>
            <link>https://www.kdgregory.com/index.php?page=java.refobj</link>
            <pubDate>Mon, 27 Apr 2015 20:00:00 +0000</pubDate>
            <description>
                Reference objects allow you to interact with the garbage collector, specifying levels of reachability between &quot;in use&quot; and &quot;gone.&quot; This article is based on a presentation that I gave to the Philadelphia Java User&#039;s Group in December 2007, providing an overview of the Java object life-cycle and practical examples of when and why you&#039;d use reference objects.
            </description>
        </item>
        
        <item>
            <title>Riding the Auto Train</title>
            <link>https://www.kdgregory.com/index.php?page=train.autotrain</link>
            <pubDate>Sat, 21 Mar 2015 12:00:00 +0000</pubDate>
            <description>
                The Auto Train is Amtrak&#039;s route for snowbirds: an overnight train from Virginia to Florida, where your car rides with you. I&#039;m not a snowbird, but my wife and I took the train for our vacation. Here are my thoughts on the trip, along with some information that I would have liked to know before the trip.
            </description>
        </item>
        
        <item>
            <title>Writing a Java Micro-benchmark</title>
            <link>https://www.kdgregory.com/index.php?page=java.microBenchmark</link>
            <pubDate>Thu, 10 Jul 2014 08:00:00 +0000</pubDate>
            <description>
                A micro-benchmark is designed to evaluate the performance of a short piece of code, typically in comparison to other code that provides the same functionality. While they can be valuable, they&#039;re only valid within the context of a particular execution environment. This article discusses how to compensate for the environment and interpret results.
            </description>
        </item>
        
        <item>
            <title>Tunneling to an HTTP Proxy</title>
            <link>https://www.kdgregory.com/index.php?page=ssh.proxy</link>
            <pubDate>Wed, 27 Jun 2012 07:30:00 +0000</pubDate>
            <description>
                If you&#039;re using an unsecured wireless network, as in a coffeeshop or conference hall, anyone in range can listen to your network traffic. And if you connect to a site via unsecured HTTP, they can pull your password or access tokens out of that traffic. This article describes how to set up a remote proxy and an encrypted connection to that proxy, meaning that you only have to worry about network sniffers on the Internet backbone.
            </description>
        </item>
        
        <item>
            <title>Weekend in West Virginia</title>
            <link>https://www.kdgregory.com/index.php?page=mc.wv</link>
            <pubDate>Sun, 27 May 2012 12:30:00 +0000</pubDate>
            <description>
                West Virginia is one of my favorite states for motorcycling, and this is the story of a recent four day trip to and around Lewisburg, in the southern portion of the state.
            </description>
        </item>
        
        <item>
            <title>Ancho-Lime Grilled Salmon</title>
            <link>https://www.kdgregory.com/index.php?page=food.salmon</link>
            <pubDate>Sun, 01 May 2011 18:00:00 +0000</pubDate>
            <description>
                A recipe for grilled salmon with an ancho-lime sauce. Even people that don&#039;t like salmon like this salmon.
            </description>
        </item>
        
        <item>
            <title>Motorcycling Across Pennsylvania</title>
            <link>https://www.kdgregory.com/index.php?page=mc.pa_east_to_west</link>
            <pubDate>Tue, 06 Jul 2010 07:30:00 +0000</pubDate>
            <description>
                It&#039;s hard to find a motorcycle-friendly road that heads west from eastern Pennsylvana; this article looks at a few of the routes that I&#039;ve found, along with an in-state destination for when you give up.
            </description>
        </item>
        
        <item>
            <title>Creating a Micro-View with JSP Taglibs</title>
            <link>https://www.kdgregory.com/index.php?page=jsp.microViews</link>
            <pubDate>Wed, 18 Mar 2009 08:30:00 +0000</pubDate>
            <description>
                The traditional MVC implementation, where the controller creates a model containing all the data for a page, breaks down with complex pages where the markup changes depending on model data. This article looks at an alternative, in which a JSP tag creates a model that applies only to its body.
            </description>
        </item>
        
        <item>
            <title>The Dark Side of C++ Templates</title>
            <link>https://www.kdgregory.com/index.php?page=java.generics.cpp</link>
            <pubDate>Wed, 11 Feb 2009 09:00:00 +0000</pubDate>
            <description>
                One of the perceived drawbacks of Java&#039;s parameterized types is that type erasure means they&#039;re not truly typesafe. In this article I show that C++ templates aren&#039;t terribly typesafe either, at least for people who are willing to misuse them.
            </description>
        </item>
        
        <item>
            <title>In Defense of Parameterized Types</title>
            <link>https://www.kdgregory.com/index.php?page=java.generics</link>
            <pubDate>Sat, 17 Jan 2009 16:00:00 +0000</pubDate>
            <description>
                Parameterized types, aka Generics, have received a lot of negative press. In this article, I gloss over their bad features, and show how they can make our programs more concise and error-free.
            </description>
        </item>
        
        <item>
            <title>Baking with Sourdough -- Photos</title>
            <link>https://www.kdgregory.com/index.php?page=sourdough2</link>
            <pubDate>Mon, 01 Sep 2008 11:00:00 +0000</pubDate>
            <description>
                Photos to go with the sourdouh article.
            </description>
        </item>
        
        <item>
            <title>Gluten-free Kasha (buckwheat) Pancakes</title>
            <link>https://www.kdgregory.com/index.php?page=buckwheat</link>
            <pubDate>Mon, 11 Aug 2008 17:00:00 +0000</pubDate>
            <description>
                Recipe for gluten-free pancakes using ground kasha or buckwheat flour.
            </description>
        </item>
        
        <item>
            <title>Motorcycling in Southeast Pennsylvania</title>
            <link>https://www.kdgregory.com/index.php?page=mc.se.pa</link>
            <pubDate>Sun, 27 Jul 2008 22:00:00 +0000</pubDate>
            <description>
                A motorcycle-friendly loop anchored by King of Prussia, Reading, and Allentown.
            </description>
        </item>
        
        <item>
            <title>Baking with Sourdough</title>
            <link>https://www.kdgregory.com/index.php?page=sourdough</link>
            <pubDate>Sun, 29 Jun 2008 12:00:00 +0000</pubDate>
            <description>
                Recipe and process for baking sourdough bread.
            </description>
        </item>
            </channel>
</rss>
