It’s been six weeks to the day since the Automattic layoffs, so it seems fitting to finally gather my thoughts about it.

I haven’t blogged publicly for quite a while, not counting the odd code snippet post. But in the last few months I’ve been itching more and more to do so again. I was going to dip my toes gently by writing semi-public updates to share with my work colleagues, alas always leaving it at the bottom of the todo list meant I never got to the more personal / lessons learned / interesting-things-found-on-the-web kind of P2s (internal blog posts).

Well, I guess it makes this a bit of a Goodbye post, but also a Hello at the same time.

Farewell

Working on Tumblr has been one of the best work experience I've had and I do not regret skipping the alignment offers last year. It meant I got to work on a product I liked and believed in with people I respect and admire for those extra months. So with that chapter closing here’s a look back at the last three years.

When I started, I was giddy with excitement when I got my initial team placement details (👋 Core Web). The learning curve was steep, but worth it. Being surrounded by so many knowledgeable engineers, who share your passion to learn and co-learn with others, who are quirky, and fun, and kind, was exhilarating. There was passion for the product and our users, with fierce internal debates, even if sometimes that was not visible outside (the steamroller of capitalism and 'bills need to be paid' reality getting in the way).

I gained a real appreciation for user research while on the Labs Team. I still wish we could have explored more of the weird and wonderful ideas that came from the user needs inspired brainstorming sessions.

The re-orgs were tough, but despite the impact of the company-wide changes the newly formed Tumblr Web team managed to keep the momentum going. I’m glad to have stickers with our super adorable team logo! The design system work was something we all are proud of. It probably won't be a surprise to those I've worked with, that the Storybook work we did was one of my favourite things.

The team meetups really were the secret sauce to remote work - maybe I got lucky, but after meeting my colleagues in person they quickly became more like good old friends (even though most were younger *cough*). I'm grateful for the travel opportunities (and all the glorious food 😂). I'll always think fondly of both the project work we did during the meetups and the goofing off after hours. I don't like naming names, but I've enjoyed working with every single person on all those teams and a bunch of others outside them. :)

Guess-the-meetup activity:

Processing

With all that said, I was surprised how calmly I took the layoff. The abrupt severance of access to not just work, but also: hobby discussions, parenting talk, draft knowledge sharing posts, tons of to-read-later posts saved on Slack... was eerie to say the least. In many ways it wasn't just work, the official Slack was full of smaller more personal communities, that you suddenly are booted from too. It was a new experience for me (I was the one to move on in all the positions before) and so I was glad for the friendships that allowed me to reconnect with others outside of the official Slack.

Personally the timing was odd. I had a big family trip planned just days after, followed by Easter holidays. In hindsight, this might have helped with the transition, as I was winding down things already for the two week break. But it did make for an awkward vacation juggling all the paperwork while herding kids between the pool and holiday clubs. It also meant there wasn't much point looking at the job market properly until after the break.

I've clearly had a few more weeks after that to think. Well, almost. As I said, the timing was odd. While my husband and I normally don't do big celebrations for our anniversary this year was a big, round one, so I did have a bunch of planning and herding of guests to do. So between many party checklists and food shops, and reading about my colleagues' interview prep work 🙈 I kind of, mostly, swept the big question under the metaphorical carpet.

Hello

What is next then? After some soul searching (and a bunch of productivity research *cough* procrastination), I've come to the conclusion that while I'm open to a job that would be challenging and interesting and maybe returning to contracting, I want to first try something else. There’s been a few ideas I’ve been itching to try, but have not had time to do. There’s a parenting app I’ve been meaning to do, if just for my own use, and book writing I’ve put on hold when I had kids, as well as adventures with AI.

I wanted to document my workflows and experiments at work and share my thoughts more. Guess I’ll be doing that here instead of in internal P2s. It feels a bit weird putting it all out in the open again, but also a bit exciting.

Let’s see where it goes.

I kept struggling to remember what the type predicate was in Typescript... turns out I just didn't really know what a 'predicate' is in the first place... shakes fist darn you grammar!

I've been playing around with FeathersJS and one thing that has been hard to find is a concrete example of setting up Sequelize with related tables.

Here's an example of the users table referencing a user_statuses table using the new model.associate() syntax including populating the output of the users.find() endpoint with a hook.

Model setup

The user's model here is the basic file generated by @feathersjs/authentication with just the foreign key added and the relationship defined.

# src/models/user.model.js
# file generated using @feathers/cli

const Sequelize = require('sequelize');
const DataTypes = Sequelize.DataTypes;

module.exports = function(app){
	const sequelizeClient = app.get('sequelizeClient');
	const users = sequelizeClient.define('users', {
		email: {
			type: DataTypes.STRING,
			allowNull: false,
			unique: true
		},
		password: {
			type: DataTypes.STRING,
			allowNull: false
		},
		statusId: {
			type: Sequelize.INTEGER,
			field: 'status_id'
		}

	}, {
		hooks: {
			beforeCount(options){
				options.raw = true;
			}
		},
	});

	users.associate = function(models){
		users.hasOne(models.userStatuses, {
			as: 'UserStatus',
			foreignKey: 'id'
		});
	};

	return users;
};

UserStatuses model - just the generated file. No changes really needed for this one way relationship.

# src/models/user-statuses.model.js
# file generated using @feathers/cli

const Sequelize = require('sequelize');
const DataTypes = Sequelize.DataTypes;

module.exports = function(app){
	const sequelizeClient = app.get('sequelizeClient');
	const userStatuses = sequelizeClient.define('userStatuses', {
		name: {
			type: DataTypes.STRING
		}
	}, {
		hooks: {
			beforeCount(options){
				options.raw = true;
			}
		},
	});

	userStatuses.associate = function(models){
	};

	return userStatuses;
};

Populating the Relationship

The goal is to return the related table as part of a users.find() call. As a bare minimum you want to set two Sequelize params in a before hook: include (see Sequelize documentation for more details on this option) and raw:true (if you want a nested object rather than a flat structure).

# src/services/users/users.hooks.js
# file generated by @feathers/authentication

const {authenticate} = require('@feathersjs/authentication').hooks;
const {
	hashPassword, protect
} = require('@feathersjs/authentication-local').hooks;

module.exports = {
	before: {
		all: [],
		find: [
                        authenticate('jwt'),
                        //
                        //      Quick & dirty example 
                        //
                        context => {
                                const sequelize = context.params.sequelize || {};
                                sequelize.raw = true;
                                sequelize.include = [
		        		{
			        		model: context.app.services['user-statuses'].Model,
				        	as: 'UserStatus'
				        }
			        ];
                                return context;
	        	},
                ],
		get: [authenticate('jwt')],
		create: [hashPassword()],
		update: [hashPassword(), authenticate('jwt')],
		patch: [hashPassword(), authenticate('jwt')],
		remove: [authenticate('jwt')]
	},

	after: {
		all: [
			// Make sure the password field is never sent to the client
			// Always must be the last hook
			protect('password')
		],
		find: [],
		get: [],
		create: [],
		update: [],
		patch: [],
		remove: []
	},

	error: {
		all: [],
		find: [],
		get: [],
		create: [],
		update: [],
		patch: [],
		remove: []
	}
};

As various models might make use of this functionality I've actually created a generic hook addAssociations(). It takes multiple models for the include option and looks up the model object for you based on a shorthand string. (I'm still looking at a good way of handling hyphens vs camelcase so excuse the mix of names in the example below)

# src/hooks/add-associations.js
# hook generated by @feathers/cli

module.exports = function(options = {}){
	options.models = options.models || [];

	return async context =>{
		const sequelize = context.params.sequelize || {};
		const include = sequelize.include || [];

		//	Reasign in case we created these properties
		sequelize.include = include.concat(options.models.map(model => {
			const newModel = {...model};

			newModel.model = context.app.services[model.model].Model;
			return newModel;
		}));

		//	Nested output
		sequelize.raw = false;

		context.params.sequelize = sequelize;
		return context;
	};
};

And here's the updated users.hooks.js file:

# src/services/users/users.hooks.js
# file generated by @feathers/authentication

const {authenticate} = require('@feathersjs/authentication').hooks;
const addAssociations = require('./../../hooks/add-associations');

const {
	hashPassword, protect
} = require('@feathersjs/authentication-local').hooks;

module.exports = {
	before: {
		all: [],
		find: [
			authenticate('jwt'),
			addAssociations({
				models: [
					{
						model: 'user-statuses',
						as: 'UserStatus'
					}
				]
			})
		],
		get: [authenticate('jwt')],
		create: [hashPassword()],
		update: [hashPassword(), authenticate('jwt')],
		patch: [hashPassword(), authenticate('jwt')],
		remove: [authenticate('jwt')]
	},

	after: {
		all: [
			// Make sure the password field is never sent to the client
			// Always must be the last hook
			protect('password')
		],
		find: [],
		get: [],
		create: [],
		update: [],
		patch: [],
		remove: []
	},

	error: {
		all: [],
		find: [],
		get: [],
		create: [],
		update: [],
		patch: [],
		remove: []
	}
};

All this results in a nice nested JSON response:

{
    "total": 1,
    "limit": 10,
    "skip": 0,
    "data": [
        {
            "id": 1,
            "email": "name@example.com",
            "statusId": 1,
            "created_at": "2017-11-08T15:25:01.000Z",
            "updated_at": "2017-11-08T15:27:29.000Z",
            "UserStatus": {
                "id": 1,
                "name": "active",
                "created_at": "2017-11-08T15:25:01.000Z",
                "updated_at": "2017-11-08T15:25:01.000Z"
            }
        }
    ]
}

As part of cleanup and cost-cutting I had to recently moved my WordPress installations from one server to another. To make matters a bit more complicated the new server was not a cPanel based one. So, I had to move my WordPress instances, but not really the user accounts that held them as such.

After getting a bit frustrated with WordPress MU and going through several plug-ins for static sites (neither of which really worked…), I finally found something that did.

Enter: UpdraftPlus - Backup/Restore plug-in

The free version was enough to get the job I needed done. It’s quite a robust plugin that functions as a backup, but also works really well for migrating sites to a new server while maintaining the same domain name.

With docker on the other end the process ended up being quite simple:

1. Install Updraft on the old WordPress instance
2. Run the plugin and backup everything
3. Create a new docker instance (I've used the official Wordperss image)
4. Use /etc/hosts to access the new WordPress install under the old domain
5. Setup the new WordPress instance - doesn't matter really what details you use, as we'll override everything soon enough
6. Install the Updraft plugin
7. Upload the backup files downloaded earlier
8. Press restore and enjoy your new site!

So much easier than trying to deal with the native export tool WordPress provides that unfortunately doesn’t cover plugin or theme settings.

I should probably start by admitting that I haven't played the game itself. But like must gamers (unless they've been living under a rock) I had an idea about what Assassin's Creed is about. I knew about the praise it got and about the interesting "time travel" bit, However it being a bit too action oriented for my taste one never actually played it. The premise intrigued me, but there always were enough actual rpgs to keep me occupied.

Cue the movie. Right from the trailers it looked great. And after seeing it, Assassin's Creed the movie is definitely worth the big screen. It unapologetically mimics game aesthetics and maybe it says a lot about games too, but some scenes felt exactly like something that would be part of gameplay.

I haven't read any reviews (I find too many film critics are just cinema snobs who don't understand the movie genre nor the target audience if the movie isn't some sort of deep drama...) beforehand as I like to go in unbiased. It's often hard to stop thinking about something that a person mentioned as a flaw and that then ruins my enjoyment.

The movie was cool. Not groundbreaking, not complex, not full of Oscar winning performances. But it was a fun romp with great score over dynamic chases and some great parkour sequences. I enjoyed the special effects, and so what that there were plenty of plot holes. Sometimes you just go with it and enjoy the ride.

I've got the extraction options for tgz files pretty well ingrained in my brain, but whenever I had to create an archive I always had to go back to the manual.

Not any more! Annoyed at my terrible memory I created a little mnemonic for myself. Here's the command in question:

tar -czvf FILENAME.tgz FOLDER

And to remember the params I've got this nifty sentence:

Tar Can Zip Very Fast

I guess it should be gZip for accuracy, but hey it works for me ;)

Sometimes you have to take one step back to take two forward. Or in other words, never say never. Or to put it in simple terms – I’ve gone perm again…

I’ve been pretty happy with the contracting work I’ve done over the last year and a bit. After being preoccupied almost exclusively with the publishing work before that, it’s been a nice change to be coding full-time again (occasional side projects here and there don’t really count in my book). I’ve also been lucky enough to meet some great people along the way.

Despite being a loner at heart I had to admit I did miss the office banter a bit. So when I ended up contracting at an exciting company with a great team, the year had flown by fast. And while I was adamant I wouldn’t be going back to full time employment, sometimes the stars align just right and an opportunity lands in your lap that you just can’t refuse.

With a slew of exciting projects ahead I’m thrilled to join Castle Trust this month as their Lead Developer. Yay! :)

At the same time, this does not mean I’m saying goodbye to my publishing dreams. On the contrary – “Feral: The Dragon Within” has just been release (expect a longer post soon about the 2+ years of work I put into that book), and while I’m working on Feral part 2 and Hellena’s story, there’s some exciting things I’d like to try with the Wing & Fang brand soon too.