Golang & OpenAPI Spec Fiddling with an idea of generating models from the OpenAPI spec for YAML. Notes Bazel model works, but would want to formalize as a proper build system Model of pkg/apis/... is a good direction, version selecting will need to be a thing though What about YAML Support? Is swagger the expected way forward for this kind of thing? Should the generation of files be done as a bazel run or a bazel build?

Fiddling with gqlgen Experimenting a bit with gqlgen for generating GraphQL code from spec. Notes Would prefer to move gqlgen.yml and schema.graphql into a spec/ directory (or other areas) Installation method with tools.go - not sure about this, static binary is preferrable for my usages Generated models are pretty solid, similar to swagger Resolvers is nice, but what about partial updates? I’m not entirely sold on this pattern. Feel like I’d prefer more flexibility with how the models and various components are defined.

State Machine for Confirmation Dialog Running through the workshop example of Build A Confirmation Modal in React with State Machines Notes In principal, like the idea of representation this kinds of logic “Flows” Usage of strings for state is less than ideal, almost would want it to be objects Pattern of constructing a “flow” then making use of the “flow” Potential opportunities with systems like codegen Possible ideas for test evaluation with the states Not sure about this library, needs opportunities for isolation Feels like it doesn’t fit with the View -> ViewModel -> Model concept I was thinking of for State Machines The ‘dispatcher’ works similar to what a wrapper over “Modal” would have, what benefits does it bring?

Experimenting with Pulumi Experimenting with the pulumi examples from https://github.com/pulumi/examples, and the options to have Notes Enabling Bazel wtih this model encountered some pain points Pulumi is capable of performing operations like Docker Build / Referencing lambda binaries The change source pattern (git.dirty, git.author, etc) for volatile status is a nice pattern Building of artifacts should not be the responsibility of the deployment model Pulumi takes over the context element of deployments, and use that for deployments Pulumi has some nice elements too it with respect to be able to use code to create the deployment, as well as a good web/console interface.

Golang Gin & Gitpod Fiddling with the Dev experience of Golang gin within Gitpod Based on gitpod-io/go-gin-app Notes Prefer the pattern of combining this with cobra Server rendered HTML is pretty straightforward Returning simple JSON pretty straightforward Can be combined with GRPC + Proto What about swagger for generating the modules? Considerations about how to organize the elements (cli, server, routes, models, database, etc) What about logging for this? Gitpod has occassionally issues with the import of gin References for things like templates/ at the top level is nice Log while running is excellent Overall positive.

MirageJS Tutorial Running through the (MirageJS Tutorial)[https://github.com/miragejs/tutorial] case Notes If generated from a schema, the system is essentially Backend (proper) Backend Mock (in-memory) Backend JS Client (proper) Backend JS Client Mock (in-memory - integrated with MirageJS) How could this be integrated with code generation from a specification? Does this assist with local development? Test scenarios in an pseudo-E2E case?

MAnim Experimentation with Video Generation Experimenting with the MAnim library for generating video animations. Notes Solid library that works really well at what it does Scenes feel very “on-track” in that it is a sequence of steps one followed by the next Python allows for re-use to create common elements like an isometric file Works great for scenes where the emphasis is on the core “shapes” and animation Don’t think this fits with the use-case I’m after.

React Webpack with Rust WebAssembly Fiddling around with an opinionated example for Webpack builds with WebAssembly. Source code for fractal is based on https://dev.to/brightdevs/using-webassembly-with-react-1led, and the repository templated by https://github.com/Fallenstedt/wasm-react-webpack-template. Notes WASM Build works pretty well with rust Rust is a solid option for getting webassembly integrated Golang was considered, but previous experiments weren’t as desired Makefile as an entrypoint is preferrable than using yarn ... Embedding the generated packages within the front (e.

Vulnerability Disclosure Policy from Dioterms Exploring leveraging dioterms and policymaker for creating vulnerability disclore policies for a website. Notes DNS is related for the deployment of the website (_security) Entry within the /.well-known/ root of the domain (example.com/.well-known/security.txt) Security entry for the domain (example.com/security) If the application is located within example.com/app/... (e.g. index.html), then the top level domain elements can be “procedural” Construct the webpage into a bundle (website.wbn), publish it to the “deployer”, which can then handle the top level elements References can still exist within the app (/security, /.

Experimenting with ConfTest, Terraform & Bazel Experimenting with using Bazel to handle the build & execution of Terraform files, while providing means of writing tests against the terraform with conftest. Fiddling with the idea of having local tests against the configuration, as well as tests against the terraform plan. The intention is that Bazel would be responsible for constructing Terraform deployable tarballs, which contains all resolved modules & providers. These would be executed to perform apply, plan and other commands.

asdf Manage multiple runtime versions with a single CLI tool, extendable via plugins - docs at asdf-vm.com asdf is a CLI tool that can manage multiple language runtime versions on a per-project basis. It is like gvm, nvm, rbenv & pyenv (and more) all in one! Simply install your language’s plugin! Why use asdf? single CLI for multiple languages consistent commands to manage all your languages single global config keeping defaults in one place single .

Julia Jupyter Notebook Experiments with working with Julia & Jupyter Notebooks. Notes Installation of Jupyter, Conda + Julia (+ packages) onto a gitpod image Makefile for common actions working with the notebooks Validating some basic cases working with Julia for generating plots & other bits for the visualization

GitPod Jupyter Notebook Validating working with Jupyter notebooks in a GitPod environments Notes Support for preview or open in browser mode Initial provisioning of the image takes a bit, pre-baked likely would help in this area Jupyter lab is another option Makefile is a good option for acting as an entrypoint for common commands Outstanding questions still exist for multi-notebook repositories like the learning repo

Pushgateway Compose Setup Simple code setup for spinning up Pushgateway, Prometheus & Grafana for validating lifecycle pushgateway metrrics. Notes Metrics published to pushgateway are collected by Prometheus Prometheus is enabled in Grafana for queries Grafana datasources & dashboards are configured from the provisioning directory The script publish.sh can be used to publish the metrics into the system Dashboards in grafana/dashboards can be configured with other tools for construction Dashboards could be standardized, then shared into other sources Tools can be configured for publishing in these scenarios

AWS Organization Structure Experiments - Mirrored Organizations Experiments with AWS Organization structure and potential SCP policies. Notes The entire organization unit hierarchy shouldn’t be a single entity for mirroring. Makes it difficult to evaluate in “isolation” Entire organization mirrors can work with the SCPs, but internal permissions (e.g. S3 Bucket) still might have issues Organizations should include a uniqueness component to allow for constructing a new version (& prototyping) SCPs seem like they would benefit in cases where there is a sort of “State machine” in the SCP State machine examples are “During provisioning of account, need to create IAM Users, but from then on no users should be created” Account boundaries for services as a way of strictly locking things makes it easier to have DenyKMS and other such policies Region denies only apply after provisioning, as we need to purge the “default VPCs” created when an AWS Account is created (+ any other “default” resources) AWS Password Policy / AWS IAM Account Name / Etc are all good examples of something that should only need to be provisioned “once” SCPs give a potential idea for the concept of “Immutable AWS Account Infrastructure”, that require you to create a new AWS Account (+ migrate resources) rather than edit them Sandbox/Staging organizations can contain the developer workloads that are for sandbox/development Developer workloads should be contained within accoounts that can be created/decommissioned on a release schedule (see ubuntu - Bionic Beaver, Focal Fossa, Xenial Xerus) More investigation is needed into this idea, as the exact “concern” that this kind of structure & SCP policy layout will handle is kind of vague.

Release Mirror for GitHub Releases Lightweight experiment for mirroring GitHub releases into a file store system like Minio or AWS S3. Getting Started packages/ Contains the tool definition files for each of the mirror repositories (tool.ini), and the computed checksums for the downloaded files. In an actual use case it would be better to store the checksums externally from this repository, allowing this one to act purely as an executor, and the other repository acting as a “record” of the known-good commit SHAs (as well as .

GitHub Configuration in Code Fiddling with the configuration options available for GitHub, while encoding the properties in the .github directory. Getting Started This repository The concept is to create an almost “self-contained” repository, that includes within hidden directories like .github/.aws/.azure/.gcp/etc that represent almost “interfaces” between the repository and external services that would act on it. This way rather than having the repository rely on assumptions about how it is configured, it is instead providing all the baseline elements for any supporting infrastructure (e.

GitHub App for Generated Commits Running through a bunch of things to be done with this Notes Is it possible to push empty commits, which would need to be handled Commits should be crafted first, then attempts being made to apply the change Would need to have better visibility into the “crafted” files that will be committed Does this really require a GitHub Application? Feels like this could be decoupled Need to ensure that requests with the API go through the proper retry processes Need to ensure that the configuration is split from auth, so its easier to rotate the auth without fiddling with the config Should the app really be responsible for the work-component of crafting the change?

GPG Artifact Sign Experiment Minor experiment with a shell script for signing artifacts that would be generated from a build process. Notes Build tooling can support multiple checksum algorithms (sha256/sha1/md5/sha512/etc) Docker Container Trust (DCT) didn’t fit with the usecase/portability desired GPG is the standard way for doing this (can this be packaged into something more portable?) Design should aim to be agnostic of GitHub Releases or any other platform Build tooling likely doesn’t need to understand the concept of “signing” (or should it?

Rusy Bevy Baseline Fiddling with one of the Bevy examples for provisioning a window with Bevy. Notes Initialize setup required installation of libraries like: libasound2-dev libwebkit2gtk-4.0 libudev-dev mingw-w64 Cross-compilation works, but associated GitHub Issues seemed conflicting Earlier version of bevy had issue with missing audio driver (devcontainer) failing the build Don’t think will continue with this for now, maybe investigate later. Components for the chess board sourced from https://caballerocoll.

Experiment - WebAssembly Golang + Bazel Experimenting with some issues encountering with WebAssembly, Golang & Bazel Notes Confirmed issue with syscall/js in the basecase with using goos and goarch (toolchains passed as orgs better option?) Using a genrule sufficient to workaround the case Base case with a simple calculator, using just base HTML js.Value conversions, framework wrapper to exist to handle the interop? Directory layout of cmd/ and app feels a bit off, but does help keep the bits separate

Packer Overwrite MOTD Overwriting the MOTD of pre-baked AMIs using Packer Notes Message files are located in /etc/update-motd.d/ Existing ones can be purged and replaced with a fixed one Likely want to keep the status components (source from existing, overwrite) Scripts need to be executable, and include shebang Current packer requires AWS for EC2 create/snapshot, can we avoid? This works well for setting up a baseline for the AMIs.

CobraCMD with GenMarkdownTree Experiment with the GenMarkdownTree method available with cobrago. Actions The command line utility can be executed by running: bazel run //cmd/cobradocs version The markdown tree for the docs can be generated by running: bazel run //docs/cobradocs -- --dir $PWD Notes Markdown or YAML generated from the docs works fairly nice Better fit would be YAML, then providing it to a markdown templator (or alternative tools) Feels like having an OpenAPI spec for the CLI would make this process easier (build docs from the OpenAPI spec) Need to have a reference to the command object for the CLI Files are written into a directory, or dumped to a buffer & stdout Can be good for getting some docs out, but is this the ideal direction?

XTerm for Terminal as Browser Experimenting with the idea of a minimum environment for running terminal applications in browser. In essence, allowing a user to navigate to example.com/terminal to view a terminal version of the sites API. With the appropriate token & other bits provided from the browser session tokens. Notes WebAssembly for Golang can be used in combination with this Browser token can be used to authenticate with the service, allowing for commands to exec against it Using something like the cobra yaml export (or deriving actions from OpenAPI-like spec), the JS interface can be generated Validation would be performed within the cmd, although a common ‘OpenAPI-like’ spec would help reduce the complexity on this front (have better interacted with UIs) Leveraging other wrapper frameworks for xTerm.

AWS AssumeRole with Certificate for CI Exploring the concept of using AWS IoT Certificates for authenticating with AWS. This came up while working with minio, which supports authentication with certificates: MinIO provides a custom STS API that allows authentication with client X.509 / TLS certificates. Getting Started The commands boostrap.sh and cert.sh are provided for working with the IoT devices. Bootstrap is responsible for provisioning the certificate, IoT resources, and the permissionless IAM role.

AWSS3 & AWS Cognito Fiddling with AWS S3 Websites leveraging AWS Cognito for authentication Terraform is based on the tutorial https://transcend.io/blog/restrict-access-to-internal-websites-with-beyondcorp/ and the public repository: https://github.com/transcend-io/beyondcorp-cloudfront Notes This approach isn’t really something I think is great The lack of ease configuration for Lambdas, and the need to either embed configuration in the lambda zip, or through AWS SSM is not ideal Either a single monolith terraform module, or split between multiple.

Bazel Container Image Rules Bazel CI Generated API documentation is in the docs folder, or you can browse it online at https://docs.aspect.dev/rules_docker Basic Rules container_image (example) container_bundle (example) container_import container_load container_pull (example) container_push (example) These rules used to be docker_build, docker_push, etc. and the aliases for these (mostly) legacy names still exist largely for backwards-compatibility. We also have early-stage oci_image, oci_push, etc.

EntityModel Dapper Experiment Case Exported case of experimenting with using Postgres Functions, Dapper & Entity.Model. Notes Experimenting a bit more with the entity model of splitting out the “database” components (e.g. ID) from the model objects, with an aim towards designing a strict interface for working with the database, that could be generated from a baseline specification. This would allow for things like ReadOnly entities, better field filtering & potential for “programmatic” improvements to how the database handles searches.

Cuelang with SchemaGen Experimenting with using Cuelang for the purposes of representing a schema, then generating associated files from the original source of truth Notes Schema validation is nice, the base case is straightforward Combining data with this allows for connecting enum/datasets What about stubbing of datasets (e.g. restrict this to ‘Dataset’ that isn’t locally defined?) Text templating isn’t really what I want to do with this kind of tool Seems like I need to write more “representation/composition” than I originally hoped Doesn’t seem to support the kind of “intentions” workflow I was hoping for This isn’t handling the case I’m interested in with schema validation & generation.

Bazel Bash Packaged Experimenting with using Bazel & Bats in container images for writing up tests for shell scripts. Notes Sometimes while developing things it can be useful to have a small shell script that performs a simple action or operation, that in the short-term makes sense as a shell script. In this case, it can be useful to add some simple tests to ensure that: The script is runnable Simple transformations work as expected Any environment variable or file references work as intended This isn’t intended for cases where a shell script is increasing in complexity, but rather where it acts as ‘Glue’ responsible for filling in gaps that might exist in a system.

JCompiler Summary A Joos programming language compiler, written in Java. Getting Started The project is currently not maintained or kept in runnable order. You may be able to open the project in Eclipse, but at this time the code is only here as readonly. Notes The application was written as part of the UWaterloo CS444 Compiler Course. Group Members: seanmk sxyuan Acknowledgements The project icon is retrieved from the Noun Project.

bazel-toolchain-from-s3 Experimenting with setting up Bazek toolchains, when the tools are mirrored into an AWS S3 bucket. This builds off previous work done in jrbeverly/bazel-external-toolchain-rule for creating toolchains from files. Notes Implementation of s3_archive uses that same model as http_archive The repository_rule does not use toolchains like rules, meaning bootstrap rules must be downloaded by repository_ctx Repository rules can convert labels to paths using the repository_ctx.path method To get a fully managed system that doesn’t require tools to be installed on the local system, would likely require a bootstrap rule using a tool that is publicly available.

bazel-external-toolchain-rules Experimenting with setting up Bazel toolchains using an externally managed .toolchain file, that is responsible for defining properties such as: System compatibility Integrity Checks Tool retrieval locations Notes This idea came out of the idea of having Bazel rules that were not aware of how toolchains were defined (or what systems they are compatible with), and instead being entirely based on the lock file (.toolchain) available in the caller environment.

Bazel & Jsonnet Templates Generating files from base configuration files using Jsonnet. Notes Exploring the idea of leveraging jsonnet with Bazel to create a series of templates sourced from configuration files. The basic principle of this is how to built in-repository the idea of ∀ ∈ Configuration Files { template([inputs]) => rendered }. The usage of libsonnet lets the lib/ directory contain all of the models, utilities and other means of representing the data structures.

internal-reserved-license-repo Experimenting with laying out the licensing stamp for a closed/internal source repository Notes Experimenting with the idea of what license annotations would look like on an internal repository that is not intended for public distribution. This can seem odd, as the source code files of the project should not be distributed, so the only individuals viewing the license should be those with pre-approved access (i.e. contributors/employees). The intention of this is to explore ideas around having tools & systems be aware of the licensing “intentions” of the source code.

github-actions-dbx-upload Publishing to Dropbox programmatically from GitHub Actions with the intentions to mirror the model of AWS S3 publishing. Notes Exploring how one might leverage Dropbox as an artifact storage source, with an authentication model that is similar to AWS. Setting up the initial Dropbox Application to get the tokens for publishing was a bit more involved than useful, and I suspect the process of rotating these tokens might be a pain too.

Terraform AWS CodePipline Terraform Executor Terraform executor leveraging the CodePipeline functionality in AWS, for a fully serverless model of executing terraform in AWS. Getting Started The primary environment is configured in env/, with a single main file. This provisions the CodePipeline, CodeBuild components, as well as some stub S3 buckets that represent both incoming sources, artifacts. The artifacts bucket is treated as a stand-in for the Terraform state environment variable, but the pipeline itself does not attempt to configure the backend for S3.

Bazel Golang Inline Analyzer Experimenting with having analyzers locally defined to a repository, rather than externally defined. Notes Requires using go_tool_library instead of go_library due to a dependency change issue (must also use go_tool_library of deps) Baked natively into nogo, so it can be pretty straightforward to test Names of types aren’t as simple as package.Type, but instead include other components (using HasSuffix) (What options are there?) Change in ‘internal/cobrago/storage.

GitHub App in Golang Prototyping GitHub App written in Golang with the AWS & GitHub integrations split away, to try and encode the core ‘concepts’ solely into the lib/ component Notes Development (& Testing) should support a non-smee way of development How would integration/infrastructure/e2e tests work with this kind of system? Would it make more sense to have an OpenAPI system, with the GitHub integration performing the interface? Is this similar to Hubot, in that having an interface layer/service makes more sense, as it avoids the requirement for direct interface?

K3s In HomeLab Proof of Concept Determining how viable it would to be switch from using docker-compose to using K3s to run my internal homelab environment. Getting Started The installation process assumes that you have a freshly imaged ubuntu machine, connected to the internal network, and with a minimum of password-based SSH access. Installing dependencies The tools FluxCD & K3sup can be installed on the host machine using the script setup.

GitPod Golang CLI Leveraging GitPod for prototyping out a golang cli that interfaces with AWS. Notes The .gitpod.yml file must exist in the root directory Dockerfile(s) for the environment can be specified in its own directory (.gitpod) Commands can be run on start-up, ensuring that the build is working as expected GitHub Permissions required to make changes to GitHub Actions workflows GitHub Permissions required for a series of commit/pull request based actions Workspaces can be provisioned/stopped/cleaned up on-demand Docker works on the provisioned nodes Extensions & Other components are defined by the .

Rust Language Checks Experimenting with aspects of Rustlang for working with database, and immutable data structures. Notes How might the Entity.Model apply to this? Where we split the id from the data struct? Immutable hashmap appears to need additional crates (cursory look) The /src & /lib standard directories is a nice component Using .env to reference the database URL Requires some additional components for PSQL & Diesel

Packer Bakery with AWS Native Creating pre-baked AMIs using Packer within AWS Native resources (Codepipeline / CodeBuild). Notes Tuning minimum permissions can be a bit difficult with the CodePipeline/CodeBuild error messages Artifacts bucket should store only temporary/cache files, and should be destroyable Logs from CodePipeline & CodeBuild can be restricted to a specific log group Unique ‘key’ identifier allow single-use of module within a common key-scope Events on-complete require additional resources/overhead Image is amazon pre-built, installing Packer on-the-fly Although nice to leverage IAM solely for this, the benefits don’t really outway the issues with leveraging CodePipeline for this kind of build.

bazel-and-aws-cdk Prototyping ideas with using Bazel and AWS Cloud Development Kit to create cloudformation templates

Repository Templating & File Automation Experimenting with a model of building a lightweight cron+bash system for performing templating&file modification to multiple repositories. Idea The basics of this repository was the idea of leveraging the GitHub CLI (gh) to automate the creation of pull requests that were intended to facilitate common chore work in repositories. This would reduce the need to handle things like setting up license files, formatting, metadata, GitHub Actions, etc.

dotfiles A set of vim, zsh, git, and configuration files.

Machine Learning Lab A repository for aggregating my machine learning exercises, practices and learning labs. The projects included in this repository are based on the coursework for Udacity’s Deep Learning Nanodegree Foundations. These are primarily from working on the Machine Learning Nanodegree offered by Udacity. The project files are built using Jupyter Book into a web-accessible form. Getting Started The conda environment for working with all of the Jupyter Notebooks is provided as environment.

Codespace Prebuilt, development environment in the browser – powered by VS Code. This image acts as a catch-all image for doing full-stack development in a polyglot type environment. The running container makes use of the host docker service to allow for docker builds.

HomeLab - Internal Tooling Ansible playbooks for configuring services running within my internal home cloud. Getting Started DevContainers The DevContainer environment can be started by opening the repository in VSCode and installing the ‘Remote - Containers’ extension. When started, the prompt will build and image and configure the container. The deployments to any of the environment can be triggered by running any of the helper scripts available in /opt/bin. To deploy the codelab environment, you can run codelab.

Running code-server on AWS Lightsail Summary Run VS Code on an AWS Lightsail instance with auto-generated password and static IP. Early experiments with cloud-driven development environments configured on-demand using terraform. Initial exploratory work for seeing what changes exist in the workflows, and any issues that may arise as a result of working in Lightsail. Notes Below are some quick points noted while experimenting with this: AWS Access Keys In comparison to running this on ECS or EC2, AWS access keys need to be generated and supplied if you wish to run AWS commands.

Express in Deployments A simple Express application built with the intent to test an Express server running in different environments (local, docker, lambda). Usage The available make commands can be listed with make help: Usage: make <target> help This help text. Serverless deploy Deploy the lambda with serverless remove Destroys the instructure Express local Locally run the app Docker docker Build and run in a docker container Notes Simple service with the intent to be used for some AWS work involving cloud costing, cold starts and on-demand provisioning of services.

jrbeverly Represents the infrastructure resources of ‘jrbeverly’, keeping track of infrastructure components, assets and other resources that are needed for components. Directory Mappings The directory layout is modelled after the Linux directories (/var, /etc/, /root, /srv, /opt, etc). This is intended to handle cases as they are adopted into the standards. /srv Represents the website resources for any hosted domain.

blockycraft Summary Blockycraft is a Minecraft inspired Block Engine written in Unity3D and built using GitHub Actions. The intent of this project is to better learn Unity, and discover some new use cases with GitHub Actions. The project is available as binary releases for different operating systems, and includes a hosted WebGL version that can be played in supported browsers: blockycraft.jrbeverly.dev/play There is no formal feature list or any intentions to carry the project long-term into a fully featured block engine.

Blockycraft Summary Blockycraft is a Minecraft inspired Block Engine written in Unity3D and built using GitHub Actions. The intent of this project is to better learn Unity, and discover some new use cases with GitHub Actions. The project is available as binary releases for different operating systems, and includes a hosted WebGL version that can be played in supported browsers: blockycraft.jrbeverly.dev/play There is no formal feature list or any intentions to carry the project long-term into a fully featured block engine.

cardboardci-dockerfiles Dockerfiles for CardboardCI’s Docker images.

Friending Summary Friending is an online dating, friendship, and social networking mobile application that features user-created questionnaires. Friending has two primary features: joining groups to find people similar to you or signing up for events happening in your local area. Friending is a prototype built with the Proto.io application prototyping tool. The Friending prototype was built as part of a requirements specification project. The project focused on the development of a user manual around a fictional matchmaking application called Friending.

XPlatformer Summary XPlatformer is a simple video game reminiscent of the classic side-scrolling arcade game, using the XLib API. The point of the game is to control a character through a terrain to meet an objective. The project makes use of the XLib API (XOrg) and focus on code that was developed to accomplish tasks for the assignment task. Acknowledgements The project icon is retrieved from kenney.nl. The original source material has been altered for the purposes of the project.

Predicting Boston Housing Prices Evaluate the performance and predictive power of a model that has been trained and tested on data collected from homes in suburbs of Boston, Massachusetts. A model trained on this data that is seen as a good fit could then be used to make certain predictions about a home — in particular, its monetary value. This model would prove to be invaluable for someone like a real estate agent who could make use of such information on a daily basis.

Finding Donors for CharityML Employ several supervised algorithms to accurately model individuals' income using data collected from the 1994 U.S. Census. From the best candidate algorithm from preliminary results and further optimize this algorithm to best model the data. Construct a model that accurately predicts whether an individual makes more than $50,000. This sort of task can arise in a non-profit setting, where organizations survive on donations. Understanding an individual’s income can help a non-profit better understand how large of a donation to request, or whether or not they should reach out to begin with.

Creating Customer Segments Analyze a dataset containing data on various customers' annual spending amounts (reported in monetary units) of diverse product categories for internal structure. One goal of this project is to best describe the variation in the different types of customers that a wholesale distributor interacts with. Doing so would equip the distributor with insight into how to best structure their delivery service to meet the needs of each customer.

Summary Blockycraft is a interactive graphics demo to create a Minecraft inspired demo which revolves around breaking and placing blocks. The game world is composed of rough cubes arranged in a fixed grid pattern and representing different materials, such as dirt, stone, and snow. The techniques used in the demo can be toggled using keyboard commands. The Blockycraft project is written using C++ and OpenGL. Notes The project was developed for a University of Waterloo Graphics course in Summer 2016.

Classification of Dogs My implementation of the Convolutional Neural Networks (CNN) algorithm for identifying a canine’s breed from an image. Additionally, it supply the resembled dog breed if provided an image of a human. Classification You can see an example classification for the German Shepherd picture below: And an example of a misclassification for a rotweiler. Notes You can see my full analysis of the classifier in the notebook, but a snippet is included below

Quadcopter using Reinforcement Learning My implementation of the DDPG reinforcement learning algorithm to solve the problem of a quadcopter taking flight. I have included a reference to the DDPG paper used in the development of the flying agent: Continuous control with deep reinforcement learning Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, Daan Wierstra We adapt the ideas underlying the success of Deep Q-Learning to the continuous action domain.

BMX BMX grants you API access to your AWS accounts, based on Okta credentials that you already own. It uses your Okta identity to create short-term AWS STS tokens, as an alternative to long-term IAM access keys. BMX manages your STS tokens with the following commands: bmx print writes your short-term tokens to stdout as AWS environment variables. You can execute bmx print’s output to make the environment variables available to your shell.

Git Timeline Allows bulk modification of the commit dates of a repository, changing the history of a repository. Usage # Creates the demo repository ./git-timeline.bash clone # Copies the demo repository to the working environment ./git-timeline.bash working # Exports the history of the git repository to files ./git-timeline.bash history You can then edit the dates of the three files emitted: FIRST - The first commit to the repository HISTORY - The commit history LATEST - The most recent commit to the repository After you have done this, you can then run apply and show:

AWS Lambda PowerShell Example A simple Lambda function written in PowerShell to validate if New-PSSession can be leveraged from an AWS Lambda. The objective of this repository was to determine if it was possible to use New-PSSession from an AWS Lambda. This would allow for modification of services like Office365 using remote sessions from AWS without requiring an ECS/EC2 container. Without a custom lambda runtime (or some way of enabling WSMan), it would be difficult to do this with a vanilla lambda execution environment.

Friending Landing Page This repository contains the source for the webpage friending.jrbeverly.dev. The webpage is built off the Hugo template by by themefisher used under CC by 3.0 - Alterations to theme have been made to the underlying template. Those changes are made available in the themes/vex directory.

AWS Chat App SAM Application for a simple chat application based on API Gateways new WebSocket API feature. This was originally developed as an experiment to see how viable running a chat-bot in a fully serverless environment, as opposed to just running on a container in ECS. This repository is based on Announcing WebSocket APIs in Amazon API Gateway, with the cloudformation and lambdas from simple-websockets-chat-app. Usage A build-harness created with make is available for the repository.

Hubot in AWS ECS Hubot deployment in AWS using AWS ECS Fargate. This was prototyped out while I was evaluating ChatOps strategies that could be used to wrap existing web interfaces or require minimal overhead. Usage A build-harness created with make is available for the repository. This harness simplifies the commands necessary to build and deploy the project. You can see the available targets by running make help: Usage: make <target> help This help text.

Docker AWSCLI Built with Bazel The AWS Command Line Interface (CLI) is a unified tool to manage your AWS services. With just one tool to download and configure, you can control multiple AWS services from the command line and automate them through scripts. CardboardCI aims to create a collection of docker images that can be used in continuous integration. These images will have all dependencies pinned, to ensure that any commit will produce the exact same image (or as close to as possible).

Powershell Library on GitHub Summary A powershell library that is installed from GitHub, rather than from Powershellgallery. Usage Downloading from GitHub: # Enable installing from github Install-Module -Name InstallModuleFromGitHub # Install the module Install-ModuleFromGitHub -GitHubRepo jrbeverly/pwsh-from-github # Perform Actions Write-Hello -Name "World" Write-World -Message "LFG" Notes Experimenting with using InstallModuleFromGitHub, instead of using Powershell gallery. I have noticed that this requires all of the scripts be at the root of the repository, rather than using a folder structure like so:

AWS IAM External Role Terraform module for a continuous integration user-role pairing. These types of resources are supported: IAM Role Usage module "cicd_setup" { source = "git::https://gitlab.com/infraprints/modules/aws/iam-ci-role" username = "infraprints-iam-ci-role-basic" role_name = "infraprints-iam-ci-role-basic" environment_variable = { s3_bucket = "infraprints-bucket-example" hello_world = "hello world" } } Examples Basic Example Notes Environment variables are prefixed with ENV_ to prevent them Inputs Name Description Type Default Required environment_variable Times map <map> no labels map <map> no length The length of the external id desired.

AWS S3 Terraform State Output Terraform module which creates an S3 Object containing terraform outputs. These types of resources are supported: S3 Bucket Object Template Usage locals { topics = ["aws", "s3", "terraform"] tags = { name = "infraprints", description = "Infrastructure as Code." } } module "output_resources" { source = "git::https://gitlab.com/infraprints/modules/aws/terraform-state-output" bucket = "infraprints-terraform-state-output" key = "aws/infraprints/project/outputs.tf" terraform_output = [ { key = "aws_account_id" value = "123412341234" }, { key = "topics" value = jsonencode(local.

terraform-aws-acm-certificate

AWS Terraform Remote State with Lock Table Terraform module which creates a terraform remote state storage in S3 with a DynamoDB lock table. These types of resources are supported: S3 Bucket DynamoDB Table Usage module "remote_state" { source = "git::https://gitlab.com/infraprints/modules/aws/terraform-remote-state" bucket = "infraprints-terraform-remote-state" table = "infraprints-terraform-lock-table" } resource "aws_iam_role" "terraform" { name = "infraprints-terraform" assume_role_policy = <<EOF { "Version": "2012-10-17", "Statement": [ { "Action": "sts:AssumeRole", "Principal": { "Service": "ec2.

AWS S3 Terraform State Output Terraform module for an tiered storage S3 bucket with eventual object expiration. Primary use key is for a build artifacts storage. These types of resources are supported: S3 Bucket Usage module "build_artifacts" { source = "git::https://gitlab.com/infraprints/modules/aws/s3-artifacts" bucket = "infraprints-s3-artifacts" standard_transition_days = 10 glacier_transition_days = 30 expiration_days = 365 tags = { Longevity = "Yearly" Expiration = "True" } } Examples Basic Example Adjusted Example Notes With the default configuration, all objects in the S3 bucket will expire in 90 days.

terraform-aws-acm-certificate

AWS ACM DNS Validated Certificate Terraform module for provisioning a DNS validated certificate, along with the required validation records. The module will wait for validation to complete. These types of resources are supported: ACM Certificate ACM Certificate Validation Usage module "certificate" { source = "git::https://gitlab.com/infraprints/modules/aws/acm-certificate" zone_id = "${data.aws_route53_zone.zone.id}" domain_name = "infraprints.io" subject_alternative_names = [ "api.infraprints.io", "dev.infraprints.io", ] } data "aws_route53_zone" "zone" { name = "infraprints.io" } Examples Basic Example Multiple Records Example Notes The module deploys the required validation records and wait for validation to complete, which can take upwards to 30 minutes.

AWS IAM External Role Terraform module for describing an IAM role responsible for delegating cross-account access. These types of resources are supported: IAM Role Usage module "example" { source = "git::https://gitlab.com/infraprints/modules/aws/iam-external-role" name = "infraprints-iam-external-role" external_id = "TXAiS9rfgQghzWW2" role_arn = ["${aws_iam_role.default.arn}"] count = "1" } resource "aws_iam_role" "default" { name = "infraprints-ec2-role" assume_role_policy = <<EOF { "Version": "2012-10-17", "Statement": [ { "Action": "sts:AssumeRole", "Principal": { "Service": "ec2.amazonaws.com" }, "Effect": "Allow", } ] } EOF } Examples Basic Example ExternalID Example Multiple roles Example Notes The count property is required as a constant as a workaround to a Terraform issue.

Terraform Resource ID Construct a formatted name for a Terraform resource.

Terraform Netlify Gitlab CI/CD Terraform module which creates a site on Netlify with the necessary variables for GitLab CI deployments. These types of resources are supported: Netlify Site Usage module "cloudability" { source = "git::https://gitlab.com/infraprints/modules/netlify/gitlab-cicd.git?ref=master" name = "my-netlify-website" custom_domain = "www.example.com" project = "01234567" } Examples Basic Example Notes Three GitLab CI Environment Variables (NETLIFY_SITE_ID, NETLIFY_NAME, NETLIFY_CUSTOM_DOMAIN) Inputs Name Description Type Default Required name A friendly name for the netlify site.

Website The work-in-progress stub for the infraprints website.

Proposals Experimenting with the underlying infrastructure for a GitHub based proposals mechanisms that deploys to a web resource (website/subpage/etc) Motivations Automation to ensure contribution guidelines are both accessible and followed (e.g. first contribution bot, linting) Contribution previews, either by links to markdown rendering or branch previews Support for supplemental resources (e.g. assets/list-of-items.csv) Methods to organize the proposals better (date? slugs? IDs?) Simple layout in code (minimal overhead), with tooling to move assets into the correct locations When working with code, the proposals have some organization mechanism Minimal barriers when trying to write a proposal Notes Using date-based directory organization helps for filtering based on the latest proposals.

Experimenting with CircleCI Orbs Experimenting with CircleCI Orbs for reducing code re-use in templates Usages cp Deploy to S3 orbs: awscli: jrbeverly/awscli@0.0.5 version: 2.1 workflows: Deploy to S3: jobs: - awscli/aws-copy-to: bucket: hello-bucket namespace: some/terraform source: some/path sync Deploy to S3 orbs: awscli: jrbeverly/awscli@0.0.5 version: 2.1 workflows: Deploy to S3: jobs: - awscli/aws-sync-to: bucket: hello-bucket namespace: some/terraform

Docker image for MarkdownLint A tool to check markdown files and flag style issues. To have markdownlint check your markdown files, simply run mdl with the filenames as a parameter: mdl README.md Markdownlint can also take a directory, and it will scan all markdown files within the directory (and nested directories): mdl docs/ You can see the cli reference here. Usage You can run awscli to manage your AWS services.

CI Core CI-core is a special Docker image that is configured for running in CI environments. It is Ubuntu, with: A docker user A directory workspace Mechanisms for running build tools (json, web requests, etc)

Docker image for CppCheck Cppcheck is an analysis tool for C/C++ code. It provides unique code analysis to detect bugs and focuses on detecting undefined behaviour and dangerous coding constructs. The goal is to detect only real errors in the code (i.e. have very few false positives). You can see the source repository here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.

Docker image for AWS CLI A command line client for Dropbox built using the Go SDK Supports basic file operations like ls, cp, mkdir, mv (via the Files API) Supports search Supports file revisions and file restore Chunked uploads for large files, paginated listing for large directories Supports a growing set of Team operations You can see the source repository here. Usage You can run awscli to manage your AWS services.

Docker image for HTMLHint The static code analysis tool you need for your HTML. You can see the source repository here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.jpg" aws sts assume-role --role-arn arn:aws:iam::123456789012:role/xaccounts3access --role-session-name s3-access-example Pull latest image docker pull cardboardci/htmlhint Test interactively docker run -it cardboardci/htmlhint /bin/bash Run basic AWS command docker run -it -v "$(pwd)":/workspace cardboardci/htmlhint aws s3 cp file.

Docker image for LuaCheck Luacheck is a static analyzer and a linter for Lua. Luacheck detects various issues such as usage of undefined global variables, unused variables and values, accessing uninitialized variables, unreachable code and more. Most aspects of checking are configurable: there are options for defining custom project-related globals, for selecting set of standard globals (version of Lua standard library), for filtering warnings by type and name of related variable, etc.

Docker image for PyLint Pylint is a Python static code analysis tool which looks for programming errors, helps enforcing a coding standard, sniffs for code smells and offers simple refactoring suggestions. It’s highly configurable, having special pragmas to control its errors and warnings from within your code, as well as from an extensive configuration file. It is also possible to write your own plugins for adding your own checks or for extending pylint in one way or another.

Docker image for Render SVGs A utility to render Scalable Vector Graphics (SVG), associated with the GNOME Project. It renders SVG files to Cairo surfaces. Cairo is the 2D, antialiased drawing library that GNOME uses to draw things to the screen or to generate output for printing. You can see the cli reference here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.

Docker image for Rubocop RuboCop is a Ruby static code analyzer and code formatter. Out of the box it will enforce many of the guidelines outlined in the community Ruby Style Guide. RuboCop is extremely flexible and most aspects of its behavior can be tweaked via various configuration options. You can see the cli reference here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.

Docker image for StyleLint A mighty, modern linter that helps you avoid errors and enforce conventions in your styles. It’s mighty because it: understands the latest CSS syntax including custom properties and level 4 selectors extracts embedded styles from HTML, markdown and CSS-in-JS object & template literals parses CSS-like syntaxes like SCSS, Sass, Less and SugarSS has over 170 built-in rules to catch errors, apply limits and enforce stylistic conventions supports plugins so you can create your own rules or make use of plugins written by the community automatically fixes some violations (experimental feature) is well tested with over 10000 unit tests supports shareable configs that you can extend or create your own of is unopinionated so you can tailor the linter to your exact needs You can see the cli reference here.

CardboardCI A collection of docker images that provide a common core for use in continuous integration. The idea of these images is to balance the following: Frequency of updates Standard set of tooling Common Environment Background Notes I encountered a lot of difficult with trying to automate the updating of those docker images. GitLab does not really have the idea of bots. Instead it would require a personal access token for my account, if I wanted to make commits.

Bazel CSharp Rules Examples Overview This repository provides a set of usages for the bazel csharp rules. The idea behind these examples is to cover edge cases that are encountered during development, and provide a comprehensive test (& prototype) suite. While working on the bazel csharp rules, I have encountered bugs or small quirks that I would like to encode records of. Some of these are very minor details, so I felt it would work best to have them as an external repository.

Packer with GitHub Actions Experimenting with GitHub Actions for building machine images with Packer. Ideally trying to figure out what it takes for building the following on GitHub Actions: VirtualBox ISO Hyper-V ISO Docker Image Docker Image A base case. I want to confirm that I am in fact able to use packer without issue on GitHub Actions. HyperV I have had to do some work with Windows containers recently, and have found them to have performance issues for disk intense work.

Viewdocs Autodoc This was an early concept I was working with for converting metadata files (json/yml) into standard README markdown files using simple bash and templates. Ultimately I did not go in this direction, as I found that I was not making the best use of the customization yielded from using with bash + templates. A simple templating engine provided all the basics that I was ultimately after. Below I have described some of the template concepts I was exploring at the time:

Awesome Terraform Prototype An experiment using mkdocs and a series of json/yml files to define an awesome list. The markdown files are automatically generated from the yml files that define each element of the list (tags/metadata/etc). These files are then piped into mkdocs, which yields a material theme website for the project.

Minimizing Docker Builds Summary A GitlabCI repository designed to experiment with potential avenues for minimizing the size of a build image. Notes Experiment with flags from docker:1.13 for minimizing the process Compress the build-context that is sent to the daemon (compress) Squash the layers using the --squash flag Experiment with the tool docker-slim for shrinking the build image Issues with permissions on the tooling are preventing deployment in Gitlab

SVG Icon Processing Summary Experiment with programmatically generating color variants for SVG files using a JSON definition file with the source SVG. Usage The variants of each of the files is defined as a dictionary (string:object). The key for the dictionary matches the name of the variant. The object defines a collection of id and properties. These will be merged into the SVG to generate the variant icon. An example definition file is included below.

BullsEye Experimentation Summary Experiment with BullsEye for building command-driven tooling (build-systems). Usage Experimenting with using BullsEye in a dotnet project. BullsEye doesn’t handle parsing of command line arguments, instead recommends using a tool for parsing them. var app = new CommandLineApplication(throwOnUnexpectedArg: false); var foo = app.Option<string>("--foo", "foo", CommandOptionType.SingleValue); BullsEye can then be used to built a higher level build system for languages (terraform, docker, etc). Notes Creates common build-systems for templates (terraform-module, docker image) Auto-generate the console apps (BullsEye, CommandLineApplication) from a definition Define the system, then generate interfaces (service, cli, client, etc)

Vagrant Continuous Integration Prototype Pre-built Vagrant Box: -vagrant init ubuntu/trusty64 This example vagrant configuration installs and configures Ubuntu Trusty using simple Ruby scripts. The objective is to move as much of the Vagrantfile configuration into external ruby scripts. These scripts could then be split into testable functions and modules. Currently the focus is on providing a consistent installation process using shellcheck and rubocop. Aiming to have a simple vagrant example in this repository, and then use GitLab CI to perform linting on the provisioning scripts (shell+ruby).

GitHub Learning Lab - Lab Starter Noticed this when working with GitHub Actions that you can have a automated ‘teacher’ by using linting + GitHub Bot. Thought this was an interesting idea, and have started this repository to get a better understanding of how this actually works. With GitHub now having its own CI/CD Pipeline, it may be possible to create all sorts of tutorials for setting up applications. The first one that comes to mind is gamedev with something like Godot.

Welcome to “Hello World” with GitHub Actions This course will walk you through writing your first action and using it with a workflow file. Ready to get started? Navigate to the first issue.

Docker image for WkHtmlToPDF wkhtmltopdf and wkhtmltoimage are open source (LGPLv3) command line tools to render HTML into PDF and various image formats using the Qt WebKit rendering engine. These run entirely “headless” and do not require a display or display service. You can see the cli reference here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.

Docker image for SVG Tools SVG Tools are a collection of tools for working with vector graphics. You can see the cli reference here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.jpg" aws sts assume-role --role-arn arn:aws:iam::123456789012:role/xaccounts3access --role-session-name s3-access-example Pull latest image docker pull cardboardci/svgtools Test interactively docker run -it cardboardci/svgtools /bin/bash Run basic AWS command docker run -it -v "$(pwd)":/workspace cardboardci/svgtools aws s3 cp file.

Docker image for Surge This is the CLI client for the surge.sh hosted service. It’s what gets installed when you run npm install -g surge. This CLI library manages access tokens locally and handles the upload and subsequent reporting when you publish a project using surge. You can see the cli reference here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.

Docker image for Shellcheck ShellCheck is a GPLv3 tool that gives warnings and suggestions for bash/sh shell scripts: The goals of ShellCheck are: To point out and clarify typical beginner’s syntax issues that cause a shell to give cryptic error messages. To point out and clarify typical intermediate level semantic problems that cause a shell to behave strangely and counter-intuitively. To point out subtle caveats, corner cases and pitfalls that may cause an advanced user’s otherwise working script to fail under future circumstances.

Docker image for PSScriptAnalyzer PSScriptAnalyzer is a static code checker for Windows PowerShell modules and scripts. PSScriptAnalyzer checks the quality of Windows PowerShell code by running a set of rules. The rules are based on PowerShell best practices identified by PowerShell Team and the community. It generates DiagnosticResults (errors and warnings) to inform users about potential code defects and suggests possible solutions for improvements. You can see the cli reference here.

Docker image for PdfTools Scientific articles are typically locked away in PDF format, a format designed primarily for printing but not so great for searching or indexing. The new pdftools package allows for extracting text and metadata from pdf files in R. From the extracted plain-text one could find articles discussing a particular drug or species name, without having to rely on publishers providing metadata, or pay-walled search engines. You can see the cli reference here.

Docker image for Pdf2HtmlEX pdf2htmlEX renders PDF files in HTML, utilizing modern Web technologies. Academic papers with lots of formulas and figures? Magazines with complicated layouts? No problem! Features: Native HTML text with precise font and location. Flexible output: all-in-one HTML or on demand page loading (needs JavaScript). Moderate file size, sometimes even smaller than PDF. Supporting links, outlines (bookmarks), printing, SVG background, Type 3 fonts and more. You can see the cli reference here.

Docker image for Netlify The Netlify CLI facilitates the deployment of websites to Netlify, to improve the site building experience. You can see the cli reference here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.jpg" aws sts assume-role --role-arn arn:aws:iam::123456789012:role/xaccounts3access --role-session-name s3-access-example Pull latest image docker pull cardboardci/netlify Test interactively docker run -it cardboardci/netlify /bin/bash Run basic AWS command docker run -it -v "$(pwd)":/workspace cardboardci/netlify aws s3 cp file.

Docker image for LaTeX LaTeX is a high-quality typesetting system; it includes features designed for the production of technical and scientific documentation. LaTeX is the de facto standard for the communication and publication of scientific documents. LaTeX is available as free software. You can see the LaTeX reference here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.

Docker image for Hugo Hugo is one of the most popular open-source static site generators. With its amazing speed and flexibility, Hugo makes building websites fun again. You can see the cli reference here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.jpg" aws sts assume-role --role-arn arn:aws:iam::123456789012:role/xaccounts3access --role-session-name s3-access-example Pull latest image docker pull cardboardci/hugo Test interactively docker run -it cardboardci/hugo /bin/bash Run basic AWS command docker run -it -v "$(pwd)":/workspace cardboardci/hugo aws s3 cp file.

Docker image for GitLabCLI What is GitLabCLI ? It’s a cross platform GitLab command line tool to quickly & naturally perform frequent tasks on GitLab project. It does not force you to hand craft json or use other unnatural ways (for example ids, concatenating of strings) like other CLI’s to interact with GitLab. It does not have any dependencies. It’s self contained .NET core application - you don’t need to have .

Docker image for AWS CLI & Docker The AWS Command Line Interface (CLI) is a unified tool to manage your AWS services. With just one tool to download and configure, you can control multiple AWS services from the command line and automate them through scripts. This container includes docker, allowing deployments to Amazon Elastic Container Registry (ECR), a fully-managed Docker container registry. You can see the cli reference here. Usage You can run awscli to manage your AWS services.

Docker image for Bats (Bash Automated Testing System) Bats is a TAP-compliant testing framework for Bash. It provides a simple way to verify that the UNIX programs you write behave as expected. A Bats test file is a Bash script with special syntax for defining test cases. Under the hood, each test case is just a function with a description. #!/usr/bin/env bats @test "addition using bc" { result="$(echo 2+2 | bc)" [ "$result" -eq 4 ] } @test "addition using dc" { result="$(echo 2 2+p | dc)" [ "$result" -eq 4 ] } You can see the source repository here.

Docker image for AWS CLI The AWS Command Line Interface (CLI) is a unified tool to manage your AWS services. With just one tool to download and configure, you can control multiple AWS services from the command line and automate them through scripts. You can see the cli reference here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.

Docker image for GitHubCLI hub is an extension to command-line git that helps you do everyday GitHub tasks without ever leaving the terminal. hub can be safely aliased as git so you can type $ git <command>in the shell and get all the usual hub features. You can see the source repository here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.

Docker image for HadoLint A smarter Dockerfile linter that helps you build best practice Docker images. The linter is parsing the Dockerfile into an AST and performs rules on top of the AST. It is standing on the shoulders of ShellCheck to lint the Bash code inside RUN instructions. You can see the source repository here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.

Docker AWSCLI A docker image based on Windows containing the awscli.

.NET Core Native Compilation Experiments A simple CI/CD pipeline making use of CoreRT to build linux and windows copies of a “Hello World” console application. Notes CoreRT currently does not support compilation cross-compilation (as it is not supported yet). AOT for a linux binary requires non-dotnet dependencies (that need to be installed to be base image) At present it is likely best to use Windows docker images for building the dotnet native jobs.

Prototype CodePipeline Terraform Repository A repository for terraform execution in a Codepipeline task. This repository is part of an original experiment I wanted to have an terraform executor that met the following requirements: Use official terraform docker image (hashicorp/terraform:light) No external dependencies or custom images (e.g. terragrunt, astro, etc) Customizable execution process with minimal overhead Support in-repository modules No credential management (AWS Codepipeline execution) Multiple AWS environments within a single repository No single state file, state file per component (controlled by terraform.

Docker image for TfLint TFLint is a Terraform linter focused on possible errors, best practices, etc. You can see the cli reference here. Usage You can run awscli to manage your AWS services. aws iam list-users aws s3 cp /tmp/foo/ s3://bucket/ --recursive --exclude "*" --include "*.jpg" aws sts assume-role --role-arn arn:aws:iam::123456789012:role/xaccounts3access --role-session-name s3-access-example Pull latest image docker pull cardboardci/tflint Test interactively docker run -it cardboardci/tflint /bin/bash Run basic AWS command docker run -it -v "$(pwd)":/workspace cardboardci/tflint aws s3 cp file.

Makefile Experiments Summary Experimenting with using makefiles as a build harness type structure. The idea is to package makefile using GitHub, that can then be downloaded when running. Conceptual Usage As the structure is simply an experiment, no targets are actually implemented. At the top of the Makefile, you can include the makefile using the following: -include $(shell curl -sSL -o .build-system "https://.../makefile"; echo .build-system) This will download a Makefile called .

Infrastructure Summary The specification of jrbeverlylabs as a set of terraform modules. Usage To run this you need to execute: terraform init terraform plan terraform apply Notes This was a simple experiment making use of the gitlab provider of terraform. The idea was to see if it would assist in the process of maintaining jrbeverlylabs between gitlab.com and my internal gitlab instance.

XUnit.Metadata Summary Strongly-typed attributes for the management and organization of tests. As opposed to using strings throughout the code, [Trait("Category", "Unit")], you can use strongly-typed attributes for organizing tests. Getting Started With xUnit v2 you can markup tests with traits, particullary of interest is the category key. Using traits you can sort tests or control execution of tests from the command line. You can install in your project using the Nuget Manager Console:

XPlatformer-Workspace Summary A meta-repository for facilitating development of the many-repository XPlatformer project. Getting Started XPlatformer-Workspace is a git-submodules oriented approach for dealing with the multiple repositories of the XPlatformer project (XPlatformer / XGameLib / XSamples). The project provides all the repositories in one, using vagrant-desktop to provide an X11 development environment. You can clone all the repositories using the --recursive directive of git as such: git clone --recursive git@gitlab:.../XPlatformer-Workspace.git Or if the repository has already been cloned, you can use:

Wifi Web Summary Wifi Web provides an autorun USB for connecting to wireless access points for devices that do not have access to a camera. It opens an HTML page that provides easy access to the Wifi connection details. If you have a camera-enabled device, you can scan Wifi connection details using a QR Code (or any barcode type). Installation You can install Wifi Web onto a USB stick by unzipping the most recent build.

stack-opengl Summary stack-opengl is a variant of stack-net written in OpenGL. It uses extremely simple shaders and OpenGL programming to create a block stacking application. Getting Started The project uses premake4 as the cross-platform build system. You will need to build the external dependencies of the project, by running a root level build. You can then build the project itself. You can do so as such: premake4 gmake make cd src/ premake4 gmake make .

Stack-NET Summary A block blueprinter, built using a visual graph style approach to graphics. Getting Started The project is based on the old approach to C# projects. The project should be opened in Visual Studio, built, then run. Acknowledgements The project icon is retrieved from the Noun Project. The original source material has been altered for the purposes of the project. The icon is used under the terms of the Public Domain.

RayTracer Summary A Raytracer that receives a scene defined in lua, and produces an image output. Getting Started Compilation follows the standard process defined by the UWaterloo CS488 sample projects. We use premake4 as our cross-platform build system. First you will need to build all the static libraries that the projects depend on. To build the libraries, open up a terminal, and cd to the top level of the CS488 project directory and then run the following:

jrbeverly.profile Summary This is a one page user profile for Jonathan Beverly (jrbeverly - i.e. me), linking to multiple online identities, relevant external sites, and popular social networking websites. Not all of them are included, but most of the relevant ones are. Build Process The process of minimizing the web resources is handled using the command line utility of Minify which is available here. The process is used manually as opposed to leveraging a specific build system, is to experiment with more granular controls for website compilation.

jrbeverly portfolio Summary Collections data from a specified list of gitlab projects, then converts them into static HTML briefs. Getting Started The project is designed to git clone a series of repository, then collect information from each of them. This includes the project icon, name, license, path, etc. From this information, the project will then for each repository create: A brief - A simple static page featuring the README.md of the project rendered in a viewdocs format A redirect link, allowing one to navigate to jrbeverly.

Packer Desktop Summary This build configuration installs the vagrant-desktop environments onto minimal ubuntu images that can be used with Virtualbox. Getting Started Make sure all the required software (listed above) is installed, then you can build the images as follows: # cd x11/ # cd opengl/ # cd base/ packer build ubuntu.json After a few minutes, Packer should tell you the image was generated successfully. Acknowledgements The project icon is retrieved from the Noun Project.

office-depot Summary office-depot is a container based software development stack. Getting Started Getting started is as simple as using docker-compose. You can do so as such: docker-compose up --env-file=office-depot.env -d Updating and Upgrading If you wish to upgrade the container stack, you need to run the following commands: docker-compose stop docker-compose rm -v docker-compose pull You can then start the docker environment. docker-compose up --env-file=office-depot.env -d Cleaning After upgrading, you can be left with unused images or containers.

Mirroring Summary A lightweight bash script that allows easy mirroring of projects to external git hosts. Getting started Simply fork this repository, as it has all the scripts necessary for performing mirrors. You can then add your repositories into the assets/ directory. You will want to store them as such: > repoA/ > bitbucket.config > github.config > gitlab.config > someService.config > REPO > repoB/ > ... > repoC/ > ... Each repositroy is its own directory.

Localization.NET Concept Summary A simple experiment prototyping a concept for strongly typed language terms. Note: The generated component is not built with this. This is a usage prototype only (no generator is included). Getting Started The idea that Localization.NET is attempting to conceptualize is one where an interface is used as the primary mechanism for declaring language terms. Attributes can be used to include more contextual information (usage, type, namespace). The Roslyn compiler can then use this information to generate the underlying code to facilitate the Language terms.

Issues.Style Summary A style guide for issue management, release versioning, Git Flow and repository documentation. Description In order to speed up the initialization process of a new gitlab project, Issues.Style provides a set of common labels and issues that might be used when setting up a new project. The project provides methods for quickly setting up the project, specifically providing the following: Labels - Grouped by color, according to broad themes Setup Issues - Initialization labels, including licensing, documentation, CI and metadata.

jrbeverly.icons Summary A collection of scalable vector graphics (SVG) that define project and group icons. Build You can build the icons using the tool rsvg-convert. To build with rsvg-convert, you can do the following: rsvg-convert -f svg icon.svg > output.svg rsvg-convert -f png icon.svg > output.png It is recommend to use the build scripts available in build/ or in the local source directory. These scripts are used in the build pipeline, ensuring that all arguments and attributes are set for compilation of the icons.

gitlab-ci.yml A collection of GitLab CI configuration files that are used by my projects. Stored here as the process of docker projects are polished and standardized. Getting Started Each of the dockerfiles is presented with a simple .gitlab-ci.yml file that uses one of my docker images. The resources referenced by the definition are not included in this project. You can start by copying the .gitlab-cy.yml, then replacing the relevant bits.

Entity.NET Concept Summary A simple experiment prototyping a concept for strongly typed ORMs. Getting Started The idea that Entity.NET is attempting to conceptualize is one where strongly-typed objects are used with an ORM system. The primary objective is to use strongly typed identifiers (Keys.Customer) that restricts the usages of an applications ORM. The concept is from the following scenario: var cust = new Models.Customer() { Name = "John Doe" }; var entity = Repository.

Dockerized WKHtmlToPDF Summary A super small image with wkhtmltopdf installed. The project icon is from cre.ativo mustard, HK from the Noun Project NOTE: This image is marked EOL, and use is discouraged. Usage You can use this image locally with docker run, calling wkhtmltopdf: docker run -v $(pwd):/media/ jrbeverly/wkhtmltopdf:privileged wkhtmltopdf http://google.com google.pdf Gitlab You can setup a build job using .gitlab-ci.yml: build: image: jrbeverly/wkhtmltopdf:baseimage script: - wkhtmltopdf http://google.com google.pdf artifacts: paths: - google.

Dockerized Optipng Summary A super small Alpine image with OptiPNG installed. The project icon is from cre.ativo mustard, HK from the Noun Project NOTE: This image is marked EOL, and use is discouraged. Usage You can use this image locally with docker run, calling as such: docker run -v $(pwd):/media/ jrbeverly/optipng:baseimage optipng test.png Gitlab You can setup a build job using .gitlab-ci.yml: compile_pdf: image: jrbeverly/optipng:baseimage script: - optipng test.png artifacts: paths: - test.

Dockerized Minify Summary A super small image with Minify. The project icon is from cre.ativo mustard, HK from the Noun Project NOTE: This image is marked EOL, and use is discouraged. Usage You can use this image locally with docker run, calling minify as such: docker run -v /media/:/media/ jrbeverly/minify:privileged minify -o index-min.html index.html Gitlab You can setup a build job using .gitlab-ci.yml: compile: image: jrbeverly/minify:baseimage script: - minify -o index-min.

DistributedRPC Summary A multi-client, multi-server environment that relies on a binder to facilitate an RPC system. Getting Started To make (“compile and link”) all components of the project, you can quickly get started with make exec Or if you are doing quick debugging make exec && ./binder You can also invidiaully build each component with make <component>. Notes The project is over-commented to explain each line of code. This is for the purposes of explaining how the overall project connects together.

ContentBundler Summary A proof of concept for generation of strongly typed paths using the Roslyn Framework. Getting Started ContentBundler is provided as an command line application, originally adapted from an XNA Content Compiler. The new version greatly simplifies the code requirements, leveraging Roslyn for the code generation. An example is available from test/assets, which will generate the result [PatchQ.cs] ./ContentBundler.exe --archive patch-Q.zip --file PatchQ.cs --class PatchQ --namespace PlatformerGame.Assets This will then output a series of static classes.

Boxstarter.Workspace Summary A set of chocolatey packages for setting up a Windows PC. Getting Started The packages are not available on chocolatey.org, so they will need to be manually built. You can pack them up using the following: cd src/baseenv choco pack This will create a package. Acknowledgements The project icon is retrieved from the Noun Project. The original source material has been altered for the purposes of the project. The icon is used under the terms of the Public Domain.

UdaciCards Summary For the UdaciCards project, you will build a mobile application (Android or iOS - or both) that allows users to study collections of flashcards. The app will allow users to create different categories of flashcards called “decks”, add flashcards to those decks, then take quizzes on those decks. Installation You can install the project dependencies using: cd src/udacicards/ yarn The you can start the application: yarn start To troubleshoot the issues of the application, you can review React Native - Getting Started.

JollyBot Summary Prisoners' Dilemma A.I. bot performing an ‘Olive Branch’ strategy focusing on attempting to cooperate whenever possible. The bot attempts to establish cooperation, even in cases where the opposing agent may appear hostile (e.g. always defect). Description The iterated prisoner’s dilemma is a classic two-person game which consists of a number of rounds. In each round, each person can either defect by taking $1 from a (common) pile, or cooperate by giving $2 from the same pile to the other person.

Readable Udacity Nanodegree React Project Installing Server cd src/api npm install node start Installing Client cd src/client npm install npm start API Server Information about the API server and how to use it can be found in its README file. Acknowledgements The project icon is retrieved from the Noun Project. The original source material has been altered for the purposes of the project. The icon is used under the terms of the Public Domain.

MyReads Project Summary A digital bookshelf app that allows you to select and categorize books you have read, are currently reading, or want to read. Description MyReads is a digital bookshelf app that allows you to select and categorize books you have read, are currently reading, or want to read. It is built as a project for Udacity React Nanodegree. Getting Started The backend API uses a fixed set of cached search results and is limited to a particular set of search terms, which can be found in SEARCH_TERMS.

Vagrant Docker Desktop Summary Provide a method of reproducible graphical development environments based on Linux. This repository provides a base Docker Desktop environment, sandboxed on your local computer. Getting Started You can use this locally with vagrant up, calling as such: vagrant --name=mydesktop up However It is recommended to use the script create.sh for the first run to ensure all necessary arguments are provided. The provided arguments creates a settings.yaml, storing the settings for the machine.

Vagrant Homelab Desktop Summary Provide a method of reproducible graphical development environments based on Linux. This repository provides a base Homelab Desktop environment, sandboxed on your local computer. Getting Started You can use this locally with vagrant up, calling as such: vagrant --name=mydesktop up However It is recommended to use the script create.sh for the first run to ensure all necessary arguments are provided. The provided arguments creates a settings.yaml, storing the settings for the machine.

Githooks Summary GitHooks provides a multi-hook framework for Git Hooks, along with a collection of scripts for the purposes of encouraging a commit policy, altering the project environment depending on the state of the repository, and implementing continuous integration workflows. The framework allows multi-script execution, you can use GitHooks to automate or optimize virtually any aspect of your development workflow. Getting Started Git Hooks are event-based scripts you can place in a hooks directory to trigger actions at certain points in git’s execution.

Docker Alpine Base Summary A super small image with basic development libraries installed. The project icon is from cre.ativo mustard, HK from the Noun Project NOTE: This image is marked EOL, and use is discouraged. Usage You can use this image locally with docker run, calling sh to enter the container: docker run -it -v /media/:/media/ jrbeverly/alpine:edge sh Gitlab You can setup a build job using .gitlab-ci.yml: compile: image: jrbeverly/alpine:edge script: - echo "Hello world" Components Metadata Arguments Metadata build arguments used with the Label Schema Convention.

Dockerized pdf2htmlEX Summary A super small image with pdf2htmlEX installed. The project icon is from cre.ativo mustard, HK from the Noun Project NOTE: This image is marked EOL, and use is discouraged. Usage You can use this image locally with docker run, calling pdf2htmlEX: docker run -v /media/:/media/ jrbeverly/pdf2htmlEX:privileged pdf2htmlEX report.pdf Gitlab You can setup a build job using .gitlab-ci.yml: compile: image: jrbeverly/pdf2htmlEX:baseimage script: - pdf2htmlEX report.pdf artifacts: paths: - report.

Dockerized GLibC Summary A super small image with glibc installed, to allow binaries compiled against glibc to work. The project icon is from cre.ativo mustard, HK from the Noun Project NOTE: This image is marked EOL, and use is discouraged. Usage You can use this image locally with docker run, calling sh to enter the container: docker run -v /media/:/media/ jrbeverly/glibc:privileged echo "hello" Gitlab You can setup a build job using .

Dockerized X Window System Summary A super small image with X Window System development libraries installed. The project icon is from cre.ativo mustard, HK from the Noun Project NOTE: This image is marked EOL, and use is discouraged. Usage You can use this image locally with docker run, calling g++ to build X Window System applications: docker run -v $(pwd):/media/ jrbeverly/xwindow:privileged g++ myxapp.cpp -o xapp Gitlab You can setup a build job using .

Dockerized LaTeX Summary Comprehensive TeX document production system for use as a continuous integration image. The project icon is from cre.ativo mustard, HK from the Noun Project NOTE: This image is marked EOL, and use is discouraged. Usage You can use this image locally with docker run, calling latexmk as such: docker run -v /media:/media jrbeverly/latex:full latexmk -pdf manual.tex Gitlab You can setup a build job using .gitlab-ci.yml: compile_pdf: image: jrbeverly/latex:full script: - latexmk -pdf manual.

Boilerplate for Docker Repository Summary A boilerplate template for specifying a docker image using the makefile build approach. The project icon is from cre.ativo mustard, HK from the Noun Project This model of creating docker image has been deprecated. Components Metadata Arguments Metadata build arguments used with the Label Schema Convention. Variable Value Description BUILD_DATE see metadata.variable The Date/Time the image was built. VERSION see metadata.

Docker Baseimage Summary A super small image to act as a baseimage for continuous integration images. The project icon is from cre.ativo mustard, HK from the Noun Project NOTE: This image is marked EOL, and use is discouraged. Usage You can use this image locally with docker run, calling sh to enter the container: docker run -it -v /media/:/media/ jrbeverly/baseimage:baseimage echo "hello" Gitlab You can setup a build job using .

Dockerized RSvg Summary A super small image with librsvg installed. The project icon is from cre.ativo mustard, HK from the Noun Project NOTE: This image is marked EOL, and use is discouraged. Usage You can use this image locally with docker run, calling rsvg-convert to rasterize an image: docker run -v $(pwd):/media/ jrbeverly/rsvg:privileged rsvg-convert test.svg -o test.png Gitlab You can setup a build job using .gitlab-ci.yml: build: image: jrbeverly/rsvg:baseimage script: - rsvg-convert test.

Automated Windows Setup A script for setting up a Windows PC using BoxStarter and Chocolatey. Getting Started There are a few options for launching a BoxStarter script check out the offical documentation for all the various methods. > START http://boxstarter.org/package/nr/url?... Environments Environment Description basic A very simple box standard A common environment that can be used on multiple dev machines fullwin A .

Homelab Summary A collection of templates and utility scripts used in my homelab. Most of these are just snippets or experiments. Getting Started As most of the scripts are self-contained, you can clone the repository: git clone git://homelab/homelab And copy the relevant scripts into /usr/bin/ (or others) as necessary. You can also skip that, and just copy the contents of a file, then paste it into a fresh nano instance.

Vagrant OpenGL Desktop Summary Provide a method of reproducible graphical development environments based on Linux. This repository provides a base OpenGL Desktop environment, sandboxed on your local computer. The repository is meant for experimenting with OpenGL related programming in a virtual machine. Getting Started You can use this locally with vagrant up, calling as such: vagrant --name=mydesktop up However It is recommended to use the script create.sh for the first run to ensure all necessary arguments are provided.

Vagrant X11 Desktop Summary Provide a method of reproducible graphical development environments based on Linux. This repository provides a X11 Linux Desktop environment for the development of the XPlatformer project. Getting Started You can use this locally with vagrant up, calling as such: vagrant --name=mydesktop up However It is recommended to use the script create.sh for the first run to ensure all necessary arguments are provided. The provided arguments creates a settings.

Vagrant Linux Desktop Summary Provide a method of reproducible graphical development environments based on Linux. This repository provides a base Linux Desktop environment, sandboxed on your local computer. Getting Started You can use this locally with vagrant up, calling as such: vagrant --name=mydesktop --file=desktop.yaml up However It is recommended to use the script create.sh for the first run to ensure all necessary arguments are provided. The provided arguments requires a settings.

Blockycraft Manual Summary Blockycraft is an interactive graphics demo to create a Minecraft inspired demo. Blockycraft is focused on a series of graphics techniques create the graphical aethestics of a Minecraft world. This involves the usage of Perlin Noise for a dynamic world, lighting and shadows based on the positions of blocks in the world, and the aesthetic of the block world. The Blockycraft Manual explains the Blockycraft project in terms of interactive, compilation and technical components.

XSamples Summary XSamples provides a collection of XWindows starter code that works with the XGameLib library. The XGameLib library powers the XPlatformer project. All the examples make use of the XLib API (XOrg) and focus on code that was developed in the XPlatformer project (or planned to be used). The point of the examples is to demonstrate how to use the XGameLib library. Getting Started To make (“compile and link”) an example, use the included makefile with the name of cpp file passed as a variable.

XGameLib Summary XGameLib is a simple video game library used in the development of a classic side-scrolling arcade game, using the XLib API. The point of the game is to control a character through a terrain to meet an objective. The project makes use of the XLib API (XOrg) and focus on code that was developed to accomplish tasks for the assignment task. Components Component Filename Description Spritesheet Spritesheet.

XPlatformer Summary XPlatformer is a simple video game reminiscent of the classic side-scrolling arcade game, using the XLib API. The point of the game is to control a character through a terrain to meet an objective. The project makes use of the XLib API (XOrg) and focus on code that was developed to accomplish tasks for the assignment task. Getting Started To make (“compile and link”) an example, you can use bazel to build and run the project:

Friending Summary Friending is an online dating, friendship, and social networking mobile application that features user-created questionnaires. Friending has two primary features: joining groups to find people similar to you or signing up for events happening in your local area. Friending is a prototype built with the Proto.io application prototyping tool. The Friending prototype was built as part of a requirements specification project. The project focused on the development of a user manual around a fictional matchmaking application called Friending.

Friending User Guide Summary The Friending user manual provided as a web resource generated from the user manual. The user guide provides info and tips to help you understand the mobile application as a web resource, instead of the standard PDF representation of the user manual. The method used to convert the user manual can be viewed in the build/ directory. Friending Friending is an online dating, friendship, and social networking mobile application that features user-created questionnaires.

Friending Manual Summary The Friending user manual provides info and tips to help you understand the mobile application. The project is the actualization of a user vision and set of requirements to construct a matchmaking application. The User Manual encodes these requirements as scenarios and use cases, while the Friending prototype presents a high-fidelity vision of the matchmaking application. Friending Friending is an online dating, friendship, and social networking mobile application that features user-created questionnaires.

Jotto Summary Jotto is a logic-oriented word game played with two players. Each player picks a secret word of five letters (that is in the dictionary), and the object of the game is to correctly guess the other player’s word first. Players take turns guessing and giving the number of Jots, or the number of letters that are in both the guessed word and the secret word. The Jotto application is built with a single player, playing against a computer.