Glynn Bird

Client Architect @ IBM Cloud

Glynn started his career in the research and development arm of the steel industry, creating sensors and control systems. He then became a web developer for a business directory company building CRM systems, search technology and automated telephony systems. He now works for IBM in the UK, first as a Developer Advocate and now as a Client Architect.


          `/+........-......` `::`                 
          `/+----...----...``` `:.                 
           -/---::/:::::://:-.  ::                 
              `://///++//:-----o+ `                
          `````.+////////::-::/o- ``               
       `````.```-++///////::/+o:   ```    `        
   ```   ```` ```-/+//////////:`             `     
 ````...````` `.//..--:::::---`.   ````            
 .```...--...:+ooo/::::--..---:+:-...``     ````   
 ..`````....-:::::::////--://:::--..``````` ``.-`` 


A web-based drum machine.
A simple password generator.
A Apache CouchDB dashboard - with a sprinkle of SQL.
A guitar tab and lyrics store that allows each song's key to be changed.
Hacker news presented as Teletext.
Web-based recreation of an old BBC micro game.
Cryptic crossword tools.
Anagram Helper
A tool to help when making anagrams

Open Source Software

CSV/TSV import/export command-line scripts for interacting with Apache CouchDB.
A curl wrapper to make forming requests for Apache CouchDB easier.
Official Apache CouchDB Node.js client.
Grep through jsonl files using Mango selectors or SQL where clauses.
An incremental backup tool for Apache CouchDB.
A streaming JSON parser.
An incremental backup tool for Apache CouchDB.
A fast data movement tool for Apache CouchDB
A datawarehousing tool for data originating in Apache CouchDB/Cloudant.
CLI tool to help with Apache CouchDB replications.
Interact with Apache CouchDB as if it were a Linux file system.
CLI tool to help migration of index definitions with Apache CouchDB.
Deployable RSS-powered news aggregator.
Node.js library to convert SQL to CouchDB "Mango" queries.
Mastodon CLI tool. Send toots from the command line.
A Node.js library to create rate limited, defined-concurrency queues.
A Node.js library to generate time-sortable UUIDs.
CLI and Node.js library for dummy data generation.
Wordle clone for CLI fans.
Tells you where a lat/long pair is.


HTTP 429
Handling Cloudant's rate limiting HTTP response
HTTP 409
When is conflict not a conflict?
HTTP 200/201/202
What do CouchDB/Cloudant success response codes mean?
Replication Efficieny Improvements
How Cloudant made replication go faster?
Taxi Service
How to build a taxi service with Cloudant?
How I Backup CouchDB Data
Creating searchable, incremental backups with Apache CouchDB or Cloudant.
Simple Geospatial Queries
Finding data within a rectangle or nearest to a point
Using the Changes Feed
Best practices and pitfalls
Migrating from TXE
Switching from Cloudant TXE to Cloudant Standard
Storing data in a Cloudant index for faster retrieval
Code Engine & Cloudant
Using IBM's Code Engine platform with the Cloudant database
Removing Tombstones
Purging deleted documents from Cloudant/CouchDB databases
GitHub Webhooks and Cloud Functions
Using GitHub as a trigger for Cloudant data
Repairing a database with conflicts
Removing conflicted documents from a database
Migrating a Cloudant Account
Moving from one Cloudant account to another without downtime
Automated Daily Backups
Backing up Cloudant databases to COS every night.
JSON Schema Validation
Validating JSON schemas with CouchDB Design Documents
Transaction Engine Costs
Following the incentives to get the best performance for the lowest price.
Best Practice for Transaction Engine
How to get the best out of Cloudant on Transaction Engine
Building a Store Finder
Using Cloudant Search to implement a 'find nearest' store finder.
Optimising Cloudant Queries
Selecting the right index and query for the best performance.
Fast data transfer
A faster alternative to replication
Filtered Replication
Using a selector to filter documents from the changes feed.
Timing HTTP Requests in Node.js
Instrumenting your Node.js app to time HTTP requests in detail
Case-sensitivity in queries
Making a case-sensitive/insensitive query, MapReduce and search.
Point-in-time backup tool for CouchDB/Cloudant
Paginating _all_docs
Three ways to page through the CouchDB primary index
Logging with LogDNA
Logging Cloudant requests to LogDNA for monitoring and analysis
Design Docs For Life
Design documents in Cloudant & CouchDB
Error detection with Redis
Configuring retry/reconnection logic with Redis
Replicating from a Query
Replacing filtered CouchDB replication with query/write pattern
Paging with Cloudant bookmarks
Paging through results sets using the Cloudant bookmark feature
Partitioned Databases and Node.js
Using partitioned databases with the Node.js Cloudant library
Scheduled Cloudant Backups
Running regular backups of Cloudant databases using Kubernetes crons.
Optimal Cloudant Indexing
Using fewer indexes across multiple document types.
Analyzing backups with SQL Query
Archiving Cloudant data and querying it at rest on Object Storage.
Time-series data storage
Managing ever-growing data sets with time-boxed buckets.
Building a CRM System
How to build a CRM system with Cloudant's Partitioned Databases
Partitioned Databases - Sizing
Calculating the sizes of the partitions in Cloudant database
Partitioned Databases - Data Migration
Moving data from a non-partitioned to a partitioned database
Partitioned Databases - Data Design
How to design data for a partitioned Cloudant database
Partitioned Databases - Introduction
Introduction to the new partitioned databases feature in Cloudant
Natural Language Classification with CouchDB
Combining CouchDB with the IBM Watson Natural Language Classifier service
The Count Distinct Problem with CouchDB
Counting the distinct numbers of things in a collection is a memory intensive operation, but if you can accept an approximate answer there is a solution.
Caching CouchDB requests with Nginx
Caching frequently-performed searches can make your app run much faster with very little change in your code
CouchDB and the data warehouse
Pairing CouchDB, as a primary data store, and a data warehouse for ad-hoc queries gives you the best of both worlds.
Search Analyzers in Cloudant Search
Picking the right analyzer in your Lucene search
Generating sample data for a JSON data store
Using datamaker to generate meaningful sample data
Time-sortable document ids in Cloudant/CouchDB
Making a document id that is time-sortable and unique
Adding Cloudant search to your static Jekyll blog
Making a static HTML website have dynamic search
Cloudant Fundamentals - Aggregations
_sum-ming up the basics of Cloudant (part 10 of 10)
Removing Cloudant conflicts
Using couchdeconflict, a command-line tool, to declutter your database
Introducing CouchDB Nano 7.0.0
The latest release of the official Node.js library for Apache CouchDB
Using Cloudant from Jupyter Notebooks
Analyse your app’s Cloudant data directly from an interactive notebook
Cloudant Fundamentals - Indexing
Primary or secondary? Type json or text? Understanding your options (part 9 of 10)
Modelling Cloudant data in TypeScript
Using TypeScript classes in your code and saving their JSON representation in a Cloudant database.
Cloudant Fundamentals - Querying in Node.js
Using Node.js to build JSON and SQL queries
Cloudant Fundamentals - Querying
Using Cloudant Query to slice and dice your data
Optimising Cloudant for Serverless
Getting the best out of Cloudant using Cloud Functions
Software Engineering Radio Podcast
Developer Productivity with Open Source
Cloudant Fundamentals - Programmatic CRUD
Reading and writing documents from Node.js
Cloudant Fundamentals - The Bulk API
Using the bulk API to write and fetch documents
Emoji in Cloudant documents
Emoji are everywhere, but can they survive in a JSON data store?
Cloudant Fundamentals - The API
Using the API from the command-line
Date formats for Apache CouchDB & Cloudant
Picking the best format when storing date & time in JSON
Cloudant Fundamentals - The rev token
It's all about revisions. And trees.
Cloudant Fundamentals - The _id
Unlocking the mysteries of the unique _id field.
Cloudant Fundamentals - The Document
General tips on data modelling JSON documents.
Protecting Your Website Forms With Serverless CAPTCHA
Using a serverless function to prevent spam form completions.
Keeping Your Secrets Between Cloud Object Storage and Your Browser (Part 2)
Downloading files from Object Storage to the browser
Keeping Your Secrets Between Cloud Object Storage and Your Browser (Part 1)
Uploading files to Object Storage from a browser
Cloudant and CouchDB Replication with couchreplicate
A new command-line tool for managing and monitoring multiple replication jobs
Keeping Local Documents Local in a CouchDB-Style Replication Job
For when you replicate data, but need to leave a bit of config behind
Sharing variables between Python & Node.js in Jupyter notebooks
They live apart and speak different languages, but these variables hold common values
Creating partial Cloudant indexes
Filter data before it’s indexed to get the most out of your storage
Detatching Cloudant attachments to Object Storage with Serverless functions
How to build a pipeline to move Cloudant attachments to object storage using IBM Cloud Functions
Using your own domain name with Cloudant
Secure your custom domain using serverless functions on the IBM Cloud
Creating a Cloudant/Elasticsearch hybrid
Copying data from Cloudant to Elasticsearch using serverless OpenWhisk
Mapping the songs of Bruce Springsteen
Plotting geographical references from Springsteen lyrics on a map with Pixiedust
Track your crypto-currency portfolio with serverless functions
Poll an API to get bitcoin pricing and store it in Cloudant using OpenWhisk
Notebooks for Spreadsheet Users
Perform spreadsheet-like tasks in notebooks with this handy guide
Couchimport revisited
Updates to couchimport to allow multiple documents per line of CSV to be created.
Cloudant Envoy - Serverless Edition
The CouchDB one-database-per-user pattern, now with less infrastructure
Offline First Drum Machine
Offline-First drum machine modelled on a CR78 built with Vue.js and PouchDB
Building the fastest website in the world
From the Amp project and Google’s Lighthouse, to Offline First and service workers
Reading the open-source nutrition labels
The open-source projects that underpin various IBM cloud services.
Custom Indexers for Cloudant
Using JavaScript and Redis for problems that don’t fit Cloudant’s indexing engines.
Nodebooks - Custom Node.js visualisations in Notebooks (part 3)
Using Node.js modules, adding HTML and images and connecting to Redis databases from a Notebook with Node.js.
Nodebooks - Sharing data between Node.js and Python (part 2)
See how you can use Python and Node.js code in the same Jupyter notebook and share data between the two languages, using Pixiedust to visualise the results
Nodebooks - Node.js in Jupyter notebooks (part 1)
Developers can use notebooks too, for prototyping, data exploration and visualisation of results. If you're a Node.js developer, check out pixiedust_node for Jupyter notebooks
Open Source for Fun, Learning, and Kudos
Reflecting on my career, and advice on getting started
Custom Cloudant Replication
Use OpenWhisk to replicate a Cloudant database into many sub-databases, ready for replication. Read this worked example, using a bus timetabling display as a demo.
Serverless Autocomplete
Autocomplete is an excellent use of serverless technology because the autocomplete data set can reside in the same container as your API code. Find out how.
Querying Your PouchDB Database with SQL
You can now query your PouchDB databases with SQL using the pouchdb-silverlining plugin.
CouchDB Writes - Piecemeal, Bulk, or Batch?
There are several ways of writing data to Cloudant, this article explores the trade-offs between each approach.
Querying Cloudant with SQL
Cloudant doesn't natively support SQL queries, but now the cloudant-quickstart library allows SQL queries to be converted into Mango-JSON which Cloudant does understand.
Hacking vs. Prototyping vs. Production Code
Exploring the difference between knocking up a quick demo to producing prodction-ready code that others can build on. It uses the example of couchbackup, which went from hack to production this year.
API Rate-limiting with qrate
Avoid 429 error codes by rate limiting the API calls you make to third-party API services. qrate is a drop-in replacement for async.queue. Find out how easy it is to use.
Choosing a Cloudant Library
This articles the choices you have for Node.js libraries that talk to Apache CouchDB or Cloudant and the levels of abstraction they use.
Diff your database
Introducing couchdiff, a tool to tell you the difference between two CouchDB databases.
PouchDB - the Swiss army knife of databases
How I love PouchDB. Let me count the ways.
Serverless, Watson-powered chatbot for your business
Create a concierge service for your small business using Watson and OpenWhisk
Moving data from DocumentDB to Cloudant
Export data from Azure's DocumentDB to CouchDB or Cloudant
Alexa skills with Cloudant and OpenWhisk
Create your own Amazon Alexa skills using OpenWhisk.
Moving DynamoDB data to Cloudant
Export Amazon DynamoDB data to CSV then import to Cloudant
Analysing Cloudant data in notebooks
Use Runkit to analyse Cloudant data using JavaScript
Scalable online-petition with OpenWhisk
Building scalable serverless systems with OpenWhisk and Cloudant
Installing web apps with Electron
Distribute your web apps as installable applications on Mac, Windows & Linux.
Keeping secrets secret in Node.js
Tips on how to keep your API keys secret in Node.js applications
Dogfight - making retro game multiplayer
Turning a 1983 BBC Micro game into a web-base mulitplayer game.
Cloudant and Node.js Made Simple with the cloudant-quickstart (formerly silverlining) Library
A Cloudant and Node.js Made Simple with the cloudant-quickstart (formerly silverlining) Library
Creating a custom domain for Cloudant
Using Cloudflare in front of Cloudant allows you to have a custom domain, caching and more
Blazingly Fast Geospatial Queries with Redis
Import geospatial data into Redis using Python and make super fast 'find nearest' queries
Building Offline-First, Progressive Web Apps
Make web apps that sync offline, are installable on mobile phones and render on all devices.
OpenWhisk Microservices
Create microservices simply with OpenWhisk for event-driven computing.
Offline First QR Code scanner
An offline-first, web-based QR-code scanning app that syncs to Cloudant.
Searchable Game of Thrones
Importing Game of Thrones character data into the Simple Search Service
Multiplying Microservices
Adding simple metrics aggregation microservice for metrics collection.
Simple CouchDB & Cloudant backup
Three ways to backup your Cloudant or CouchDB databases.
Deploying the metrics collector microservice on Compose
Using Compose and IBM Cloud to deploy the Metrics Collector Microservice
Metrics Collector Microservice
Website and app metrics collector as Microservice using Redis/RabbitMQ/Kafka and writing to Cloudant/MongoDB/ElasticSearch
PouchDB in a Web Worker
PouchDB gives you offline-first storage in a browser. It can also run in a Web Worker to improve performance.
Simple Search Service
Created a faceted search engine by uploading a CSV file.
Introduction to Queues
A look at the differences between the various queue and broker technologies, listed here in order of increasing complexity, resilience, and capacity
Scaling Web Apps
How to use Message Hub (Kafka) or RabbitMQ to scale up a busy website
Command-line tools for CouchDB
Backup, design doc migration, shells and JSON parsers on the command-line.
Greenkeeper interview
Interview with the creators about their Node.js change management tool.
Export Cloudant to CSS, RSS and iCal
How to turn Cloudant JSON into other data formats directly from Cloudant
Slack to Cloudant
Writing data directly to Slack from Cloudant
Defensive coding in MapReduce
Avoid common pitfalls in writing MapReduce functions with Cloudant.
Spreadsheet to search
Turning your structured data into a faceted search engine is easy with Cloudant Search.
Cloudant Query Grows Up
A run-through of the features of Cloudant Query 'text' indexes for performing ad-hoc searches.
Replication guide
A beginners guide to replication
Design Document Management
A guide to CouchDB/Cloudant design documents, how they work and how to manage change control.
Building a Cloudant cluster from Raspberry Pis
A guide to building a distributed database with 13 Raspberry Pis.
A guide to Cloudant document conflicts - Part Three
The third part of triology on CouchDB document conflicts, how they work and how to resolve and avoid them
A guide to Cloudant document conflicts - Part Two
The second part of triology on CouchDB document conflicts, how they work and how to resolve and avoid them
A guide to Cloudant document conflicts - Part One
The first part of triology on CouchDB document conflicts, how they work and how to resolve and avoid them