
Over the past two years I’ve been cooking as a hobby, trying to replicate dishes I see at higher end restaurants. 

I post my creations on Instagram and it’s led to a lot of people (mainly men), asking me how they too can create food that tastes and looks appealing. I’m in no way a chef, and there a far better, more wise cooks out there than me, but for benefit of a novice teaching another novice, i’ll write down some of my learnings.

## The Golden Rule
> “Mother Nature is the true artist and our job as cooks is to allow her to shine.” —  Marco Pierre White

If you have bad quality ingredients you end up needing to do more to them in order to enhance their taste, whereas the better quality the ingredients, the less you need to do as by default as they taste amazing.

Let’s take the humble Tomato for example. Less fresh, out of season tomatoes, end up being less acidic, and less rich in flavour. They’re best to be blended into a tomato soup or put into a sauce along with tomato paste. However, fresh, in-season Tomatoes can be served sliced with Mozzarella, or grated and sieved as a Bruschetta. Such a contrasting difference in the effort of preparation.

## Evaluating Recipes
I hate complex recipes and I hate long ingredient lists. I also don’t think a recipe book should contain recipes that have ingredients not easily obtained by most readers.

Those cookbooks do more harm than good for novice cooks as they appear scary, or too complex to try and attempt. Few authors understand this and they try hard to curate cookbooks that serve as good starters for the novice cook, these include:

* [Ottolenghi SIMPLE](https://ottolenghi.co.uk/simple)
* [Nigel Slater - Real Fast Food](https://www.nigelslater.com/real-fast-food_bk_25)
* [Nigel Slater - Real Fast Puddings](https://www.nigelslater.com/real-fast-puddings_bk_28)
* [Nigel Slater - Eat](https://www.nigelslater.com/eat_bk_2)

When looking at a recipe, I ask myself:

_Are the ingredients listed available to me via my local grocers?_

No point missing out a key spice or ingredient due to it not being easy to find.

_Are the ingredients in-season (i.e: going to be fresh)?_

This goes back to the golden rule - if it’s in season and locally produced then you’re going to get the best flavour out of it.

_Is the number of on-plate ingredients less than 5-6?_

The more ingredients you have to plate, the harder it’ll be to make it look prettier.

_Can you make a portion of the dish ahead of time?_

I once made a bean puree ahead of time, so come time to cook I just had to worry about the steak and potatoes.

## Plating A Dish
The most common question I get is how to make a dish look pretty on the plate. Considering that we first eat with our eyes, this step is probably the most important.

There are actually a number of different plating techniques ranging from landscape, free form, to contemporary etc. But for the novice chef, I recommend sticking to landscape until you work up enough confidence to try other styles.

1. Start by applying the puree or sauce to the dish (the thinner the sauce the less of it you should apply to avoid drowning the food).
2. Add the ingredients on to the dish one at a time, layering them on top or to the side of one another. *Note*: height is generally preferred when plating.
3. Add your decorations such as herbs or green vegetables on at this stage to finish off the dish.
4. Serve and amaze your friends.

![](https://images.unsplash.com/photo-1560717845-968823efbee1?ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&ixlib=rb-1.2.1&auto=format&fit=crop&w=1950&q=80)

## Necessary Equipment
There’s a few tools I find myself using daily when cooking food:

**Stainless steel or copper saucepan**

Get yourself a saucepan that can go in and out of the oven, it’ll save you a tonne of washing up, and allows you too have all the flavours in one place.

**Microplane grater**

For adding parmesan or zesting any fruit into/onto a dish

**Chef’s Knife**

The omnitool of the kitchen, the chef’s knife is your best friend. Spend more than £50 getting one and get used to it’s handle.

**Food Processor**

Useful for making pastries, cheesecakes, and purees. I can’t live without mine.

The Novice's Guide To Cooking


Growth engineers are concerned with optimizing all stages of a self-serve business' funnel. Often this comes in the form of running small experiments within the product or marketing site, which the growth engineer will build and test themselves.

The aim of the growth engineer is to make small improvements (1-10%) to the funnel which add up over time. Unlike a product engineer who will aim to have a much larger impact (20-50%) to one stage of the funnel with a new feature launch.

Growth engineers also concern themselves with the internal operations of the business. For example, creating data pipelines from Segment to Salesforce in order to better personalize lifecycle emails, or writing scripts to backfill lead data to give sales better insight into the customers.

In order to become a growth engineer you'll need a few key skills:

1. A good understanding of SQL

No matter the reporting tool having a good understanding of SQL will allow you to pull up product usage data and find trends.

2. 1-3 years of engineering experience

Startups are a busy environment. Product engineering teams have schedules and roadmaps, and having to rely on them to build small experiments for you is a waste of their time. Instead being able to quickly jump into any part of the product and make the changes you want will save you, and the company time, and allow for rapid iteration based on learnings.

3. An understanding and love of digital marketing

Funnels, CTR, CPC, CLC, Page Score, etc. If you hate marketing you'll hate growth engineering. A growth engineer will be working alongside the CMO and other marketers, so you'll need an understanding of how the funnel operates and what metrics the marketing team are looking to improve.




What is Growth Engineering?


While I had some time off over Christmas I decided it would be useful to read up on product validation. Especially after the launch of my first startup, Readercatch, which although launching quite successfully on ProductHunt failed to generate any meaningful conversion.

I created a site called validationguide.com (using [Ghost](http://ghost.org/)) to host all this research. Upon researching the topic, I realized something, Almost all product validation methods for successful bootstrapped companies are the same.

There's the odd sneaky company that uses Ads or just launches a product without validation. But for the most part almost all validated companies do these things:

### 1) Listen To People

Whether it's selling [Bone Broth](http://justinmares.com/how-i-validated-my-idea-for-kettle-fire/) or [launching the next platform for App deals](https://tim.blog/2011/09/24/how-to-create-a-million-dollar-business-this-weekend-examples-appsumo-mint-chihuahuas/). **Validating products requires listening to people's problems first**.

In other words for your product to be validated you need to start talking to people and asking them about their problems, what's taking up their time at work, etc.

For Kettle & Fire it was Justin's friends talking about how great Bone Broth was and Justin finding out that no business sold Bone Broth online. For App Sumo it was Kagan's last startup, Gambit, where he learned that startups wanted more users over more revenue.

### 2) Sell Sell Sell

Nowadays when a startup is launching you see the plain old email signup landing page. That's great if you're the next X in tech and everyone's hyping about you, but for validating your customer's needs an email sign up box sucks.

Instead try creating a fake (or real) checkout flow for the product that doesn't exist yet. Justin validated Kettle & Fire by creating an Unbounce landing page with a PayPal checkout and knew he was onto something when he received $500 in orders. App Sumo validated it's business model by running Reddit Ads and selling pro Imgur accounts. Drip validated it's problem by emailing a bunch of founders asking about email marketing.

Being lean doesn't mean building the full product. In fact if you can get someone to pay you based off an idea then you're onto a real winner of a business.

### 3) Find A Way To Easily Reach Customers

So you've found a group of customers who have a problem and you want to see if your solution will solve it for them. Here's a few quick ways:

1. Cold email/message/call your target customer (How Drip got started)
2. Run FB/Google/Bing/Etc Ads (How Kettle & Fire got started)
3. Write blog content and share it online about how your product solves X and Y (How Basecamp got started)

**Your target customer should be so relieved that your product exists that they should be willing to pay for it.** Don't make the mistake of building something nice to have.

What I Learnt Reading 80 Articles On Product Validation


Since it has been almost a year since I’ve joined Tray.io as a Senior Growth Engineer. I figured it was time for a reflection on my thoughts on what I define as the basis for what I do every day.

Not only to share my lessons with you but to also define a structure for future growth engineers to quickly get up to speed

## Choose A Metric

> “You can't manage what you can't measure.” - Peter Drucker

We begin the process by choosing a metric that we wish to improve. More often then not this will be a baseline metric such as Conversion Rate, Form Fill Rate, Website load time, Engagement, Email Link Clicks, etc.

What I tend to do is look at the metric and see if I can see any obvious trends. Has it decreased over time? Does it peak during times of the year? Is there another metric that impacts this metric?

This is useful further down the line so you can factor in a metric's normal behavior when you make a change.

## Develop a Hypothesis

> “Quickness is the essence of the war.” - Sun Tzu

Now you must ask yourself how you’ll improve this metric. To not get married to a single solution I tend to ask myself a series of questions:

- **What’s impacting this metric?** For metrics such as conversion rate, you can observe traffic sources, website load time, etc.
- **How could I cause this metric to go down?** Useful to think of the opposite for once and do the inverse.
- **Who is responsible for this metric?** You can get a deeper insight by speaking with the person in charge of acquisition etc.

I often find that forcing myself to come up with more than one solution often leads to thinking about edge cases and other tactics that can feed into the main solution.

Once you’ve developed your hypothesis **I recommend finding the smallest possible way to test it**. Whether that be an A/B test or tweaking some variables or copy. The aim is to see if the hypothesis will have an impact on the metric. If a small change can cause a slight shift then implementing the full change will cause an uptick.

## A/B Test it

> “The options are limitless, but each path must begin with the same first step: replacing assumptions” – Tim Ferriss

Once you’re ready to release your change to the world I recommend partially releasing it to a subset of your traffic. I’ve mentioned previously that you should test your hypothesis with a small tweak, which acts as an indicator, but **when making larger changes I still like to test the effects.**

It has the benefit of being able to quickly see the percentage improvement you’ve delivered compared to the old version of the site. Normally I see a lot of developers skip this step and just deploy the entire change which makes it harder to see the impact in the short term.

## Keep an eye on it

> “If you wait by the river long enough, the bodies of your enemies will float by.” - Sun Tzu

Don’t just give up now that you’ve released! Keep an eye on that metric as **it may take a few days for the changes you’ve made to show any significant impact**.

I highly recommend having an easily accessible dashboard which shows all the metrics your team is working on to improve. **Watch the metric for 1-2 weeks to see if the trend has been impacted. Factor in that external sources might also be contributing to any trends that you’re seeing**

## Closing Thoughts

If you haven’t already noticed the above process is very similar to the [Lean Startup approach by Eric Reis](http://theleanstartup.com). My convictions about Growth Engineering is that it should closely follow the Lean Startup method. As engineers we are constantly creating features, products, updating copy, and looking for new ways to help the business. It makes perfect sense therefore to follow a method that validates our assumptions and acts as a guiding principle for improvement.

if you’re a software engineer who has a fascination with marketing and optimizing conversion rate etc. Then I’d love to talk with you about the above process and get your thoughts on it.

The Growth Engineering Process


Since my last article I've been getting a lot of questions on Twitter on how to find business ideas. I'm no guru myself but I do end up with a lot of SaaS ideas (almost daily at this point).

> [@KameronTanseli](https://twitter.com/KameronTanseli?ref_src=twsrc%5Etfw) Hi, please suggest some idea that a single developer can make, that make $100 per month.
> 
> — Mustafa Hanif (@MustafaHanif8) [May 12, 2020](https://twitter.com/MustafaHanif8/status/1260121626856865794?ref_src=twsrc%5Etfw)

To name a few ideas I've had recently...

*   A discovery site for accessing paid, membership-only Slack groups
*   Slack command to buy a slack space owner a Coffee
*   Founder Chats, weekly recorded zoom calls with my founder friends where we review a maker's new product.
*   Printable Meal Plans from a Google Sheet (PTs love using Google Sheets for everything)
*   [Buy & Sell Zapier Workflows](http://copythatworkflow.com/) on an Online Marketplace
*   [A journal based on Fear Setting](http://thefearsettingjournal.com/) by Tim Ferriss

Okay, the last two I'm acting on but you're free to take the rest :)

## Generating your own Ideas

In the past [I have talked about how to come up with better niche ideas](/blog/if-you-want-to-have-great-startup-ideas-then-be-a-weirdo/). Since then I've read up on a lot of new tactics just solely based on analysis. So here's what I found:

*   Unbundle existing platforms ([Zapier](/blog/first-it-was-craiglist-next-its-zapier/), [Craigslist](https://thegongshow.tumblr.com/post/345941486/the-spawn-of-craigslist-like-most-vcs-that-focus), [AWS](https://www.tclauson.com/2019/09/11/Unbundling-AWS.html) etc)
*   [Unique and interesting domain names](https://www.deepsouthventures.com/i-sell-onions-on-the-internet/)
*   [Analysing market numbers with GTrends and FB Ads](https://tim.blog/2011/09/24/how-to-create-a-million-dollar-business-this-weekend-examples-appsumo-mint-chihuahuas/)
*   Turn popular book methods into apps (e.g: [5 Minute Journal](https://apps.apple.com/gb/app/five-minute-journal/id1062945251))
*   Create directories for niche groups (e.g: [Glide Apps](https://community.glideapps.com/c/app-showcase), [Sheet2Site Showcase](https://www.sheet2site.com/showcase/))
*   [Analysing Google Keywords Searches](https://startupbook.net/)

If the above doesn't generate anything exciting for you. Try just calling up your friends and asking them about their day at work and what challenges they're having etc. People love to talk about their problems.

Finding Good Ideas


As I delve deeper into the no-code space I see a lot of Zapier, Integromat and [Tray.io](https://tray.io) workflows. Some of these are actually quite complex and require some programming knowledge to understand them (which kind of defeats the point of no-code).  
  
As I was looking at some of these workflows, I couldn't help but think how there will be this eventual shift like with Craiglist where companies will spring up that just focus on certain more complex popular workflows.

Take for example a project of mine, [gsheet2mail.com](https://gsheet2mail.com), you could make it in Zapier like so:

1.  Create a Zap
2.  Query for your spreadsheet
3.  Parse the fields of your spreadsheet into something usable
4.  Connect the result of #3 and pipe it into a RSS feed connector
5.  Copy the webhook URL and paste it into Mailchimp
6.  Realise that Mailchimp queries your RSS feed a lot
7.  Run out of Zaps
8.  Pay $29 per month

Compare that to the custom app I built:

1.  Sign in with google
2.  Copy the example spreadsheet
3.  Paste in your new spreadsheet URL
4.  Connect to Mailchimp
5.  Done

Even if the customer needed to go premium the cost would be significantly lower (around $6 a month) because I don't need to support massive infrastructure or bother about investor pressure.

So my advice if you're looking for your next indie software idea. Just observe what these no-coders are automating on Zapier and build a nice UI around it.

> “Complexity can be tamed, but it requires considerable effort to do it well. Decreasing the number of buttons and displays is not the solution. The solution is to understand the total system, to design it in a way that allows all the pieces fit nicely together, so that initial learning as well as usage are both optimal. Years ago, Larry Tesler, then a vice president of Apple, argued that the total complexity of a system is a constant: as you make the person's interaction simpler, the hidden complexity behind the scenes increases. Make one part of the system simpler, said Tesler, and the rest of the system gets more complex. This principle is known today as "Tesler's law of the conservation of complexity." Tesler described it as a tradeoff: making things easier for the user means making it more difficult for the designer or engineer.”  
> ― **Donald A. Norman,** [**Living with Complexity**](https://www.goodreads.com/work/quotes/13144201)

P.S: Why you're here [follow me on Twitter](https://twitter.com/KameronTanseli) 😉

First, it was Craigslist, next it's Zapier


You've had the next best idea, Uber for Cats, and you have coded up a landing page test complete with email capture and pricing tables in true lean fashion.

Your next step is to observe the impact after you funnel customers to it. Most likely your go to analytics tool is Google Analytics.

## Focus on one metric

*   Page views are meaningless unless extracted into a conversion rate.
*   Sessions are meaningless unless extracted into a conversion rate.
*   Daily active user charts are just plain confusing and best avoided.

What I'm trying to hint at is that Google Analytics is full of really pretty charts that you'll waste your time worrying about. Unless you're a Google Analytics wizard you don't know how to setup goals and trigger events and in my opinion don't bother.

There are plenty of tools out there like [Full Story](https://fullstory.com) or [Hot Jar](https://www.hotjar.com/) that offer conversion targets based on user events out of the box as a main feature. That leads me to my second point...

## User Recordings Will Save You

I use Full Story at work and on my personal projects. It's a lifesaver for figuring what your users are actually doing. For [gsheet2mail.com](https://gsheet2mail.com ) I realised customers were clicking the top header example link, so I added more examples which drove a higher conversion rate and more link clicks for viewing pricing.

I wouldn't have known that if I had a goal setup in GA as GA's job is for high level numbers not user to user interactions. It's those user interactions in the early stages that help you redefine how your product works and build something truly worth sharing with others.

Why you shouldn't use Google Analytics for your MVP


For the last week I've been acting as a sort of motivational speaker to my friends. Each one has been hampered with fears around their creative pursuits.

I'm quite fortunate to have experienced consistent failure within my field of creativity. Micro-SaaS app building is not something you can ace first time and most ideas have a 2% chance of being successful.

So for the majority of you, let me give you the same advice I said to my friends.

## The Majority consumes, the Minority creates.

For the last 8 days I have blogged consistently every day (even the days where I nearly forget and I end up writing at around 11pm). This has brought in around 600 unique readers to my blog, something I never thought would be a thing now that I reflect on it.

But it goes to show that if you put content online people will consume it. To put it metaphorically:

> Act like the farmer and you'll start to grow a crop.

## But what if people don't like my work

Firstly that's all in your head. Secondly you don't know if people don't like your work till you share it with them.

## I never have enough motivation

Start small. Want to write a blog post every day? Try just tweeting your idea. Want to paint? Try sketching a rough outline. You'll find that just by starting small you'll begin to break that barrier in your head of "this will be too much effort".

## The idea already exists

Unless your idea is to build the next Uber, Airbnb, or Microsoft. I'm pretty sure you can put your own unique flair or solution to whatever problem your trying to address.

If we just stopped after one person made a CRM. We wouldn't have Salesforce.

If we stopped after one person did a self-portrait. We wouldn't have the Mona Lisa.

You get what I'm trying to say.

Getting Over Fears


When your product change rapidly in the face of new information. You have a greater chance of coming out on top.

With that I'd like to talk about a tech stack that has helped me build SAAS apps from start to finish.

## Node & Express

Starting off with the basics is crucial. I'm not going to build a SPA if its just me working on it. I need quick turn arounds and a low amount of JS errors so I can get a good night's rest.

I chose Express as its the most mature out of the other alternatives. I know if I encounter a problem that someone has solved it with Express.

Notable packages to use with Express include:

*   [Passport](http://www.passportjs.org) for Authentication
*   [Flash](https://www.npmjs.com/package/express-flash) for Notifications

## Handlebars

I chose Handlebars because its easy to learn and simple to use. Express has a great package which allows me to create flexible layouts using partial tags and overall I've never had any problems or limitations using it.

    {{#unless user.hasPremium}}
      <div class="notification is-info is-light">
        <div><strong>Get Access to GSheet2Mail Premium</strong></div>
        <p style="margin-bottom: 20px;">
          Get access to unlimited feeds and linked spreadsheets with GSheet2Mail Premium
        </p>
        <a href="/app/upgrade" class="button is-info">Get Premium</a>
      </div>
    {{/unless}}
    

## Mongoose

Changing data on the fly without having to do massive SQL migrations is a blessing and a curse (at times). For a single developer looking to launch something quick. Mongoose can be used to whip up a new app in minutes.

    const feedSchema = new Schema(
      {
        user: { type: Schema.Types.ObjectId, ref: "User" },
        title: String,
        description: String,
        spreadsheetId: String
      },
      { timestamps: true }
    );
    
    const Feed = mongoose.model("Feed", feedSchema);
    

## Bulma

Theres few CSS frameworks out there that have developer UX in mind like Bulma has. I love the way the docs are presented and the components fit great on the page without needing much in the way of JavaScript to support them (looking at you Bootstrap 3.0).

![](../static/posts/screenshot-www.oneprofile.info-2020.05.02-22_12_09.png)

One of the many beautiful Bulma websites out there

## Heroku

Controversial. But I just like an all in one service and I really hate AWS. So theres not much in the way of services that I know are going to be around forever like Heroku is.

Plus I can one click provision Mongo Databases and create pipelines like a staging environment etc without having to faff around in documentation.

## Conclusion

So thats the tech stack that helps me build bigger more complex apps. If you're curious I use Next for static sites because Next is just super awesome :)

My Productivity Tech Stack


Since the great tech boom of the 90s we have slowly created and scaled companies to solve most of our needs. We now have hairdressers that will bring the salon to us, robots that can drive us places, and drones to deliver packages for us.

It's safe to say that all the basic problems have been solved.

### So how do I come up with new ideas?

Be interesting. I mean it. If you like going to gym and you follow a specific diet read everything about that diet. If you work with JavaScript for a living read about design patterns or functional programming.

The idea is to learn the things that the majority are not willing to learn. It's when you do that you'll find the minority with the problems that they care enough to pay for.

If you want to have great startup ideas then be a weirdo


Prerequisites

*   [Node.js](https://nodejs.org/en/) Installed
*   [A code editor](https://code.visualstudio.com/)

## Getting Started

In order to scrape a website in 2020 we need to make sure we're using something that can click, tap and scroll as websites have become a lot more dynamic since 1999.

Luckily [Puppeteer](https://pptr.dev/) is a Node API that allows us to control a [Google Chrome Browser](https://www.google.com/chrome/) using simple code commands.

To get started we need to install Puppeteer:

    npm i puppeteer --save
    

Then create a JS file called `index.js` and import Puppeteer like so:

    const puppeteer = require('puppeteer');
    

## Basic Example

Before we do any Puppeteering we need to create an [Async IIFE](https://anthonychu.ca/post/async-await-typescript-nodejs/):

    ;(async () => {
     // code goes here
    })();
    

This will allow us to write `await` calls which are needed as the puppeteer API is asynchronous. Now let's open and close a browser instance:

    ;(async () => {
      // Opens the browser
      const browser = await puppeteer.launch();
      // Opens a new tab
      const page = await browser.newPage();
        
      // closes the entire browser
      await browser.close();
    })();
    

Then after we've got our browser setup let's navigate the tab we opened to go to [HackerNews](https://news.ycombinator.com/):

    (async () => {
      const browser = await puppeteer.launch();
      const page = await browser.newPage();
      // navigates the tab to load HN
      await page.goto('https://news.ycombinator.com/');
      await browser.close();
    })();
    

Great now that we have a program that can open HackerNews. Let's grab the top 10 headlines:

    (async () => {
      const browser = await puppeteer.launch();
      const page = await browser.newPage();
      await page.goto('https://news.ycombinator.com/');
      // queries the page and returns an Array of Elements
      const headlines = await page.$$eval(
       '.storylink', 
       // grab the top 10 and get the titles
       stories => stories.slice(0, 10).map(s => s.innerText)
      );
      // log to the console
      console.log(headlines.join('\n'))
      await browser.close();
    })();
    

Our console should now output a result like this:

    Using Reinforcement Learning in the Algorithmic Trading Problem
    Show HN: Insomnia Designer – Open-source collaborative editor for API design
    What other coronaviruses tell us about SARS-CoV-2
    Hacking Together an E-ink Dashboard
    Lyft lays off 17% of workforce, furloughs hundreds more
    Recovered virus patients retest positive due to 'dead' virus fragments: experts
    Why Segment Went Back to a Monolith
    Iron Ox is looking for a DevOps engineer to help scale automated indoor farming
    Good writing is a business advantage
    Building a WireGuard jail with FreeBSD's standard tools
    

## Clicking Elements

A more advanced example is clicking an element on the page. Luckily with Puppeteer its quite straight forward. Here's an example of clicking the upvote button on the front page of HN:

    (async () => {
      const browser = await puppeteer.launch();
      const page = await browser.newPage();
      // navigates to HN
      await page.goto('https://news.ycombinator.com/');
      // clicks the first vote arrow on the page
      await page.click('.votearrow')
      await browser.close();
    })();

Getting Started with Puppeteer


Over the last few years I've collected a variety of tools to help cut down my wasted time. Here's a few tools that I found incredibly helpful:

# Time Tracking

**RescueTime**

There is probably a million time tracking apps at this point but one tool in particular which I kept getting recommended to me is [RescueTime](https://www.rescuetime.com/).

![RescueTime](../static/posts/automation-rescuetime.png)

RescueTime has a variety of great features that surpass many of the other tracking apps:

* Cross Platform Apps: Chrome, Desktop, Mobile.
* Daily, Weekly, Monthly summaries.
* Huge categorisation database to aggregate from.
* Set Goals for how you spend your time
* Compare your time against people in the same industry as you

I've used RescueTime to identify that I spent way too much time on Instagram and Reddit. Having cut those down my productivity hours has increased to fill those 2-3hrs I was wasting.

**Google Calendar**

One of the most used calendar apps on this earth, Google Calendar is unbeatable when it comes to convenience and platforms. 

Did you know that you can also write scripts for Google Calendar? If you head to [script.google.com](https://script.google.com/home) you can create/run/share scripts that are run on the Google Cloud.

A way that I manage my time using GCal is to colour code my events. This gets repetitive if you're manually making events each day but [if you do a bit of programming magic](https://rickpastoor.com/2019/05/30/google-calendar-color-coder.html) you can have it colour code your week every 15 minutes:

![Google Calendar](../static/posts/automation-gcal.png)


## Task Management

When it comes to Todo lists there are a few things I look for:

1. Clean and simple interface
2. Dates/Reminders to do different tasks
3. Add descriptions / urls to the todos

With those criteria, I ended up stumbling across [TickTick](https://ticktick.com/home). [TickTick](https://ticktick.com/home) is an app which nails the Todo list experience and also helps me jot down every idea/task that I have throughout my day.

[TickTick](https://ticktick.com/home) also packs in a load of other great features:

* Cross Platform Support
* Calendar View
* Tagging
* Habits
* Streaks
* Prioritising

![TickTick](../static/posts/automation-ticktick.png)

## Mail

I'm not one of those people who suffer from ridiculous amounts of email a day (sometimes I wish I did). However when I do get an important email in the morning [I snooze it](https://support.google.com/mail/answer/7622010?co=GENIE.Platform%3DDesktop&hl=en) until 2pm, this is because I like to keep my mornings focused and peaceful.

[Gmail](https://gmail.com), a Google owned mail client allows me to do just that from any platform.

_I'm not gonna put a picture here, you know what it looks like._

## Food

**Lifesum**

If you're into fitness like myself, calorie tracking is a must have for ensuring your body is getting the energy it needs to lose/gain weight.

There are two main apps which fight it out regularly for the best fitness app and those are [MyFitnessPal](https://www.myfitnesspal.com/) and [Lifesum](https://lifesum.com/).

I'm a [Lifesum](https://lifesum.com/) fan mainly because of their friendly UI and diet plans that they have on the app 🥗. But feel free to try both and see which one works best for your routine:

![Lifesum](../static/posts/automation-lifesum.jpg)

Price: £7 per month

**Eat This Much**

You don't just need to track your calories to be healthy. You also need to eat the right kind of food in the right amounts.

Adjusting recipes to fit those amounts is a chore, something I used to spend hours on each day. But thankfully [eatthismuch.com](https://www.eatthismuch.com/) has me covered.

[Eat This Much](https://www.eatthismuch.com/) is a web tool that generates meal plans based on your diet preference and calories needed per day. It works amazingly well as it keeps the recipes it generates simple and easy to make.

Here's an example of my Paleo meal plan:

![Eat This Much](../static/posts/automation-eatthismuch.png)

## Finance

If you haven't yet, read [I will teach you to be Rich](https://www.iwillteachyoutoberich.com/book/) by Ramit Sethi. This will teach you about Interest rates, Index Funds and automating your finances.

With that said, I use 3 apps to help me manage my finances:

**Monzo**

Not a day goes by where I don't want to move away from Monzo. Monzo for those outside the UK is challenger bank and is fully digital. You can open up sub accounts within your account to segment your money and manage direct debits etc straight from your phone.

One time saving killer feature is bill splitting. Simply tap on a transaction and choose your friends from your contacts and Monzo will split the bill evenly between you and your friends.

![Monzo](../static/posts/automation-monzo.jpg)

**Wealthsimple**

Index funds are a collection of the top performing stock in that current time. Index funds historically have risen for the last 100 years and are a great way to accumulate high interest on your money.

[WealthSimple](https://www.wealthsimple.com/en-gb/) is a service that auto-invests your money for you and reinvests any dividends back into that lump sum so it compounds over the years.

![WealthSimple](../static/posts/automation-wealthsimple.png)

**FreeTrade**

[FreeTrade](https://freetrade.io/) is an app that let's you trade from your phone and doesn't charge commission on buying/selling stocks. You can invest your money into Index ETFs, Bond ETFs and individual stocks.

![FreeTrade](../static/posts/automation-freetrade.png)

## Cosmetics

**Quip**

Having an electric toothbrush is paramount to a healthy dental hygiene. [Quip](https://www.getquip.com/) is a service that handles replacing your electric toothbrush head every 3 months by sending you a new head, battery and toothpaste.

Not only does this save me time but it also helps me look forward to brushing my teeth as the brush itself is beautifully designed as well:

![Quip](../static/posts/automation-quip.jpg)

Price: £7.65 every 3 months

**Harry's**

On the same vein as Quip, [Harry's] (https://www.harrys.com/en/gb) is a Razor company that every 3 months sends me replacement heads for my Razor.

What shocked me when I first tried Harry's is the quality of the Razor compared to my Gillette, it was noticeably sharper and the packaging even advised me to take it slower when I first used it.

![Harry's](../static/posts/automation-harrys.jpg)

Price: £14 every 3 months

**Asos**

I hate retail. I hate going around all the shops trying on clothes. With [Asos](https://www.asos.com/) you can shop a variety of different brands and get sizing recommendations based off your height, weight and preferred fit.

![Asos](../static/posts/automation-asos.png)

## Flow

**Headspace**

It's important to disconnect and refocus using meditation. [Headspace](https://www.headspace.com/) is the number one app for meditation and frankly it deserves it. It has lessons for each different thing you could want from NBA motivational meditations to sleep stories.

![Headspace](../static/posts/automation-headspace.jpg)

Price: £10 per month

**Tide.fm**

Natural music helps me concentrate and achieve flow with my work. I prefer to use [Tide](https://tide.fm/en_US/) over [Noisli](https://www.noisli.com/) as Tide offers way more custom sounds like instrumentals and nature sounds. [Tide](https://tide.fm/en_US/) also let's you set a timer for how long you want to focus for.

![Tide](../static/posts/automation-tide.jpg)

Tools I use to automate my life


[Outy](https://outy-app.herokuapp.com/) is an app I developed to help solve the problem of choosing places to meetup with friends.

It uses the [Foursquare API](https://foursquare.com/) to fetch venues based on the geocode the user inputs in the search box. I designed the search functionality to be Google-esque in a way. So you can filter down by location by typing: `[category] in [place]` (e.g: Bakeries in Watford).

The app is powered using my favourite stack:

* [Node / Express](https://expressjs.com/)
* [Mongoose](https://mongoosejs.com/)
* [EJS](https://ejs.co)
* [Cutestrap](https://www.cutestrap.com/)
* [Heroku](https://heroku.com/)

It may seem super boring but it's actually super productive to not have to setup React, Webpack etc to get an app out the door. Especially since this app is just searching for locations.

Here's a full list of features:

* Location / Category search: Bakeries, Cafes, Muesuems, Bars, Gyms etc
* Create Polls to help decide where to go out
* Select and save venues for later

![Adding venues with Outy](../static/posts/outy-poll.png)

1 Day Projects: Outy


I wrote this article back in 2016 and a lot has changed since. Because of this shift I have decided to remove certain sections that are no longer considered best practises or are based on ES5 APIs. Enjoy :)

## 1. Don’t use commas when declaring variables

The variables can now be easily moved around from line to line without having to worry about the commas.

```javascript
let a = 2,
  b = a + 2,
  c = b - 3;

let a = 2;
let b = a + 2;
let c = b - 3;
```

## 2. Move code into separate modules

Before:

```javascript
class Stock {
  checkItemIsInStock(item) {
    // logic
  }
}

class Basket {
  constructor() {
    this.stock = new Stock();
    this.items = [];
  }
  addToBasket(item) {
    if (this.stock.checkItemIsInStock(item)) {
      this.items.push(item);
    }
  }
}
```

After:

```javascript
import Stock from "./stock";
import Basket from "./basket";

const shoppingCart = new Basket(new Stock());
```

## 3. Utilize the Module pattern

The closure created by the [Immediately Invoked Function Expression (IIFE)](https://ultimatecourses.com/blog/mastering-the-module-pattern) allows privacy. E.g: The `privateMethod()` is only accessible by the inner `Basket` class:

```javascript
const Basket = (() => {
  // encapsulate a private function
  const privateMethod = () => true;

  class Basket {
    publicMethod() {
      privateMethod(); // use private methods
    }
  }

  return Basket;
})();
```

## 4. Comment your code

```javascript
/**
 * Creates a Point to be used in D3
 * @class Point
 * @example
 * new Point(2, 3);
 */
class Point {
  /**
   * @constructor
   * @param {number} x - The x value.
   * @param {number} y - The y value.
   * @returns {Point} new instance of Point
   */
  constructor(x, y) {
    // ...
  }
}
```

This allows developers to get a deeper understanding of what is happening in your code without having to figure it out from the code. If you use [JSDOC](http://usejsdoc.org/about-getting-started.html) the comments can be used to generate online documentation guides.

## 5. Learn design patterns

- [The Observer pattern](http://www.dofactory.com/javascript/observer-design-pattern) helps your modules communicate to each other through events thus providing loose coupling in your app.

- [The Mediator pattern](http://www.dofactory.com/javascript/mediator-design-pattern) takes control over a group of objects by encapsulating how these objects interact. E.g: a basket that handles items.

- [The Iterator pattern](http://www.dofactory.com/javascript/iterator-design-pattern) is the underlying pattern for ES2015 generators.

- [The Facade pattern](http://www.dofactory.com/javascript/facade-design-pattern) provides an simple interface which encapsulates the end user from complex functionality. E.g: Email module with simple methods such as start, stop and pause;

Not only are these solutions to commonly solved problems, they are a way of describing application structure to other developers fairly simply. E.g: _“The basket module is a mediator for all the store items, it communicates to the payment module via an observer”_.

## 6. Pass objects into functions with a large number of arguments

```javascript
// not so good
function colorWidget(
  element,
  colorValue,
  colorRange,
  colorFormat,
  opacity,
  onChange
) {}

colorWidget($("<div/>"), "#fff" /*...*/);

// way better
function colorWidget({
  element = $("<div/>"),
  colorValue = "#000",
  colorRange = [0, 255],
  colorFormat = "rgb",
  opacity = 0.8,
  onChange = () => {}
}) {
  // ...
}
colorWidget({
  element: $("<div/>")
});
```
1. Simple to add new options
2. The developer doesn’t have to worry about the order of the arguments
3. Simple to add default values

## 7. Don’t use type constructors unless specifically necessary

```javascript
// Before
const x1 = new Object();
const x2 = new String();
const x3 = new Number();
const x4 = new Boolean();
const x5 = new Array();
const x6 = new RegExp("()");
const x7 = new Function();

// After
const x1 = {};           
const x2 = "";           
const x3 = 0;            
const x4 = false;        
const x5 = [];           
const x6 = /()/;         
const x7 = function(){};
```

The creation through type constructors is significantly slower than primitives. Also because the end result of the constructor is an `Object` rather than a primitive value you get [nasty side effects](http://stackoverflow.com/questions/5750656/whats-the-point-of-new-stringx-in-javascript) like so:

```javascript
const a = new String("x");
a === "x"  //false
a == "x" //true

const b = "dog";
b.woof = true;
b.woof; // undefined

const c = new String("dog");
c.woof = true;
c.woof; // true
```

## 8. Make sure your context is right

```javascript
class Button {
  constructor () {
    this.count = 0;
  }
  click () {
    this.count += 1;
  }
  init () {
    $("button").click(this.click);
  }
}
```

From a glance this should work however when a user clicks the button we will get an error that count doesn’t exist. This is because the click function is executed in the context of the `$("button")` element instead of the `Button` object. We can fix this by binding the context to the function:

```javascript
class Button {
  constructor () {
    this.count = 0;
  }
  click () {
    this.count += 1;
  }
  init () {
    $("button").click(() => this.click());
    // or using bind
    $("button").click(this.click.bind(this));
  }
}
```

## 9. Apply

> The `apply()` method calls a function with a given this `value` and `arguments` provided as an array (or [an array-like object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects)). — MDN

Some useful instances of using apply:

```javascript
// emulating "super" in an constructor 
SomeConstructor.prototype.somemethod.apply(this, arguments);

// passing an array of promises to jQuery.when
$.when.apply($, [$.get(), $.get()]);

// finding the max number in an array
Math.max.apply(Math.max, [1,2,3,4,5]);
```

## Bonus Points

Contributed by: [Russley Shaw](https://medium.com/@russleyshaw)

## 10. Use let and const over var

`let` allows you to declare variables that are limited in scope to the block, statement, or expression on which it is used.

Lets look at a few use cases where this is useful over `var` statements:

```javascript
var elements = document.querySelectorAll('p');
for (var i = 0; i < elements.length; i++) {                                 
    // have to wrap in IIFE other i would be elements.length
    (function(count){  
       elements[count].addEventListener('click', function(){
           elements[count + 1].remove();
       });
     })(i);
}

// using let
let elements = document.querySelectorAll('p');
for (let i = 0; i < elements.length; i++) {
   elements[i].addEventListener('click', function(){
        elements[i + 1].remove();
   });
}
```

The reason why the top example would be `elements.length` is because `i` is referenced directly so on the next iteration `i` is incremented. When we wrap the code in an IIFE we reference `i` under the parameter `count` thus removing the direct reference.

`const` allows the declaration of variables that cannot be re referenced. This is useful for declaring constants (the keyword originates from it).

```javascript
const API_KEY = '2rh8ruberigub38rt4tu4t4';
const PI = 3.14;
```

However objects and arrays can still be accessed and changed. To stop this use `Object.freeze()`:

```javascript
const API_CONFIG = Object.freeze({
  'key': '8ry4iuggi4g38430t5485jmub',
  'endpoint': '/some/boring/api/path/'
});
API_CONFIG.key = null; // attempt to change
API_CONFIG.key; //= '8ry4iuggi4g38430t5485jmub'

const EVENS = Object.freeze([ 2, 4, 6, 8]);
EVENS[2] = 9;
EVENS[2]; //= 6
```

## 11. Avoid using “or” when referencing variables

The only reason to avoid doing this is when the variable is allowed to be `false` . Take a look at the example below:

```javascript
let msg = ''; //= should hide the button
let btnMsg = msg || 'Click Me';

btnMsg; //= 'Click Me'
```

The reason this happens is due to the conversion of the `"”` into a Boolean which returns false . As the `"”` is counted as `false` the `or` comparison returns the other side `'Click Me'`.

If you want to have shorthand if statements you can use the ternary operator:

```javascript
var msg = ''; //= should hide the button
var btnMsg = msg.length < 5 ? msg : 'Click Me';

btnMsg; //= ''
```

9 ways to level up your JavaScript code


I wrote this article back in 2016 and a lot has changed since. Because of this shift I have decided to remove certain sections that are no longer considered best practises or are based on ES5 APIs. Enjoy :)

Interfaces are great for when you need to enforce some rules about how a developer builds a class. For example we have a Form class, this class is composed of lots of Fields/Inputs. Instead of writing logic to handle all different types of inputs we can define a common interface between them all.

Our Interface will contain a `render()` method to render out the input and a `value()` method to get the input’s value.

```javascript
const required = () => {
  throw new Error("Implement!");
};

class InputInterface {
  render = required;
  value = required;
}
```

We can apply the Interface to a Base Input class so that all of our derived classes have the Interface.

```javascript
class Input extends InputInterface {}
```

Now whenever you call `render()` you will get an Implementation Error. This forces the developer to override the Base class’s methods. Thus you have forced them to implement the interface.

```javascript
class Checkbox extends Input {
  constructor () {
    this.$el = $("<input/>", { type: "checkbox" }); 
  }
  render () {
    return this.$el;
  }
  value () {
    return this.$el.prop("checked");
  }
}
```

Quick Guide to using interfaces with JavaScript


I spend a lot of my time developing new reusable UI components.

This means during development I tend to extract UI components that are placed in a shared library or styleguide. These components are reused throughout the entire project. Often having different styles or layouts when integrated into features.

Along the way I learnt a few rules that helped me save time and pain.

## 1. Keep the layout fluid

I can’t count the amount of times a component has had a fixed width and that has affected a responsive design. Meaning I have to go in and fiddle with the existing props that was set up in place for another feature somewhere in the site. Not good.

By keeping the component 100% width you pass the layout responsibility up to the parent component.

For example it’s a lot easier to use `CardOne` over `CardTwo`. As `CardOne` will respond to the parent's column changes when the screen size changes.

```javascript
const CardOne = ({ title }) => (
  <div style={{ 
    padding: "20px 30px", 
    background: "white" 
  }}>{title}</div>
);

const CardTwo = ({ title }) => (
  <div style={{ 
    width: 600, 
    padding: "10px",
    background: "white" 
  }}>
    {title}
  </div>
);

const App = () => (
  <div className="row">
    <div className="col-md-6">
      <CardOne title="I'm Fluid" />
    </div>
    <div className="col-md-6">
      <CardTwo title="I will break this layout" />
    </div>
  </div>
);
```

## 2. Allow extra props to be passed

Turns out that your Button component needs a specific data attribute to work with the library you’re using for one of the specific features. Too bad that the `Button` component only allows `className`, `children` and `onClick`.

How can we fix this?

[Modern ES6 JavaScript allows you to spread function parameters and objects.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax) This can be used to feed props to components.

```javascript
// Before -> <button className="button">Click me</button>

const Button = ({ children, className, onClick }) => (
  <button 
    onClick={onClick} 
    className={`${styles.button} ${className || ""}`}>
    {children}
  </button>
);

// After -> <button className="button" data-theme="dark">Click me</button>

const Button = ({ className, ...props }) => (
  <button 
    className={`${styles.button} ${className || ""}`} 
    {...props} />
);

// Example

const App = ({ onActivate }) => (
  <SpecificFeature>
    <Button data-theme="dark" onClick={onActivate}>
      Click me
    </Button>
  </SpecificFeature>
);
```

## 3. Push logic upwards / Keep it dumb

One of the top things that prevents reusability is when stateful logic specific to a feature is implemented within a reusable component.

Imagine you have a `Dropdown` component. That you have used in your navigation when a link is clicked.

```javascript
const DropdownItem = ({ className, ...props }) => (
  <li className={`dropdown-item ${className || ""}`} {...props} />
);

class Dropdown extends React.Component {
  state = { toggled: false };
  toggle = () => this.setState(state => ({ toggled: !state.toggled }));
  render() {
    return (
      <div className="navbar-link">
        <span onClick={this.toggle}> {this.props.title} </span>
        {this.state.toggled && (
          <ul className="dropdown"> {this.props.children} </ul>
        )}
      </div>
    );
  }
}

const Navbar = () => (
  <div className="navbar">
    <div className="navbar-brand">Example</div>
    <ul className="navbar-menu">
      <Dropdown title="My Account">
        <DropdownItem>One</DropdownItem>
        <DropdownItem>Two</DropdownItem>
      </Dropdown>
    </ul>
  </div>
);
```

The problem above is:

1. `Dropdown` handles the logic for opening and closing the dropdown. Making it a lot harder to reuse `Dropdown` for more complicated scenarios (e.g: only open the dropdown when a request is successful).

2. `Dropdown` has markup that relates to the `Navbar` component.

If we refactor the `Dropdown` component to push the logic up. We end up with a much more reusable `Dropdown` component.

```javascript
const DropdownItem = ({ className, ...props }) => (
  <li className={`dropdown-item ${className || ""}`} {...props} />
);

const Dropdown = ({ className, ...props }) => (
  <ul className={`dropdown ${className || ""}`} {...props} />
);

class Navbar extends React.Component {
  state = { showUserOptions: false };
  
  toggleOptions = () => {
    this.setState(state => ({
      showUserOptions: !state.showUserOptions
    }));
  }

  render() {
    return (
      <div className="navbar">
        <div className="navbar-brand">Example</div>
        <ul className="navbar-menu">
          <div className="navbar-link">
            <span onClick={this.toggleOptions}>My Account</span>
            {this.state.showUserOptions && (
              <Dropdown>
                <DropdownItem>One</DropdownItem>
                <DropdownItem>Two</DropdownItem>
              </Dropdown>
            )}
          </div>
        </ul>
      </div>
    );
  }
}
```

## Summary
* Keep the component layout fluid.
* Allows extra props to be passed into the component.
* Keep logic out of them as much as possible.

The rules of reusable components


Separating logic from your presentation has always been a best practise. It enforces the [single responsibility principle (SRP)](https://en.wikipedia.org/wiki/Single_responsibility_principle) and makes the code easier to test.

React however gets in trouble for letting developers mush the two concerns together with ease. Lets take an example from the [homepage](https://reactjs.org/) to explain:

```javascript
class Timer extends React.Component {
  constructor(props) {
    super(props);
    this.state = { seconds: 0 };
  }
  tick() {
    this.setState(prevState => ({ seconds: prevState.seconds + 1 }));
  }
  componentDidMount() {
    this.interval = setInterval(() => this.tick(), 1000);
  }
  componentWillUnmount() {
    clearInterval(this.interval);
  }
  render() {
    return <div>Seconds: {this.state.seconds}</div>;
  }
}
```

Above you can see the rather simple Timer class. You can also see the display logic for the class is coded right into the `render()` method.

The problem with having `<div>Seconds: {this.state.seconds}</div>` in the `Timer` class is that it’s not separating logic from presentation.

Lets separate the two concerns:

```javascript
const SecondsActive = ({ seconds }) => <div>Seconds: {seconds}</div>;

class TimerContainer extends React.Component {
  state = { seconds: 0 };
  tick() {
    this.setState(({ seconds }) => ({ seconds: seconds + 1 }));
  }
  componentDidMount() {
    this.interval = setInterval(() => this.tick(), 1000);
  }
  componentWillUnmount() {
    clearInterval(this.interval);
  }
  render() {
    return this.props.view({ seconds: this.state.seconds });
  }
}

ReactDOM.render(
  <TimerContainer view={SecondsActive} />,
  document.getElementById("app")
);
```

With a simple switch to rendering via a prop we have made the `Timer` class reusable across many presentational components and have made the presentational component super easy to test!

Utilise render props in React


> Don’t reinvent the wheel, just realign it. — Anthony J. D’Angelo

Note from the author:

_I wrote this article back in 2016 and a lot has changed since. Because of this shift I have decided to remove certain sections that are no longer considered best practises or are based on ES5 APIs. Enjoy :)_


## It is the small things that count

Small problems are usually overlooked by the developer, I myself have rushed and wrote sloppy functions as I had lack of care for the smaller problem.

An example of rushing:

```javascript
$("button").click(() => {
  const heading = $("h1").text();
  const capital = heading[0].toUpperCase() + heading.slice(1);
  $("h1").text(capital);
});
```

How can we improve this? Right away we can pull out the entire function so it is no longer an anonymous function which allows us to reuse this block of code:

```javascript
const capitalizeHeading = () => {
  const heading = $("h1").text();
  const capital = heading[0].toUpperCase() + heading.slice(1);
  $("h1").text(capital);
};

$("button").click(capitalizeHeading);
```

Lets make this even more useful and extract the capitalizing logic:

```javascript
const capitalize = (word = "") => word[0].toUpperCase() + word.slice(1);

const capitalizeHeading = () => {
  const heading = $("h1").text();
  $("h1").text(capitalize(heading));
};

$("button").click(capitalizeHeading);
```

Now we can reuse the capitalizing logic across our program.

Did you know that [jQuery constructs a new Object and queries the DOM every time you call `$(<selector>)`?](https://github.com/jquery/jquery/blob/master/src/core.js#L34). We should cache jQuery objects in order to speed up execution times:

```javascript
const capitalize = (word = "") => word[0].toUpperCase() + word.slice(1);

const capitalizeHeading = () => {
  const $h1 = $("h1"); // cache h1 in a variable
  $h1.text(capitalize($h1.text())); // reuse without creating
};

$("button").click(capitalizeHeading);
```

`capitalizeHeading()` is okay for this one use case but it would be much more useful if it accepted a parameter to indicate what elements to capitalize:

```javascript
const capitalize = (word = "") => word[0].toUpperCase() + word.slice(1);

const capitalizeElement = element => () =>
  element.text(capitalize(element.text()));

$("button").click(capitalizeElement($("h1")));
```

We can also wrap the execution in another function in order to create a partial. This is a function which has its arguments preloaded before execution, in this case we have made the element parameter a `$(“h1”)`.

Turning `capitalizeHeading` into `capitalizeElement(<element>)` allows us to reuse that function for any element we wish to capitalize:

```javascript
capitalizeElement($("h2"));
capitalizeElement($("div[data-title]"));
```
