Glynn Bird

Developer Advocate @ IBM Cloud

Home Contact

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 as a Developer Advocate.

  
              `.-:-.`...`                      
              `.:/+o+//ossys+:.                    
            `:/+ooossyhhhyhhyo:.`                  
            -+oooossyyysoo++oso/-                  
           -::```.--:/:---..../+-                  
          `/+........-......` `::`                 
          `/+----...----...``` `:.                 
           -/---::/:::::://:-.  ::                 
           `+:/+ossso//+osso+:-/:/                 
            //+ssssss--++oo+++//::`                
            /+///////..-::::--.`.::`               
            ./::--:::--.-----.``::-                
             -:::://o+///:::--.`..`                
             `::/+//++o+/:://-..`                  
              -//+oo+o+++//+/--.                   
              `/++//++o+/:::/:-`                   
               .++////+//:::::-                    
                :+++ooo+o++//:.                    
               .:/+ossssoo+/:-..                   
               /://++++++//:--.o-                  
              `://///++//:-----o+ `                
          `````.+////////::-::/o- ``               
       `````.```-++///////::/+o:   ```    `        
   ```   ```` ```-/+//////////:`             `     
 ````...````` `.//..--:::::---`.   ````            
 .```...--...:+ooo/::::--..---:+:-...``     ````   
 ..`````....-:::::::////--://:::--..``````` ``.-`` 
 .`....-.....--------:::::--------......---..`.-.--
 

Cloudant Fundamentals - Querying

Using Cloudant Query to slice and dice your data
Cloudant Query

Optimising Cloudant for Serverless

Getting the best out of Cloudant using Cloud Functions
Cloudant Serverless

Software Engineering Radio Podcast

Developer Productivity with Open Source
Open Source Podcast

Cloudant Fundamentals - Programmatic CRUD

Reading and writing documents from Node.js
Cloudant

Cloudant Fundamentals - The Bulk API

Using the bulk API to write and fetch documents
Cloudant

Emoji in Cloudant documents

Emoji are everywhere, but can they survive in a JSON data store?
Cloudant

Cloudant Fundamentals - The API

Using the API from the command-line
Cloudant

Date formats for Apache CouchDB & Cloudant

Picking the best format when storing date & time in JSON
Cloudant CouchDB

Cloudant Fundamentals - The rev token

It's all about revisions. And trees.
Cloudant

Cloudant Fundamentals - The _id

Unlocking the mysteries of the unique _id field.
Cloudant

Cloudant Fundamentals - The Document

General tips on data modelling JSON documents.
Cloudant

Protecting Your Website Forms With Serverless CAPTCHA

Using a serverless function to prevent spam form completions.
Serverless

Keeping Your Secrets Between Cloud Object Storage and Your Browser (Part 2)

Downloading files from Object Storage to the browser
Serverless Object Storage

Keeping Your Secrets Between Cloud Object Storage and Your Browser (Part 1)

Uploading files to Object Storage from a browser
Serverless Object Storage

Cloudant and CouchDB Replication with couchreplicate

A new command-line tool for managing and monitoring multiple replication jobs
Cloudant CouchDB Replication

Keeping Local Documents Local in a CouchDB-Style Replication Job

For when you replicate data, but need to leave a bit of config behind
Cloudant CouchDB

Sharing variables between Python & Node.js in Jupyter notebooks

They live apart and speak different languages, but these variables hold common values
Jupyter Node.js Notebooks

Creating partial Cloudant indexes

Filter data before it’s indexed to get the most out of your storage
Cloudant

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
Cloudant Serverless Object Storage

Using your own domain name with Cloudant

Secure your custom domain using serverless functions on the IBM Cloud
Cloudant Serverless

Creating a Cloudant/Elasticsearch hybrid

Copying data from Cloudant to Elasticsearch using serverless OpenWhisk
Cloudant Serverless ElasticSearch

Mapping the songs of Bruce Springsteen

Plotting geographical references from Springsteen lyrics on a map with Pixiedust
Cloudant Pixiedust Geo

Track your crypto-currency portfolio with serverless functions

Poll an API to get bitcoin pricing and store it in Cloudant using OpenWhisk
Cloudant Serverless Blockchain

Notebooks for Spreadsheet Users

Perform spreadsheet-like tasks in notebooks with this handy guide
Notebooks Pixiedust

Couchimport revisited

Updates to couchimport to allow multiple documents per line of CSV to be created.
Cloudant CSV ETL

Cloudant Envoy - Serverless Edition

The CouchDB one-database-per-user pattern, now with less infrastructure
Cloudant Serverless Offline First

Offline First Drum Machine

Offline-First drum machine modelled on a CR78 built with Vue.js and PouchDB
Offline First PouchDB Vue.js

Building the fastest website in the world

From the Amp project and Google’s Lighthouse, to Offline First and service workers
Static GitHub AMP

Reading the open-source nutrition labels

The open-source projects that underpin various IBM cloud services.
Open Source

Custom Indexers for Cloudant

Using JavaScript and Redis for problems that don’t fit Cloudant’s indexing engines.
Cloudant Serverless Redis Node.js

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.
Node.js Notebooks Jupyter Redis

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
Node.js Notebooks Jupyter

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
Node.js Notebooks Jupyter

Open Source for Fun, Learning, and Kudos

Reflecting on my career, and advice on getting started
Open Source Career

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.
Cloudant Serverless Replication

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.
Serverless

Querying Your PouchDB Database with SQL

You can now query your PouchDB databases with SQL using the pouchdb-silverlining plugin.
PouchDB SQL

CouchDB Writes - Piecemeal, Bulk, or Batch?

There are several ways of writing data to Cloudant, this article explores the trade-offs between each approach.
CouchDB Cloudant

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.
Cloudant SQL

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.
Cloudant Backup

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.
Node.js API Queue

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.
Cloudant Node.js

Diff your database

Introducing couchdiff, a tool to tell you the difference between two CouchDB databases.
CouchDB Cloudant

PouchDB - the Swiss army knife of databases

How I love PouchDB. Let me count the ways.
PouchDB

Serverless, Watson-powered chatbot for your business

Create a concierge service for your small business using Watson and OpenWhisk
Serverless Watson Node.js

Moving data from DocumentDB to Cloudant

Export data from Azure's DocumentDB to CouchDB or Cloudant
DocumentDB CouchDB Cloudant

Alexa skills with Cloudant and OpenWhisk

Create your own Amazon Alexa skills using OpenWhisk.
Serverless Cloudant

Moving DynamoDB data to Cloudant

Export Amazon DynamoDB data to CSV then import to Cloudant
DynamoDB CouchDB Cloudant

Analysing Cloudant data in notebooks

Use Runkit to analyse Cloudant data using JavaScript
Notebooks Cloudant

Scalable online-petition with OpenWhisk

Building scalable serverless systems with OpenWhisk and Cloudant
Cloudant Serverless Node.js

Installing web apps with Electron

Distribute your web apps as installable applications on Mac, Windows & Linux.
Cloudant Electron

Keeping secrets secret in Node.js

Tips on how to keep your API keys secret in Node.js applications
Node.js

Dogfight - making retro game multiplayer

Turning a 1983 BBC Micro game into a web-base mulitplayer game.
RethinkDB Node.js

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
Cloudant Node.js

Creating a custom domain for Cloudant

Using Cloudflare in front of Cloudant allows you to have a custom domain, caching and more
Cloudant Cloudflare

Caching Cloudant Requests with cachemachine

Take the load off your back-end API by adding a simple Redis caching layer in front.
Redis Cloudant Cache

Blazingly Fast Geospatial Queries with Redis

Import geospatial data into Redis using Python and make super fast 'find nearest' queries
Redis Geo Python

Enhanced Cloudant Search with Watson

Add structure to your unstructured data with Watson Alchemy APIs for a better search experience
Cloudant Watson Search

Plug into the Cloudant Node.js Library

Now includes plugins for 429 retries, Promises and your custom designs.
Node.js Cloudant

NoSQLImport

Import CSV data into Cloudant/CouchDB, MongoDB or ElasticSearch
Cloudant CSV MongoDB ElasticSearch

Building Offline-First, Progressive Web Apps

Make web apps that sync offline, are installable on mobile phones and render on all devices.
PWA Cloudant PouchDB

Scaling Offline First with Envoy

Cloudant Envoy allows offline-first apps to maintain the 1-database-per-user model, while storing all the data in one database on the server side.
Cloudant Node.js Offline First

Simple Autocomplete Service

Turn a list of strings into a performant autocomplete API service.
Redis Node.js

Chrome Extensions with PouchDB

Create offline-first Google Chrome extensions that can sync with Cloudant/CouchDB.
Offline First Chrome PouchDB

OpenWhisk Microservices

Create microservices simply with OpenWhisk for event-driven computing.
Serverless Slack Cloudant

Offline First QR Code scanner

An offline-first, web-based QR-code scanning app that syncs to Cloudant.
PouchDB Offline First

Searchable Game of Thrones

Importing Game of Thrones character data into the Simple Search Service
Cloudant Search

Multiplying Microservices

Adding simple metrics aggregation microservice for metrics collection.
Microservices Node.js

Simple CouchDB & Cloudant backup

Three ways to backup your Cloudant or CouchDB databases.
Cloudant CouchDB

Deploying the metrics collector microservice on Compose

Using Compose and IBM Cloud to deploy the Metrics Collector Microservice
Microservices MongoDB RabbitMQ

Metrics Collector Microservice

Website and app metrics collector as Microservice using Redis/RabbitMQ/Kafka and writing to Cloudant/MongoDB/ElasticSearch
Microservices Queue PubSub

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.
PouchDB

Log sharing service

Simple log sharing utility built with Node.js, Redis and Cloudant.
Redis Cloudant Node.js

Simple Search Service

Created a faceted search engine by uploading a CSV file.
Cloudant Search CSV

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
Redis Kafka RabbitMQ Microservices

Scaling Web Apps

How to use Message Hub (Kafka) or RabbitMQ to scale up a busy website
Microservices Kafka RabbitMQ

Volt

Password vault as a Chrome Extension using PouchDB
PouchDB

Command-line tools for CouchDB

Backup, design doc migration, shells and JSON parsers on the command-line.
CouchDB Cloudant

Greenkeeper interview

Interview with the Greenkeeper.io creators about their Node.js change management tool.
Cloudant

Export Cloudant to CSS, RSS and iCal

How to turn Cloudant JSON into other data formats directly from Cloudant
CSV Cloudant

Slack to Cloudant

Writing data directly to Slack from Cloudant
Slack Cloudant

Proforma

Offline first data capture
Offline First PouchDB

Gutenberg

Offline-first e-book reader built with PouchDB
Offline First PouchDB

Defensive coding in MapReduce

Avoid common pitfalls in writing MapReduce functions with Cloudant.
Cloudant JavaScript

Spreadsheet to search

Turning your structured data into a faceted search engine is easy with Cloudant Search.
Cloudant Search

Cloudant Query Grows Up

A run-through of the features of Cloudant Query 'text' indexes for performing ad-hoc searches.
Cloudant

Replication guide

A beginners guide to replication
Cloudant Replication

Design Document Management

A guide to CouchDB/Cloudant design documents, how they work and how to manage change control.
Cloudant

Building a Cloudant cluster from Raspberry Pis

A guide to building a distributed database with 13 Raspberry Pis.
Cloudant Pi

Flasher

LED flashing utility for Raspberry Pi
Pi

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
Cloudant CouchDB

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
Cloudant CouchDB

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
Cloudant CouchDB

Anagrammer

Anagram solver built with a Cloudant's and a custom MapReduce index.
Cloudant

md

Offline first markdown word-processor
Offline First PouchDB

Xword

Collaborative crossword tool
PouchDB

Celcius

IoT demo with Raspberry Pi & Cloudant
Cloudant

GeoQuiz

Client-side programming demo using jQuery & Cloudant.
Cloudant

Proxee

Programmable HTTP proxy that uses CouchDB/Cloudant
Cloudant

Yub

Node.js library for interaction with Yubico's API
Yubico Node.js

couchmigrate

A CouchDB design document migration tool that allows you to switch in a new design doc and wait for it build before putting it live.
Cloudant CouchDB

couchimport

A simple CSV import for CouchDB/Cloudant. Import structured text into NoSQL from the command line.
Cloudant CouchDB CSV

couchshell

CouchDB/Cloudant command-line shell. Enables you to interact with CouchDB as if it were a Unix file system.
Cloudant CouchDB

ccurl

CouchDB/Cloudant command-line helper. Enables you to interact with Cloudant's HTTP API from the terminal without typing domain names, protocols, passwords, content-types etc.
Cloudant CouchDB

BirdReader

Host-it-yourself RSS Reader built with Node.js & Cloudant. Host on Cloud, PC or Raspberry Pi.
CouchDB RSS Node.js