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/::::--..---:+:-...``     ````   
 ..`````....-:::::::////--://:::--..``````` ``.-`` 
 .`....-.....--------:::::--------......---..`.-.--

Error detection with Redis

Configuring retry/reconnection logic with Redis
Redis

Replicating from a Query

Replacing filtered CouchDB replication with query/write pattern
CouchDB Cloudant

Paging with Cloudant bookmarks

Paging through results sets using the Cloudant bookmark feature
Search Cloudant

Partitioned Databases and Node.js

Using partitioned databases with the Node.js Cloudant library
Node.js Cloudant

Scheduled Cloudant Backups

Running regular backups of Cloudant databases using Kubernetes crons.
Kubernetes Cloudant

Optimal Cloudant Indexing

Using fewer indexes across multiple document types.
CouchDB Cloudant

Analyzing backups with SQL Query

Archiving Cloudant data and querying it at rest on Object Storage.
SQL Cloudant

Time-series data storage

CouchDB Cloudant

Building a CRM System

How to build a CRM system with Cloudant's Partitioned Databases
Partitions Cloudant
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
Caching Cloudant Requests with cachemachine
Take the load off your back-end API by adding a simple Redis caching layer in front.
Blazingly Fast Geospatial Queries with Redis
Import geospatial data into Redis using Python and make super fast 'find nearest' queries
Enhanced Cloudant Search with Watson
Add structure to your unstructured data with Watson Alchemy APIs for a better search experience
Plug into the Cloudant Node.js Library
Now includes plugins for 429 retries, Promises and your custom designs.
NoSQLImport
Import CSV data into Cloudant/CouchDB, MongoDB or ElasticSearch
Building Offline-First, Progressive Web Apps
Make web apps that sync offline, are installable on mobile phones and render on all devices.
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.
Simple Autocomplete Service
Turn a list of strings into a performant autocomplete API service.
Chrome Extensions with PouchDB
Create offline-first Google Chrome extensions that can sync with Cloudant/CouchDB.
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.
Log sharing service
Simple log sharing utility built with Node.js, Redis and Cloudant.
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
Volt
Password vault as a Chrome Extension using PouchDB
Command-line tools for CouchDB
Backup, design doc migration, shells and JSON parsers on the command-line.
Greenkeeper interview
Interview with the Greenkeeper.io 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
Proforma
Offline first data capture
Gutenberg
Offline-first e-book reader built with PouchDB
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.
Flasher
LED flashing utility for Raspberry 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
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
Anagrammer
Anagram solver built with a Cloudant's and a custom MapReduce index.
md
Offline first markdown word-processor
Xword
Collaborative crossword tool
Celcius
IoT demo with Raspberry Pi & Cloudant
GeoQuiz
Client-side programming demo using jQuery & Cloudant.
Proxee
Programmable HTTP proxy that uses CouchDB/Cloudant
Yub
Node.js library for interaction with Yubico's API
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.
couchimport
A simple CSV import for CouchDB/Cloudant. Import structured text into NoSQL from the command line.
couchshell
CouchDB/Cloudant command-line shell. Enables you to interact with CouchDB as if it were a Unix file system.
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.
BirdReader
Host-it-yourself RSS Reader built with Node.js & Cloudant. Host on Cloud, PC or Raspberry Pi.