<?xml version="1.0" encoding="UTF-8" standalone="no"?><?xml-stylesheet href="http://www.blogger.com/styles/atom.css" type="text/css"?><rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" version="2.0"><channel><title>frickjack</title><description>https://blog.frickjack.com/</description><managingEditor>noreply@blogger.com (Anonymous)</managingEditor><pubDate>Sun, 26 Apr 2026 05:17:13 -0500</pubDate><generator>Blogger http://www.blogger.com</generator><openSearch:totalResults xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/">147</openSearch:totalResults><openSearch:startIndex xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/">1</openSearch:startIndex><openSearch:itemsPerPage xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/">25</openSearch:itemsPerPage><link>http://blog.frickjack.com/</link><language>en-us</language><itunes:explicit>no</itunes:explicit><itunes:subtitle>Reuben won't shutup!</itunes:subtitle><itunes:category text="Technology"><itunes:category text="Software How-To"/></itunes:category><itunes:owner><itunes:email>noreply@blogger.com</itunes:email></itunes:owner><item><title>Succeeding at Failure</title><link>http://blog.frickjack.com/2025/07/succeeding-at-failure.html</link><author>noreply@blogger.com (Reuben)</author><pubDate>Sun, 20 Jul 2025 15:27:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-6283836131707813895</guid><description>
  A common interview question is, "tell me about a time you failed, and what did you learn from it".  I was asked that question several years ago, and I replied with some examples of projects that failed, but I did not have a good answer for what I learned - another failure!


  I have several ideas about failure.  First, if you never fail, then you're not trying hard enough; or you're not </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>tips for ardour on linux</title><link>http://blog.frickjack.com/2021/07/tips-for-ardour-on-linux.html</link><category>ardour</category><category>DAW</category><category>linux</category><author>noreply@blogger.com (Reuben)</author><pubDate>Sun, 4 Jul 2021 14:54:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-1189798846565027596</guid><description>Problem and Audience

Your browser does not support the audio element.


A broad selection of digital audio workstation (DAW) software are available for Mac and Windows computers including logic pro, abelton live, and garage band.  These popular DAWs are not available on Linux (which I run on my laptop), but several good DAWs do run on Linux - including ardour.  Ardour has a rich set of features,</description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>gradle to sbt for scala3</title><link>http://blog.frickjack.com/2021/07/gradle-to-sbt-for-scala3.html</link><category>gradle</category><category>sbt</category><category>scala</category><author>noreply@blogger.com (Reuben)</author><pubDate>Sun, 4 Jul 2021 14:41:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-3318344237587526840</guid><description>Problem and Audience

Your browser does not support the audio element.


Scala 3 is an overhaul of the guts of the scala language type system and compiler that was recently released (in mid 2021) for general use.  Unfortunately, the scala plugin for gradle does not yet support the new scala-3 build chain, so we ported littleware to scala&amp;#39;s sbt build tool.
Porting a gradle build to an sbt </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">1</thr:total></item><item><title>Little UX Guidelines</title><link>http://blog.frickjack.com/2021/06/little-ux-guidelines.html</link><category>CSS</category><category>design</category><category>UX</category><author>noreply@blogger.com (Reuben)</author><pubDate>Wed, 23 Jun 2021 06:26:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-349699179724699861</guid><description>Problem and Audience
A good understanding of a system&amp;#39;s UX design drives the architecture of the underlying software that implement that design.  The CSS rules, the site map and navigation experience, and the javascript component hierarchy and state management all rely on the developer&amp;#39;s mental model of the design she is implementing.  Unfortunately, many software developers like myself </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Jamstack Cloudformation</title><link>http://blog.frickjack.com/2021/06/jamstack-clouformation.html</link><category>cloudformation</category><category>cloudfront</category><category>jamstack</category><category>s3</category><author>noreply@blogger.com (Reuben)</author><pubDate>Thu, 10 Jun 2021 13:28:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-7563216283549164384</guid><description>Problem and Audience
A simple clouformation template makes it easy to stamp out AWS infrastructure for a jamstack web site.  A jamstack is a web site composed of static presentation (non-API) resources (html, css, javascript) assembled at build time - as opposed to a site that requires some kind of dynamic server side rendering of resources at request time.  A nice feature of this architecture is</description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>route53 and cloudformation</title><link>http://blog.frickjack.com/2021/06/route53-and-cloudformation.html</link><category>aws</category><category>cloudformation</category><category>route53</category><author>noreply@blogger.com (Reuben)</author><pubDate>Mon, 7 Jun 2021 14:33:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-5955429096864701203</guid><description>Problem and Audience
Managing route53 records with cloudformation is a good idea for the same reasons that tracking other resources with cloudformation (or terraform or whatever) is better than clicking around in the web console - namely:

it is less work to manipulate route53 records by editing json files than clicking through the web console
tracking the cloudformation template and parameters </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Porting https://apps.frickjack.com to hugo</title><link>http://blog.frickjack.com/2021/06/porting-httpsappsfrickjackcom-to-hugo.html</link><category>hugo</category><category>javascript</category><author>noreply@blogger.com (Reuben)</author><pubDate>Wed, 2 Jun 2021 17:22:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-7053939507305374975</guid><description>Problem and Audience
A web site may be architected in various ways: from a simple collection of static html, javascript, and css files behind a web server; to a site administered by a content management system; to a web application built on custom server or client side software.  
The appropriate design for a particular site is the one that best balances the requirements of the site&amp;#39;s </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Simple Java/Scala Configuration Injection with Guice</title><link>http://blog.frickjack.com/2021/05/simple-javascala-configuration.html</link><category>guice</category><category>java</category><category>scala</category><author>noreply@blogger.com (Reuben)</author><pubDate>Mon, 17 May 2021 17:38:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-6952851043642043723</guid><description>Problem and Audience
One of the things every microservice needs is a mechanism
for injecting configuration, so we developed a little json configuration helper for our littleware scala code that overlays a hierarchy of json configuration objects, and integrates with our module runtime and dependency-injection framework.
Configuration in Littleware
Littleware has a simple ServiceLoader based module</description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Supporting Cloudformation Patterns with Nunjucks</title><link>http://blog.frickjack.com/2021/05/supporting-cloudformation-patterns-with.html</link><category>aws</category><category>cloudformation</category><category>nunjucks</category><author>noreply@blogger.com (Reuben)</author><pubDate>Mon, 17 May 2021 14:35:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-1167198015914577426</guid><description>Problem and Audience
Since cloudformation templates
do not natively support the dynamic resource provisioning patterns
required for many cloud architectures, various
extensions and template generators have emerged
(like CDK 
and SAM).
The little stack tools allow the use of the nunjucks template language in cloudformation templates
to support various infrastructure patterns.
Overview of little </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">1</thr:total></item><item><title>AWS codebuild for scala, docker (ecr) CI</title><link>http://blog.frickjack.com/2021/04/aws-codebuild-for-scala-docker-ecr-ci.html</link><category>aws</category><category>cicd</category><category>docker</category><category>ecr</category><category>gradle</category><category>scala</category><author>noreply@blogger.com (Reuben)</author><pubDate>Tue, 13 Apr 2021 15:06:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-6272344690482913135</guid><description>Problem and Audience
A continuous integration (CI) process that builds and tests our code,
then publishes versioned deployable artifacts (docker images) 
is a prerequisite for deploying stable software services in the cloud.
There are a wide variety of good, inexpensive CI services available,
but we decided to build littleware&amp;#39;s CI system on AWS codebuild, because it provides an easy to use </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total><georss:featurename xmlns:georss="http://www.georss.org/georss">Chicago, IL, USA</georss:featurename><georss:point xmlns:georss="http://www.georss.org/georss">41.8781136 -87.6297982</georss:point><georss:box xmlns:georss="http://www.georss.org/georss">13.567879763821153 -122.7860482 70.188347436178844 -52.473548199999996</georss:box></item><item><title>Setup ECR on AWS</title><link>http://blog.frickjack.com/2021/04/setup-ecr-on-aws.html</link><category>aws</category><category>docker</category><category>ecr</category><author>noreply@blogger.com (Reuben)</author><pubDate>Fri, 9 Apr 2021 13:03:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-5049995332093476579</guid><description>Problem and Audience
Setting up an ECR repository 
for publishing docker images is a good first step toward deploying
a docker-packaged application on AWS (ECS, EKS, EC2, lambda, ...).
Although we use ECR like any other docker registry, there are
a few optimizations we can make when setting up a repository.
Overview
We should consider the workflow around the creation and use of our Docker images </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Sign and Verify JWT with ES256</title><link>http://blog.frickjack.com/2021/04/sign-and-verify-jwt-with-es256.html</link><category>es256</category><category>jwt</category><category>scala</category><author>noreply@blogger.com (Reuben)</author><pubDate>Fri, 2 Apr 2021 14:58:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-2062477751871943059</guid><description>Problem and Audience
A developer of a system that uses json web tokens (JWT) to authenticate HTTP API requests needs to generate asymmetric cryptographic keys, load the keys into code, then use the keys to sign and validate tokens.

We are building a multi-tenant system that implements a hierarchy where each tenant (project) may enable one or more api&amp;#39;s.  An end user authenticates with the </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>A little framework for scala builders</title><link>http://blog.frickjack.com/2021/03/a-little-framework-for-scala-builders.html</link><category>scala</category><author>noreply@blogger.com (Reuben)</author><pubDate>Sat, 20 Mar 2021 11:43:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-2491238231831772696</guid><description>Many developers use immutable data structures in application code, and leverage the builder pattern to construct the application&amp;#39;s initial state, and progress to new versions of the state in response to user inputs and other side effects. The scala programming language supports immutable data structures well, but does not provide a native implementation of the builder pattern.  The following </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Asynchronous Toolbox Pattern</title><link>http://blog.frickjack.com/2021/01/asynchronous-toolbox-pattern.html</link><category>javascript</category><author>noreply@blogger.com (Reuben)</author><pubDate>Wed, 20 Jan 2021 06:31:00 -0600</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-6250410466502485475</guid><description>A javascript application designer must structure her app to asynchronously load configuration and 
bootstrap its modules at startup.  The asynchronous toolbox pattern addresses this challenge
with a simple dependency injection framework.
The Asynchronous Bootstrap Problem
Consider an application with three modules in addition to modMain: modA, modB, and modC that export classA, classB, and classC</description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>little tools for API gateway</title><link>http://blog.frickjack.com/2020/07/little-tools-for-api-gateway.html</link><category>aws</category><author>noreply@blogger.com (Reuben)</author><pubDate>Fri, 10 Jul 2020 06:28:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-3808901871440164061</guid><description>Introduction
An API gateway on AWS provides a scalable and serverless platform for deploying an HTTP API backed by a lambda function, served to clients via a cloudfront cdn, and metered per client request.  This architecture trades the traditional costs and complexity of maintaining a cluster of servers to host an API for a new set of challenges.  The people (developers, QA, operators, managers) </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Install local packages with npm link and npm config set prefix</title><link>http://blog.frickjack.com/2020/02/install-local-packages-with-npm-link.html</link><category>nodejs</category><author>noreply@blogger.com (Reuben)</author><pubDate>Sat, 29 Feb 2020 15:15:00 -0600</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-4162531379826525923</guid><description>
pre.code {
  font-family: "monospace";
  padding: 10px;
}



In nodejs if you have a Bin package that depends on a Lib package, and before publishing a new version of Lib you want to test that local changes to Lib do not break Bin, then you can do something like this to link your local copy of Bin to your local copy of Lib:


cd Bin/ &amp;&amp; npm link ../Lib/



A problem with this (at least on Ubuntu</description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>simple expressjs logging middleware</title><link>http://blog.frickjack.com/2020/02/simple-expressjs-logging-middleware.html</link><category>expressjs</category><category>logging</category><author>noreply@blogger.com (Reuben)</author><pubDate>Thu, 6 Feb 2020 00:39:00 -0600</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-7924382602279371372</guid><description>
There is a small trick to configure an expressjs
middleware function to capture a request's run time and status.
Here it is:


.code {
  font-family: "monospace";
}


const serverLogger = (req, res, next) =&gt; {
    const startMs = Date.now();
    res.on("finish", () =&gt; {
        log.info(
            {
                req: {
                    path: req.path,
                },
                </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Simple CICD with CodeBuild</title><link>http://blog.frickjack.com/2019/11/simple-cicd-with-codebuild.html</link><category>cicd</category><category>CodeBuild</category><author>noreply@blogger.com (Reuben)</author><pubDate>Thu, 21 Nov 2019 05:06:00 -0600</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-2556999731677621925</guid><description>
pre {
    background-color: #eeeeee;
}


CICD is awesome.  It automates the tasks we want to perform whenever we push code to our repository:

test linting
audit third party dependencies for security
compile the code
run unit tests
publish artifacts

There are a lot of great options for implementing CICD too.  On-prem systems like Jenkins and Team City, and SAAS systems like Travis, CircleCI, </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Publish Web Content to S3</title><link>http://blog.frickjack.com/2019/11/publish-web-content-to-s3.html</link><category>aws</category><category>s3</category><author>noreply@blogger.com (Reuben)</author><pubDate>Sat, 16 Nov 2019 09:47:00 -0600</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-1485747655116382460</guid><description>I host a little website at https://apps.frickjack.com by publishing static web files to an S3 bucket behind a cloudfront CDN.  One way to improve the performance of an S3 web site is to configure each file&amp;#39;s (s3 object) content encoding (gzip&amp;#39;ing the file if required), content type, and cache control at upload time (S3 natively specifies an Etag).
Here&amp;#39;s a little script that makes </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Executable Test Plans for BDD</title><link>http://blog.frickjack.com/2019/10/executable-test-plans-for-bdd.html</link><category>BDD</category><category>jasminejs</category><category>TDD</category><author>noreply@blogger.com (Reuben)</author><pubDate>Fri, 11 Oct 2019 06:52:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-8491814027862141907</guid><description>There are many good libraries for developing automated software tests, but we also want to allow non developers to specify test plans and acceptance tests early
in the development life cycle.

we want test plans and acceptance tests to help guide feature development
we want to track test plans as artifacts in git
we want to use Gherkin or some similar &amp;quot;living documentation&amp;quot; technology
</description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>Hydrate an AWS Account</title><link>http://blog.frickjack.com/2019/06/hydrate-aws-account.html</link><category>aws iam security devops</category><author>noreply@blogger.com (Reuben)</author><pubDate>Sun, 30 Jun 2019 17:35:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-4931590077824972655</guid><description>You just got your brand spankin&amp;#39; new AWS account, and your team is launching like a rocket into the cloud.
How should you set this account thing up?
Before playing with EC2 instances
and S3 buckets and all the other toys at the application layer of the stack; 
you should figure out how you want to authenticate,
authorize, and monitor users manipulating your base cloud infrastructure.  
The </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>EKS and AWS CNI IP Space management</title><link>http://blog.frickjack.com/2018/12/eks-and-aws-cni-ip-space-management.html</link><category>aws</category><category>EKS</category><category>kubernetes</category><author>noreply@blogger.com (Reuben)</author><pubDate>Mon, 24 Dec 2018 22:43:00 -0600</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-5594318420851306770</guid><description>
AWS recently introduced its EKS managed kubernetes service
which manages the kubernetes control plane (API and Etcd services), while the cluster owner administers the cluster's worker nodes in a
VPC.


One of the features of EKS is the VPC CNI networking plugin
that tightly integrates with AWS VPC networking, so that
each kubernetes pod is assigned an IP address from the VPC CIDR range allocated</description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>JWT Parser</title><link>http://blog.frickjack.com/2018/12/jwt-parser.html</link><category>jwt</category><author>noreply@blogger.com (Reuben)</author><pubDate>Mon, 24 Dec 2018 21:49:00 -0600</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-7679465539657966421</guid><description>
I just published a new JSON web token (JWT) parser 
app
under apps.frickjack.com.
There's nothing special about this app - it's 
just another little vanilla-js plus custom-elements app that continues the
evolution of the little-elements
and little-apps code.
</description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>little-elements webapp shell</title><link>http://blog.frickjack.com/2018/10/little-elements-webapp-shell.html</link><author>noreply@blogger.com (Reuben)</author><pubDate>Thu, 11 Oct 2018 23:43:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-5929888269532721334</guid><description>
I recently updated apps.frickjack.com
to use unbundled javascript modules
to load custom elements and style rules.
It worked great, except I soon noticed that initial page load would present an un-styled, no-custom-element rendering of the page until the javascript modules finished loading asynchronously... ugh.


I worked around the problem by implementing a simple 
application shell.  The html</description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item><item><title>jasminejs tests with es2015 modules</title><link>http://blog.frickjack.com/2018/08/jasminejs-tests-with-es2015-modules.html</link><category>jasmine</category><category>javascript</category><category>karma</category><author>noreply@blogger.com (Reuben)</author><pubDate>Fri, 3 Aug 2018 13:22:00 -0500</pubDate><guid isPermaLink="false">tag:blogger.com,1999:blog-34125606.post-1199821194774274341</guid><description>
Running jasminejs tests of javascript modules
in a browser is straight forward, but requires small adjustments, since
a module loads asynchronously, while jasmine's default runtime assumes code loads synchronously.
The approach I take is the same as the one used to test requirejs AMD modules:


customize jasmine boot, so that it
   does not automatically launch test execution on page load
write </description><thr:total xmlns:thr="http://purl.org/syndication/thread/1.0">0</thr:total></item></channel></rss>