Problem: I had a Kindle Paperwhite and I bought a Kobo Libra Colour. I also had bought books for my Kindle. How do I transfer them to Kobo?

Solution: on Windows 10.

1. Uninstall Kindle for PC (if you have it).
2. Install Kindle for PC 1.17 and
   1. Disable automatic updates
   2. Login to your Amazon account
   3. Select a location for your books
   4. Download all the books that you want to transfer – they should be in AZW format.
3. Download NoDRM
4. Install Calibre and
   • Install the NoDRM plugin via a path to the ZIP that you just downloaded
   • Within the NoDRM plugin settings, add the serial number to your Kindle. (Find it in https://www.amazon.ca/hz/mycd/digital-console/alldevices)
   • Add your books from the folder from step 2.3
   • Select all books, right-click, “convert books” and “bulk convert”
   • Select KEPUB as the target format.
   • Click “OK”.

The N test lasts ~30 minutes and it’s easy, but there’s many things to remember.

Before:

• Practice 3-point turns.

The day of:

• Remove dashcams
• Remove bike racks covering the license plate
• Remove anything heavy from the backseat

The test:

• Watch the speed limit. You’re allowed to go slower than usual, but not faster.
• Watch for parks & playgrounds. Drive around the area where your test will be to know where they are. Also watch out for speed bumps, they are usually an indicator that you are near a park.
• Shoulder check when changing lanes, changing direction, or parking.
• 360 check before reversing.
• Handling boulevards:
  • If you are turning left and the boulevard is parallel to you:
    • if the cross street has traffic light: wait as you normally would
    • if the cross street does not have traffic light: advance the car, and wait next to the far end of the boulevard.
  • If you are turning left and the boulevard is perpendicular to you:
    • Advance your car straight until you are in the middle of the boulevard. This reduces the time it will take you to make the turn.
• Stay in the middle of your lane, and on your lane.
• Wait for a safe gap when turning or when at a stop sign. Don’t rush.
• When leaving a back alley, stop before turning. Also the max speed is 20 km/h.

Max & Min Heaps:

h := &IntHeap{}
heap.Push(h, k)
heap.Pop(h)

type MaxHeap struct {
	IntHeap
}

func (h MaxHeap) Less(i, j int) bool { return h.IntHeap[i] > h.IntHeap[j] }

// min heap
type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *IntHeap) Push(x any) {
	*h = append(*h, x.(int))
}

func (h *IntHeap) Pop() any {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

Sorting functions:

sort.Slice(people, func(i, j int) bool {
        // ascending order
	return people[i].Age < people[j].Age
})

smallInts := []int8{0, 42, -10, 8}
slices.Sort(smallInts)

sort.Strings(s)

Queue and Stack:

queue := list.New()
queue.PushBack(...)
queue.Remove(queue.Front())

stack := list.New()
stack.PushBack(...)
stack.Remove(stack.Back())

Regexes:

re := regexp.MustCompile(`(?P<age>\d{2})`) // eg 42
matches := re.FindStringSubmatch(personDetails)
age := matches[re.SubexpIndex("age")]

Circular linked list:

r := ring.New(8)
for i := 2; i <= 9; i++ {
	r.Value = Phone{
		Number:  i,
		Mapping: []rune{},
	}
	r = r.Next()
}

Bitwise operations:

• &: Bitwise AND
• |: Bitwise OR
• ^: Bitwise XOR
• <<: Left shift
• >>: Right shift

Greatest common divisor:

// euclidean algorithm
func gcd(a, b int) int {
	if a == 0 {
		return b
	}
	return gcd(b%a, a)
}

package main

import (
	"context"
	"fmt"
	"os"
	"os/signal"
        "syscall"
	"time"
)

func main() {
	fmt.Println("Press Ctrl+C to exit")
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, os.Kill, syscall.SIGTERM)
	defer stop()

	waitForExit := make(chan struct{})
	go func(ctx context.Context) {
		for {
			select {
			case <-ctx.Done():
				fmt.Println("before exit")
				time.Sleep(1 * time.Second)
				fmt.Println("after exit")
				waitForExit <- struct{}{}
				return
			default:
				fmt.Println("long running task")
				time.Sleep(1 * time.Second)
			}

		}
	}(ctx)

	<-ctx.Done()
	fmt.Println(ctx.Err())
	<-waitForExit
}

Demo:

[30/07/24 9:01:29] ~/GolandProjects/programInterruptDemo  $ go run ./main.go
Press Ctrl+C to exit
long running task
long running task
long running task
long running task
long running task
^Ccontext canceled
before exit
after exit
[30/07/24 9:01:46] ~/GolandProjects/programInterruptDemo  $

Events in the life of a user:

1. Provisioning
2. Authorization (granting of privileges)
3. Authentication
4. Access policy enforcement
5. Sessions
6. Single sign-on (a user authenticates once and accesses multiple applications, without having to reauthenticate because they all trust the same identity provider)
7. Stronger authentication (supported by both OIDC and SAML 2)
8. Logout (may involve terminating more than one session)
9. Account management
10. Deprovisioning

Protocols

• SAML 2: solves the problem of single sign-on across domains. It’s complex to implement but it’s widely used.
• Ws-Fed: also solves single sign-on.
• OAuth 2: allows a user to authorize one application (the “client”) to send a request to an API (the “resource server”) on the user’s behalf, without needing their credentials. It solves authorization. Current version is OAuth 2.0 but 2.1 is on the works.
• OIDC: layer on top of OAuth 2 that provides information to applications about the identity of authenticated users. Solves authentication.
• SCIM (System for Cross-Domain Identity Management): solves the problem of sending and updating identity information from one domain to another. It provides a standard REST API for one system to send requests to another for adding or modifying user and group records. See this blog post.

OAuth 2

• Example: user is writing documents in WriteAPaper.com using his own documents stored in documents.com. So WriteAPaper.com requests access to those documents with the user’s consent.
• An authorization server must implement the /authorize endpoint and the /oauth/token endpoint, which accepts a code.
• Three grant types / flows:
  • Authorization code with PKCE (Proof Key for Code Exchange): the code ensures that the application that requested the authorization code is the same application that uses said code to get an access token. A random string called code verifier is used to create a code challenge. The authorization server must remember the code challenge. Then, when it receives a call to /oauth/token with the code verifier, it uses the same hash function to confirm that the code challenge is the same.
  • Client credentials: requires no end-user interaction because the user doesn’t own the resource.
  • Refresh token: makes sense only for the authorization code flow, to avoid having to request user consent every time.
  • Client device (not part of the spec): used for IoT, for example, a digital picture frame that requests permission to show pictures from another site. The user grants permission from a secondary device, like a phone.
  • Implicit flow: not recommended because it exposes access tokens in URL fragments which could be stored in the browser’s history.

OIDC

• An authorization server can implement a /userinfo endpoint which returns claims with a JSON object. This is useful if the claims are too large to fit in an ID token, which is encoded as JWT. The /userinfo endpoint can only be accessed with a valid access token.
• Three grant types / flows:
  • Authorization code flow: similar to OAuth 2’s flow.
  • Implicit flow: similar to OAuth2’s flow except that there is no risk of exposing an access token because the authorization server only returns an ID token in the form of a JWT.
  • Hybrid flow: mixture of the previous two. It is designed for applications with both a secure back end and a front-end.

SAML 2

• Provides cross-domain single sign-on and identity federation (i.e. a way for an application and an identity provider to use a common shared identifier for a user).
• The identity provider must implement a /sso endpoint where SAML requests can be received. The application must implement an /acs endpoint where the SAML response can be received.

Authorization

Authorization is the granting of privileges to access a resource. Access policy enforcement is done when a user requests a resource and a check is made to see if they can have access.

Three levels at which authorization may be specified and applied:

1. At the application or API
2. What functions can the user call in the application or API
3. What data the user can access or operate on

Models for specifying authorization:

• Access control lists
• RBAC
• ABAC
• ReBAC
• JWT-secured Authorization Requests (JARs), Rich Authorization Requests (RARs), or Pushed Authorization Requests (PARs).

Compliance

• GDPR describes a legal basis for processing personal data. It applies to any product that processes personal information of EU residents, regardless of where the information is held.
• Payment card industry must comply with PCI DSS.
• HIPAA and HITECH is required for the healthcare industry in the United States.
• FedRAMP applies to companies providing services to US government agencies.
• SOC2 (Service Organization Control) is a set of controls against which a company is audited related to security, privacy, confidentiality, integrity and availability.

A boomerang employee is someone who leaves a company and later returns to it. Most of the time it’s made to get a bump in salary without having to go through a promotion process.

I worked for Amazon as a software engineer for four years. I left in 2021.

Last week I got an email from a recruiter in AWS. The conversation can be summarized like this:

I was… puzzled, to say the least.

Why title the email “do you want to boomerang?” if you are going to make me do interviews as if I were a brand new hire?

And why would you want to interview me as a brand new hire? Why do you need me to go through another coding interview? I publicly admit it, I hate those, for many reasons. But I worked for your company, you know I can code. And I left because I chose to, not because you decided suddenly that my code was not good.

Is it not in your best interest to make the process easier for me? Do you really prefer to hire someone completely new? Do you know how much time it takes a new hire to learn all of the amazon tools built in-house? I’ll tell you: it’s 6 months to a year at least.

The tech interview process is very broken…