This post assumes that a Firebase project has been setup with Google Analytics enabled.

To be able to debug Firebase events in Swift apps, Firebase requires certain arguments to be passed when running the app. The details are available in the Firebase docs.

In xcode, the -FIRDebugEnabled option has to be added to the Scheme that is being used to build the app.

1. In the area where you see the current scheme and the device/simulator used to run the app, click on the scheme to reveal a menu with the option to edit the scheme.

2. Find the “Run” option in the sidebar for the Debug release.

3. Find the “Arguments” tab in this window.

4. Add -FIRDebugEnabled as the arguments to be passed for launch. The hyphen is important :)

Testing Firebase events

Firebase events can be tested on the Google Analytics project connected to Firebase. Login to Google Analytics and find the Google Analytics property associated with the Firebase project.

In the Google Analytics property, under the admin panel, find the Data Display menu option, and then the Debug View under it.

Run your app in xcode, either in a simulator or an iOS device. While you use the device, the events should show up in the Google Analytics debug view.

Important: The events are only logged in the Debug View when the app is run via xcode.

The latest version of the SDK as of this guide is 0.2.5. This guide should work for both iOS and macOS since the AWS libraries are said to be platform agnostic.

Adding the SDK to a Swift project

To add the package to the project in XCode, use the Add Packages option in the File menu. In the window that appears, enter the GitHub URL of the project to discover AWS packages.

https://github.com/awslabs/aws-sdk-swift

When prompt appears asking to choose the libraries to add, take your pick. For this example, we will be using the “CloudWatch Logs” client.

Ensure build targets have dependencies

I created a universal app and the dependencies were added only to the iOS app. It would be good to open the project window on XCode and check that the dependencies are listed for each of the targets.

My project has macOS and iOS as targets and I’ve ensured that the dependencies are in both. This section in the latest version of XCode is called “Frameworks, Libraries and Embedded Content”. If the libraries are missing, click on the plus sign and add them.

Import the libraries

As you type in class names, XCode would automatically suggest the libraries to import. So do not bother much about finding these manually for the libraries that you use. These are the XCode suggested imports for my code (and they work as expected 😃).

import AWSCloudWatchLogs
import AWSClientRuntime

Create a Credentials Provider config

All clients for the AWS Services in the SDK require a “credentials provider” object to be passed as input. This is just a fancy label for any kind of AWS credentials.

The most common credentials are the AWS Access Key and AWS Secret Key. the below snippet creates a new object with the relevant credentials.

let aws_config = AWSCredentialsProviderStaticConfig(
    accessKey: "REPLACE_THIS",
    secret: "REPLACE_THIS"
)

Create a client for the AWS Service

The next bunch of steps

1. Create a config for the client we need (CloudWatch Logs in this case).
2. Use the config to create a client for the AWS Service.

let client_config = try CloudWatchLogsClient.CloudWatchLogsClientConfiguration(
    region: "us-west-2",
    credentialsProvider: AWSCredentialsProvider.fromStatic(aws_config)
)

let client = CloudWatchLogsClient(config: client_config)

Make a request to fetch log groups

Payload for requests to AWS services are organized as input structs for different operations. For this operation, our input struct is DescribeLogGroupsInput. We do not have any special options to pass, so this will be an empty struct.

Our helper method is actually describeLogGroups according to the docs. If we did that the result would be available as response.logGroups. The snippet below has a bit more magic.

The “Paginated” helper

Most AWS SDKs now have auto-pagination. If we used describeLogGroups and there was more than one page of values, then the API response would include the first page of values, along with a pageToken as a reference to the net page to query.

If we used the describeLogGroupsPaginated function, then the SDK makes requests to fetch all values across pages in a loop (on-demand, you’ll see below). This is implemented with Swift’s new AsyncSequence protocol (WWDC 2021 video)

let response = client.describeLogGroupsPaginated(
  input: DescribeLogGroupsInput()
)

To print the responses, we could use a loop.

// Each item in the response would be a page of values.
// So we loop again to print each log event.
//
for try await page in response {
    if let logGroups = page.logGroups {
        for logGroup in logGroups {
            print("--- Received log line ---")
            print(logGroup)
        }
    }
}

AFAIK, any helper function in the AWS SDK that lists values/paginages would support another helper with the “Paginated” suffix like above.

The final piece

As our code has a few areas that might throw errors, we wrap all of it in a do-catch block for now.

do {
    let client_config = try CloudWatchLogsClient.CloudWatchLogsClientConfiguration(
        region: "us-west-2",
        credentialsProvider: AWSCredentialsProvider.fromStatic(aws_config)
    )
    let client = CloudWatchLogsClient(config: client_config)

    let response = client.describeLogGroupsPaginated(
      input: DescribeLogGroupsInput()
    )
    
    print("Printing output...")
    for try await page in response {
        if let logGroups = page.logGroups {
            for logGroup in logGroups {
                print("--- Received log line ---")
                print(logGroup)
            }
        }
    }
    print("-#-#- Call to AWS complete")
} catch {
    print("AWS init error")
}

Next steps

I have not yet tried to call a helper function that creates/destroys resources. So this post does not have any examples on how to handle the response for that. Will update this post in the future.

On Cloudflare Tunnels, tunnels with permanent domains are free. This is a good because it makes working with or debugging webhooks with local apps very easy.

Install cloudflared

Install cloudflared with homebrew like below or checkout install instructions for other operating systems)

brew install cloudflare/cloudflare/cloudflared

Start a tiny web server to test

Create and start a tiny web server to tryout cloudflared.

mkdir tunnel-tryouts && cd tunnel-tryouts
echo "<html><h1>Hello Cloudflare Tunnel</h1></html>" > index.html
python3 -m http.server

The website we just brought up should be accessible at http://localhost:8000/

The output should look something like below.

Start a Cloudflare Tunnel

To make this available to the world, run the cloudflared command by passing the url of the website as an argument.

cloudflared tunnel --url http://localhost:8000/

The output should look like something below. The tunnel url is also provided in the output. Hit the tunnel url and the website should be accessible to the world.

Running tunnels with permanent domains or subdomains

This requires a domain on your Cloudflare account that you can use for the tunnel.

Login to Cloudflare and authorise use of one of the domains

cloudflared tunnel login

You will be prompted to authorize one of your domains to use for your tunnels. Pick one and that completes the setup.

Start a tunnel with the required domain or subdomain.

I am using one of my domains to play with.

cloudflared tunnel --hostname myapp.define.run --url http://localhost:8000

The website should now be accessible at the desired subdomain 😃

This post is in response to a Hacker News thread about being slow to produce work.

The kind of person the author seems to envy in the post are people who are most likely pattern-matching against past experience. I attribute this quick thinking to having come across those same/similar problem statements earlier. But getting there requires a good understanding of the problem space. This can only be done by spending time in the problem space and paying attention to details.

When working on a new problem these days. I feel like I slow down too. I now tend to go for the details. What I cannot make up in speed, I make up for with detailed solutions, thinking from the user’s perspective, staying aware of trade-offs, watching out for unhandled scenarios, etc.

I also document all my work. Whenever I start working on a problem/ticket/issue, I create a new note in my personal note-taking tool. I document the commands, the new findings, etc.

Fun fact: For a limited time, I fulfilled the role of a Product Manager at my recent workplace. The engineers I worked with loved the amount of detailing in my product specifications. This was the result of slowing down and paying attention to the details. The above qualities/choices also resulted in me playing the implicit role of QA for the team. The concept of “implicit roles” is explained pretty well in this blog post on the StaySassy blog.

I try to compensate my slowness with attention to detail, clear communication and better documentation.

Attention to detail is as good a quality as quick thinking. I like this way better.

Ask to know more about product & roadmap

Use this information to understand/guesstimate if the company has the potential to increase revenue.

Ask for a product demo

• Getting to know the product in detail helps.
• Also ask for login credentials for a test account to play with.

What is the product roadmap?

• How do items get into the roadmap and how do they get prioritized?
• To check if the product development is stagnant. Busy work is bad work.

Who are the target customers now? Is the company planning to focus on other cohorts of customers?

• Use this to check/guess the possible size of market using other sources.
• For example: If target customers are small businesses that sell clothing, find other industry reports that offer insights/numbers for potential market size that this company can possibly grow to serve.

What was last year’s product roadmap and what was worked on last year?

• Helps to know how often the company changes priorities.
• If priority changes are too often, then focus gets scattered for product engineering.

It is very important to understand that product development can be a hit or miss during the early stages of a company. So some things might be in flux. Just not everything can be in flux.

Special note: Frequently changing roadmap

If the product roadmap is changing frequently (quarter/half-yearly) in major ways or if there is frequent reprioritisation, then it means there are too many conflicting sub-purposes within the organization. There can be many reasons, some mentioned below.

• Selling to bad-fit customers: A lot of deals require customization that forces trading-off already planned roadmap items. These customizations are very good if they are reusable - means sales is able to utilize the customizations to sell to more customers that need these. These trade-offs come at the cost of product stability. The more code written for specific customers, the larger and unmaintainable the code-base becomes. This in turn leads to increased technical debt and slower development.
• Lack of Product-Market fit: Company scaled to $X in revenue selling to a cohort of customers. But new cohort of customers require a bunch of other features that do not exist today.
• Lack of focus to iterate/improve existing functionality: This happens as a result of focusing too much on building new things.

Find out about plans for the role being hired for

What will be the responsibilities of the role for the first year?

• Based on responsibilities of the role and the product roadmap, decide if the role being hired for is important enough for you to work and grow there.
• For example, if being hired for as a Mobile Engineer and mobile apps are low on the roadmap, then the role is likely to be at risk in the near future after the project is done.
• If the company cannot list out work for at least a year, then the company is better-off hiring a contractor for this role instead of a full-time employee.

What are the expected responsibilities next year?

• Check to know if anyone has at least given some thought to a career growth map for this role.
• For example: I join as a Support Engineer. Is this a dead-end role? Does the organization expect that I work this role for more than two years? How am I going to grow?

Does the organization help employees upskill?

• Access to learning resources, conferences, etc)
• As an employee, I am going to spend significant amount of time working for the organization. Does the organization help me upskill in some ways?

Are there enough supporting functions for the role to succeed?

• For example: For a mobile engineer position, is the product line important? Is there a product manager assigned?

Ask details to understand ESOPs better

Someone I know articulated it better: “Salary is for today’s work. ESOPs are for stickiness”. Stickiness is what encourages an employee to stay invested in the company rather than switching workplaces after a year.

The below details are good to discuss/ask on a call, but also ensure to get these on an email to keep these on record.

What is the current FMV of the share, the Exercise Price and the total number of shares in the pool?

• ESOPs are “alloted” to you by the company at regular intervals. This is like “permission to buy”. To own these, you must buy them at an exercise price.
• People with ESOPs make money when the company is sold or goes for an IPO. To know what you would make as a “profit” in this sale, you must know the price you are allowed to buy at. This is the exercise price (or the strike price).
• You may be offered an exercise price at a discount compared to the actual market value of the share. This market value of the share is the Fair Market Value (FMV).
• FMV cannot be a random number based on what someone feels - companies generally do a 409A valuation with an auditor.
• To aid in understanding valuation, also find out total number of shares in the pool. Useful to know, what percentage you are being assigned. Check common practices for early employees and the value you might add.
• Read up on why FMV and Exercise Price are important to know. There is already a lot of literature on this.

Based on the roadmap, the market size and the competition, if you think the company will increase revenue (say 4x or 10x) in the next few years, then use these numbers to see what your upside or financial gains will be. Ofcourse there might be dilution, liquidation preferences, etc, when the company raises a round of funding. But knowing these numbers atleast gives you information to guess ballpark numbers of what you would make as a financial gain.

Does the company provide liquidity opportunities for employees?

• ESOPs are good. But if there is no way to liquidate them to cash, then the ESOPs are worth paper-money and useless. Find out what are the company’s plans for offering liquidity to employees with ESOPs.
• When was the last liquidity opportunity and who was it offered to? (Example: Employees that stayed for 2yrs, 4yrs, etc).

Does the company offer ESOPs with a 10-year exercise window?

• Guideline: Workplaces that have an exercise window of 30-90 days is a red-flag.
• If you quit the company after 2yrs, all the shares you vested must be exercised within the “exercise window” after you quit (say 30-90 days depending on the company’s policy). Else you forfeit the right to purchase the alloted shares.
• This is bad because employees might not have the cash to purchase an asset (company shares) that do not have liquidity and comes with an unknown probablity of making a profit.
• This is also bad because if you work for a company in a geography that has to adhere to “Perquisite tax” mentioned above, then you also have to pay the tax on the paper-profit that you have not yet made.
• Having a long exercise window of 10 years is a good thing, because after the employee feels his potential/peak at the company is past, they have the oppurtunity to move on and still have 10 years to exercise the vested shares depending on the potential upside.
• 10-yr exercise window is a good expectation to have. Anyone saying otherwise is probably BS-ing you. Give it a thought - do you expect to work at the same workplace for 7 years or are you more likely to get bored?
• Check companies offering that.

Special mention: Perquisite tax on ESOPs in India

• The “Perquisite Tax” means that if you are exercising (buying) shares at a lower than market value (FMV), then you have to pay tax on the difference (the notional profit).
• This government counts this as profit you have made because you purchased an asset of higher value for a cheaper price. The absolutely bonkers fact: This only applies to ESOPs.

Special mention: ESOPs as golden hand-cuffs

• ESOPs are called “golden handcuffs” for a reason. If you cannot afford to exercise the shares you have vested, the fear of not missing out on the potential profit would prevent you from quitting.
• Being able to afford to exercise large ESOPs with uncertain liquidity is a luxury that employees cannot afford in certain geographies. Especially in India, there is a “Perquisite Tax” to be paid on the ESOPs during exercise.

Checkout this Twitter thread

Special mention on ESOP buybacks

Nithin Kamath’s tweet - read his entire Twitter thread.

Other details

Does the company have an Employee Stock Purchase Plan? (applies to public companies only)

• What are the details of the ESPP?
• If the employer is a public company, they can help you purchase listed shares at a discounted price.

How many leaves do employees get per year?

• Are employees allowed to carry-forward unused leaves?
• Unlimited leaves are BS. Get an absolute number that employees are allowed per year.
• Check for maternity & paternity leaves. You may not be expanding your family. But this is an indicator of compassion.

Does the company work remote? How does the team collaborate?

• If remote work is what you want, check about it.
• What are the expected work hours? If you are uncomfortable with frequent meetings outside of your preferred/usual work hours, check about that too.
• Choosing a timezone for a globally distributed organization is acceptable. But internal meetings being setup always/frequently in a particular timezone is being biased and is a red-flag indicating not respecting personal time.

Is the company providing you with necessary tools?

• If you have to go through a week of approvals & discussion to buy a $29 tool for your team, it means the company isn’t seeing value in what you are doing.

Finale

What if you join the company and find out that the company lied about certain details?

Sunk cost. Find a new workplace immediately.

What if the potential employer is not willing to reveal details?

• They’ll find another engineer. You find another workplace.
• You are going to spend a significant part of your time/life working at this place. If you do not have enough details to judge the workplace, skip the workplace. This will save you some ache in the long run.

I spent time a few years at a workplace without these details. What to do?

• Talk to someone at your workplace and ask for these details.
• If details are still unclear after talking to an appropriate person, then probably consider it sunk cost, so find a new workplace.

These notes were taken when making some changes for cncf/cnf-testsuite. I had to understand the options being used with the tar command before making the changes.

These commands work fine on linux. But if on Mac, install gnu-tar with brew to get these commands working as expected.

Extract and compress

# hello is a directory
$ ls .
hello tryouts somedir

# Compress
$ tar czvf hello.tar.gz hello

# Change to a directory to experiment
$ cd tryouts && mv ../hello.tar.gz .

# Extract
$ tar zxvf hello.tar.gz
$ ls
hello

# Cleanup
$ cd .. && rm -rf tryouts

Change directory when compressing

# hello has two directories
$ ls hello
world greeting

# Compress, with change directory option
$ tar czvf hello.tar.gz -C hello .

# Change to a directory to experiment
$ cd tryouts && mv ../hello.tar.gz .

# Extract
$ tar zxvf hello.tar.gz
$ ls
hello.tar.gz world greeting

# Notice magic? No parent directory when extracting

Compress only select directories/files

# hello has two directories
$ ls hello
world greeting

# Compress, with change directory option and select world dir only
$ tar czvf hello.tar.gz -C hello world

# Change to a directory to experiment
$ cd tryouts && mv ../hello.tar.gz .

# Extract
$ tar zxvf hello.tar.gz
$ ls
hello.tar.gz world

# See? No greeting dir because we did not compress it

When using the aws-cdk Lambda docs and examples, the code for the Lambda function is fetched by lambda.Code.fromAsset() This is from a local directory within the cdk project and works as expected because the cdk is able to calculate a hash of the files to detect a change in the code.

My GitHub Actions workflow was pushing zip files to S3 containing the code for the Lambda functions. This meant that I use lambda.Code.fromBucket.

Something like this:

// bucket is of type Bucket construct from aws-cdk/aws-s3 package.

// This is path of the release zip file in s3.
const releaseFileKey = "my-function/latest.zip"

const fn = new lambda.Function(this, 'MyFunction', {
  runtime: lambda.Runtime.NODEJS_14_X,
  handler: 'handler.hello',
  code: lambda.Code.fromBucket(bucket, releaseFileKey)
})

cdk would not detect updates to the lambda function. There are some notes in the cdk documentation that mentions passing the version options to inform cdk that an update is being made.

I was looking for a mechanism to be able to pass the version of the lambda function to deploy, to the cdk deploy command. I definitely do not want to be updating the s3 release file name in the stack definitions manually everytime I want to deploy.

I stumbled upon CfnParameters. This can be used to pass parameters to the cdk on the command line.

I made some code changes to read releaseFileKey using CfnParameter. Here is how I would pass the release file key in the command line.

$ cdk deploy MyAppStack \
    --parameter MyAppStack:releaseFileKey=my-function/3badf1b7.zip

Nope - that did not work. The Lambda function still wasn’t being updated when I passed a new file key that included the git commit SHA in the file name. When I opened the CloudFormation templates in cdk.out dir, I noticed that the places where I was expected to see the release file key, there was something like {"ref": "releaseFileKey"}.

I learnt that these CfnParameters are CloudFormation parameters that are injected during deploy time. The CloudFormation templates generated by cdk would always have placeholders for these parameters and therefore the cdk would not detect any changes to deploy.

Solutions that worked

Option-1: Read the S3 file key from environment variables

const fn = new lambda.Function(this, 'MyFunction', {
  runtime: lambda.Runtime.NODEJS_14_X,
  handler: 'handler.hello',
  code: lambda.Code.fromBucket(bucket, process.env.RELEASE_FILE)
})

Run the diff command now and you’ll notice cdk is detecting changes to the stack and will update the Lambda function.

RELEASE_FILE="my-function/3badf1b7.zip" cdk diff --all

Option-2: Add the code version as an env var that is passed to the Lambda function

Incase your S3 file name always remains the same, then the other option is to pass some environment variable to your Lambda function that always changes when your code changes.

The easy way is to pass the git commit SHA like below.

const fn = new lambda.Function(this, 'MyFunction', {
  runtime: lambda.Runtime.NODEJS_14_X,
  handler: 'handler.hello',
  code: lambda.Code.fromBucket(bucket, "my-function/latest.zip")
  environment: {
    GIT_VERSION: process.env.RELEASE_VERSION
  }
})

And then pass the env var to the diff or deploy commands like this.

RELEASE_VERSION="3badf1b7" cdk diff --all

Option-3: Pass version options to lambda.Function

You can also pass the version options to lambda.Function like below. But it is required that you access the currentVersion property after the lambda function is declared. This ensures that the version is output to the CloudFormation template. Notice the last line in the snippet below.

If you notice below, the snippet still reads the release version from an env var.

const fn = new lambda.Function(this, 'MyFunction', {
  runtime: lambda.Runtime.NODEJS_14_X,
  handler: 'handler.hello',
  code: lambda.Code.fromBucket(bucket, "my-function/latest.zip")
  currentVersionOptions: {
    codeSha256: process.env.RELEASE_VERSION
  }
})

fn.currentVersion

Try running the cdk diff or deploy commands with RELEASE_VERSION env var.

RELEASE_VERSION="3badf1b7" cdk diff --all

First step: Install qmk

For Mac OS, using homebrew for installation.

brew install qmk

Install some dependencies using this doc as a reference

Setup QMK using the below command. This will download the QMK firmware for you and if required install any dependencies. On my Mac and this took about 5min.

qmk setup

The output should look like this - along with some git clone to clone the repo. (This is the output when qmk setup is run for the second time).

$ qmk setup
Ψ Found qmk_firmware at /Users/hashnuke/qmk_firmware.
Ψ QMK Doctor is checking your environment.
Ψ CLI version: 0.2.0
Ψ QMK home: /Users/hashnuke/qmk_firmware
Ψ Detected macOS 11.3.1.
Ψ All dependencies are installed.
Ψ Found arm-none-eabi-gcc version 9.3.1
Ψ Found avr-gcc version 8.4.0
Ψ Found avrdude version 6.3
Ψ Found dfu-util version 0.10
Ψ Found dfu-programmer version 0.7.2
Ψ Submodules are up to date.
Ψ QMK is ready to go

Create new keymap

My keyboard layout is going to be based on the default Preonic rev3 layout. I identified this name from the list of keyboards from QMK configurator

qmk new-keymap -kb preonic/rev3

The output should look like below:

$ qmk new-keymap -kb preonic/rev3
Keymap Name: hn-preonic
Ψ hn-preonic keymap directory created in: /Users/hashnuke/qmk_firmware/keyboards/preonic/keymaps/hn-preonic
Ψ Compile a firmware with your new keymap by typing:

  qmk compile -kb preonic/rev3 -km hn-preonic

Within the directory mentioned above in the output, I made the following changes.

Enable Tap Dance

Enable Tap Dance in rules.mk file

TAP_DANCE_ENABLE = yes

Define tapping interaval in config.h file

#define TAPPING_TERM 175

Define tap dance functionality in keymap.c

Add this snippet right below the include statements. What I’ve done is make the escape key behave like control if double-tapped.

// Tap Dance declarations
enum {
    TD_ESC_CAPS,
};

// Tap Dance definitions
qk_tap_dance_action_t tap_dance_actions[] = {
    // Tap once for Escape, twice for Caps Lock
    [TD_ESC_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_LCTL),
};

Then in the same file, replace any occurrence of KC_ESC with TD(TD_ESC_CAPS)

Enable AutoShift

Add the below snippet to rules.mk

AUTO_SHIFT_ENABLE = yes

Add the below snippet to config.h

#define AUTO_SHIFT_TIMEOUT 200

Compile the firmware and flash your keyboard with it

$ qmk flash -km hn-preonic -kb preonic/rev3

Once this command begins, ensure to reset your keyboard for the bootloader to be available. On the Drop Preonic, this is at the bottom of the keyboard - you’ll need a needle or something thin to press it.

The build would then be available in the ~/qmk_firmware/.build directory. The bin file will be flashed to your keyboard.

References

• QMK docs - tap-dance
• QMK docs - auto-shift

We may see some pending work often and identify that as the responsibility of people with a certain title or specialization. If this work comes up enough times - it is very likely that there would be a proposal to hire for this role.

Here’s how it usually goes: A company needs a mobile app built as a companion to their primary product line.

None of the current engineers can build the mobile app due to various reasons. The reasons may include the lower priority of the mobile app in comparison to the product backlog, missing skill/experience on the team, or urgency in the organization to ship the mobile app.

So the hiring starts. Position is opened and interviews happen. A suitable person is hired to build mobile apps and a manager is assigned to them.

The manager’s pain

A few months later, the mobile app is built and released. Congratulations to the team - they have delivered good work. The mobile app has no bugs. They require very minimal maintenance work. The organization now prefers to focus on other priority items and no more updates are planned to the mobile app.

The manager and the mobile engineer begin experimenting with a few other ideas, but quickly realise that any further work on the mobile apps require other teams to build/expose APIs. And these teams would not do it - because it is not their priority at the moment or for the next quarter.

Days or weeks later - soon enough, the manager begins to find it difficult to create work for the mobile engineer. The eventual end is to let go of this mobile engineer.

Hard truth: The person hired to build mobile apps should not have been hired.

The roadmap check for hiring full-time

An easy way to avoid the above scenario from happening is to check if there’s enough work for a full year before hiring.

• Try creating a roadmap of work to be done by this future person. List work to be done without which the company cannot run.
• Most importantly, for anyone hired in new position to succeed, list other teams/people who should be supporting them. Ensure to check their priority list or roadmap for the next one year.

If there is not enough work for a year, but if it still requires another person on your team, then hiring a part-time position or a contractor would be better.

Ever been in a situation like below?

A Manager, stakeholder or old employee with historical context walks into a meeting only to talk about an issue, but add nothing else. As a next step, the team tries to solve the problem, but the solutions are either not reviewed, not accepted, or worse - the same stakeholders complain about it after it has been released to production. If this happens often, then more should be expected of this topic expert.

Topic experts at workplaces would very often take part in discussions to provide perspective. This includes throwing light on details and scenarios that may be unknown to the team.

It is equally important to make an attempt to help resolve the issue. So if you take part in a conversation, do it with the intention of bringing clarity, not blockers.

Start with “Here’s something that we should be aware of”

Don’t start by shooting someone in the room by with “Your solution does not work”. Instead, use facts and reasoning to make the team realize that the solution might not work. After all, even the topic expert can be wrong.

Continue with “Here’s something we can do to resolve this”

It is of utmost importance that you attempt to provide a solution or atleast parts of it. By doing so you admit that you want to resolve it.

My self-observation is that I communicate clearly when I write. So I prefer to write a wiki page or send emails, instead of verbal conversations. YMMV.

And extend it with “Here’s what I can do to help”

By providing perspective and a possible solution, you already contribute towards moving forward. But if there’s something you can specifically do, say it out loud. It matters that you are willing to be part of the solution.

When you contribute to the solution, your role changes from a mere stakeholder, to someone that is part of the solution - skin in the game. This helps in environments where stakeholders are not trusted to stick to decisions.

useEffect

• Use to perform anything that has side-effects (API calls, modify local storage, etc)
• This does not block visual renders

useCallback

Use to create a memoized function that doesn’t have to change during renders - unless one of the dependencies have changed.

To run something that has a side-effect

• Use useCallback to create a memoized function
• Then useEffect over the memoized function to mark it as as having side-effects

• I would like to list the in-stock products first.
• I have a products table with an availability column.
• The valid values for availability column are ‘instock’ and ‘outofstock’.

SELECT * products
ORDER BY array_position(
  array['instock','outofstock'],
  products.availability
)

The above SQL uses the array_position function. It requires two arguments.

• A list of sorted values
• The column that we want to sort.

array_position(sorted_values, column_name)

If you are using #RubyOnRails, that would be the following:

# First turn your custom SQL into an Arel SQL literal
order_sql = Arel.sql("array_position(array['instock','outofstock'], products.availability)")

# Pass the Arel literal to the order method
products = Product.order(order_sql)

What if the column has NULL values?

What I have is scraped data. I found out that there are times when the availability is NULL.

If I just wanted NULL values first or last, I would use NULLS FIRST or NULLS LAST. The SQL would be something like below.

SELECT * products
ORDER BY array_position(array['instock','outofstock'], products.availability) NULLS FIRST

But for products whose availability I am not sure of (NULL value), I want them to be listed on top of products that are out of stock. So I now include the NULL value as the list of values to order by.

SELECT * products
ORDER BY array_position(array['instock',NULL,'outofstock'], products.availability)

An easier way

If the values for a column are going to a finite list of values, this column would benefit from storing the availability as integers, along with using NULLS LAST or NULLS FIRST.

I’ve been toying with #Postgres for a hobby project and I’m learning quite a lot of nice things. If this is something you are interested in - follow me on @HashNuke

~ This is a rabbit hole ~

Places that sell stuff

• KBDFans
• TechKeys for keycaps and some weird goodies like 1-key keyboards
• SpaceCat - apart from other things has an Alpha PCB to build a sample keyboard. Might be better to get a Gherkin from MechBoards.
• MechBoards has some good kits. The Iris kit and Lets Split kit are good. Compare the cost when buying.
• keeb.io has kits and guides
• 1upkeyboards
• PimpMyKeyboard
• kprepublic.com
• Sentraq
• CannonKeys sells some inexpensive practice kits
• KeyHive has a $18 Maypad practice kit
• Happy Hacking Keyboard (HHKB) and Leopold F660C
  • Both are expensive.
  • Both use Torpe switches.
• GeekHack has a list of keycap sellers
• CandyKeys has a lot of keycaps and switch options
• JellyKey
• X-bows keyboards
• MechanicalKeyboards
• Check AliExpress and NewEgg too

Notes for custom builds

Case & PCBs

• Check if the PCB has LEDs or if it atleast supports it. SMB LEDs are the kinds of LEDs that I’ve come across so far - flat and can be soldered to PCB.
• Get a Tofu65 case with a KBD67 PCB.

Key switches

• Gateron can be better than Cherry MX.
• Browns are better for me.
• Checkout low-profile switches (comes in both optical and mechanical variants).
• Sometime tryout Holy Panda or Glorious Panda switches.

Keycaps

• Keycaps come in various sizes. 1u and 2u are common. Check size before buying.
• Check if the keycaps work with the key switch being used.

Controller

• Use an Elite-C controller which is a clone of SparkFun Pro Micro, but with a USB-C instead of micro-USB. Pro Micro is cheaper but the usb port has a reputation of getting ripped off the board.
• QMK firmware supports a number of keyboards
• QMK supports Atmel and AVR ICs. Infact the Pro Micro is an Arduino clone. Maybe I can use one of the Arduino boards? (QMK seems to support ATMEGA328up)
• What if I used my own controller?
  • There is a possibility of using a Teensy microcontroller. But again it’s micro-USB.
  • SeeedStudio Xiao is cute (like a Tomu with pin-outs). But the cortex-based chip used by the Xiao is not supported by QMK.

Kits

• Check if case and keycaps are being sold with the kits. Else have to buy them.

Other people’s notes on making keyboards

• 40percent.club is a blog about building keyboards
• Building a keyboard matrix
• NematicsLab has some electronics tutorials
• technomancy’s notes on building atreus

• The Non-designer’s Design Book
• Refactoring UI
• How to draw almost everything
• How to draw almost everyday
• Drawing on the right side of the brain
• A Profound Waste of Time
• Designing Games
• Creativity Inc
• Zen Pencils
• “How Buildings Learn” by Stewart Brand

About building products and running companies

• Traction (by Gabriel Weinberg and Justin Mares)
• The Mom Test
• Obviously Awesome
• Company of One
• The Startup Owner’s Manual
• Fanatical Prospecting
• Zero to One

People, Biases and such

• The Art of Thinking Clearly
• Crucial Conversations
• Super Thinking
• Never split the difference

Market, Economy, Systems and such

• Good economics for hard times
• A Little History of Economics
• Thinking in Systems
• Black Swan
• The Intelligent Investor
• The Rise and Fall of Nations
• Skin in the game
• Anti-Fragile

Upskill

• Deep Learning for Coders with fastai and PyTorch
• A Programmer’s Introduction to Mathematics
• Everyday Data Science by Andrew Carr

About stuff around me

• Stuff Matters
• Surely you’re joking Mr.Feynman
• Feynman Lectures on Physics: Volume 1
• Feynman Lectures on Physics: Volume 2
• Feynman Lectures on Physics: Volume 3

Copywriting

• Breakthrough Advertising
• The Elements of Style

Fiction

• The Hitchhiker’s guide to the galaxy
• Eleanor Oliphant is Completely Fine

On choosing metrics for traction channels

Traction channels

Reference: List of tractions channels

• [DONE] Targeting Blogs
• [DONE] Publicity
• [DONE] Unconventional PR
• [DONE] Search Engine Marketing
• [DONE] Social & Display Ads
• [DONE] Offline Ads
• [DONE] Search Engine Optimization
• [DONE] Content Marketing
• [DONE] Email Marketing
• [WIP] Engineering as Marketing
• [DONE] Viral Marketing
• [WIP] Business Development
• Sales
• Affiliate Programs
• Existing Platforms
• [WIP] Trade Shows
• [WIP] Offline Events
• Speaking Engagements
• [DONE] Community Building

1. Write a script to follow.
2. Record the video first.
3. Then record the audio.
4. Add video and audio together.

Recording

Having a script before the recording helps keep the recording concise. You decide what goes in ahead of the recording and not during the recording. This is the secret to having byte-sized screencasts.

I want to focus on one thing and get that right. So I prefer recording audio and video separately.

You can record both at the same time as long as you get separate audio and video tracks that you can cut/edit later.

It is OK to make mistakes in the same take/recording.

In case of a mistakes or unexpected background noise during recordings, repeat the sentence or the action in the video. The mistakes can later be removed during editing. Retakes are not required.

Combining audio and video

The audio and video recordings might have unnecessary parts. Like “huh” in the audio or some unnecessary page load indicator. Having separate audio and video tracks allows you edit them separately and consolidate the length.

Decide what your “scenes” are.

Edit by considering “scenes” - parts of the video that have different contexts. In your video, the scenes might be editing different files or showing different screens of a web app.

Audio longer than video

If the audio for a particular scene is longer than the video, then consider doing one or more of the following:

• Add a “Freeze frame” for the video.
• Space out your audio. A 2 second pause can be added during editing depending on how you want the video to feel.

These help ensure that the screen/page being talked about remains in context while it is being talked about.

Video longer than audio

If the video for a particular scene is longer than the audio, then consider speeding up certain parts of the video for that scene.

Actions like typing form inputs, typing boilerplate code, page load, etc can be cut out or sped up (Video editing tools allow you to speed up select parts of the video).

Code that is not the focus of the topic can be copy-pasted into the video as boilerplate. Just mention what the code does. “Lets copy-paste this code here. This helps with bla bla bla…”

Pace the audio as required

Use the pauses in the audio to decide what the user will perceive.

Want a breezy/fast screencast? Try having less pauses in the audio. Want a calm/slow screencast? Try having sufficient pauses in the audio.

Bonus: Add that background sound 🎺🎸

Pick some background music and add that as another audio track to your recording. Search for “royalty free background sound”.

For best results, try the following:

• Set the volume of this background sound track to 15%. You do not want that to be higher than the audio.
• Add a “Fade out” effect to the background sound for the final 5 seconds of the recording.

🎉 Done. You have your professional-quality screencast. 😃

How long does all of this take?

It usually takes me 2-3 hours to produce a 5min screencast. Most of this time goes into the initial prep and then later into listening/watching the output multiple times. Your pace might vary depending on what you are recording.

I have noticed that certain details that appear to me as quirks when editing, do not matter much in the final output. I do plan to practice not editing out certain things and leave them as is. This helps with avoiding the law of diminishing returns, but still keeps the screencast quality high.

– Some additional notes –

[1] I also “smooth” the audio of my voice recording. Helps keep consistent volume levels even though I might have different pitches in the audio recording.

[2] I use ScreenFlow for all my recording work. But this process should work with other tools too.

The entire walkthrough assumes that you are using Xcode to build your mac app.

Open CoreDataLab

Click on “Create a new Core Data Lab project”.

Choose your app file (the one you are building)

When creating a new CoreDataLab project, the app file has to be chosen first.

• Click on “Select App”. This opens the file picker window.
• If you are using Xcode to build your mac app, then the use the keyboard shortcut cmd+shift+G to invoke a prompt to enter a custom folder path
• Enter the path ~/Library/Developer/Xcode/DerivedData and hit the enter key
• Within this directory, look for your app’s folder.

If your app is called Hello, then the folder would look something like Hello-23erwfaewra (some random string follows the folder name).

Within your app’s directory, navigate into the following folder structure to find your .app file.

Build
-> Projects
-> Debug
-> Hello.app

After selecting the app, continue to setup the database path

• Like how the app was selected, click on “Select database”
• Use the cmd+shift+G shortcut to enter a custom path
• If your app’s identifier is app.example.Hello, then look for a directory like below:

~/Library/Containers/app.example.Hello/

Once inside, navigate to the following path to find the SQLite database file (path depends on your app name).

Data
-> Library
-> Application Support
-> Hello
-> Hello.sqlite

The final path will look something like below. Click on the “Continue” button to proceed.

~/Library/Containers/app.example.Hello/Data/Library/Application Support/Hello/Hello.sqlite

Final step: Give your project a name

Once the project is named, that is the end of the setup. Feel free to explore the data for your CoreData models.

Link - Core Data Lab website

or “How to POST a form in Swift using URLSession”

These examples will be using httpbin.org to test our request.

let url = URL(string: "https://httpbin.org/post")

Create a URLRequest object using the URL

var request = URLRequest(url: url!)
request.httpMethod = "POST"
request.setValue(
    "application/x-www-form-urlencoded",
    forHTTPHeaderField: "Content-Type"
)

Create a list of key-values to be sent

let queryItems = [
            URLQueryItem(name: "x", value: 123),
            URLQueryItem(name: "y", value: "hello"),
            URLQueryItem(name: "z", value: "world"),
        ]

Construct the body of the POST request

The URLComponents class can be used to construct the body of the HTTP POST request. This is generally used to construct the query params for URLs for HTTP GET requests.

// Create a URLComponents object using blank url
var urlComponents = URLComponents(string: "")

// Assign the query items to the object
urlComponents?.queryItems = queryItems

// Fetch the formatted string from the URLComponents object
let request_body = urlComponents!.query!

Set the body of the request variable

request.httpBody = Data(request_body.utf8)

Make the request using URLSession

URLSession.shared.dataTask(with: request) {(data, response, error) in
    // Decode response from the data variable using JSONDecoder
}

aka “How to decode response from a JSON API”

Import the Foundation library. This will also work if SwiftUI or UIKit or imported.

import Foundation

Define a struct to represent the JSON data

struct Dog: Codable {
    var name: String
    var age: Int
}

The struct should use the Codable protocol. This is required both for encoding and decoding.

• We encode an object that respects the Codable protocol.
• OR we decode an object that respects the Codable protocol.

Decoding from JSON

The following is the JSON used in the example.

let json = """
{"name": "Tommy", "age": 6}
"""

Create a Data object to store the JSON data

let data = Data(json.utf8)

The example uses JSON input from a variable. API responses will be Data objects, so they don’t have to be converted into a Data object again.

Initialize a JSON decoder

let decoder = JSONDecoder()

Decode the JSON into an object

let decoder = decoder.decode(Dog.self, from: data)

The Xcode will warn about this expression throwing. So we’ll have to wrap it with a try.

let decoder = try? decoder.decode(Dog.self, from: data)

decoder will now be a JsonResponse object and will contain the fields x and y

Encoding to JSON

Represent a new dog.

let dog = Dog(name: "Peggy", age: 3)

Define an encoder

let encoder = JSONEncoder()

Encode the dog and ofcourse wrap it with a try.

let json = try encoder.encode(dog)

The result will be a Data object. The response can be verified by converting it to String.

print(String(data: encoded_json, encoding: .utf8)!)

Stuff to know

In the Dog struct, both name and age are defined as mandatory properties. This means that the intializer for Dog will expect both the properties to be passed to the initializer when creating the object.

If we expect JSON responses from APIs to be containing optional fields, then it is better to make the properties optional too. Example below indicates that the age field is optional.

struct Dog: Codable {
    var name: String
    var age: Int?
}