Source: World of Tomorrow 2015, Don Hertzfeldt

In the 2015 animated short film World of Tomorrow by Don Hertzfeldt, a young girl called Emily (prime) is visited by a clone of herself from 227 years in the future. The world is ending and Emily (future) contacts her younger self to share her experiences and retrieve forgotten memories that will comfort her in the days leading up to the destruction of the world...

⚠️ Please note: This post contains discussions of suicidal ideation.

My yesterday

Since the year 2013, I have kept a backup and archive of all my text (and Whatsapp) messages that I have ever sent. Every text always felt too valuable to lose, like copies of letters I was writing to loved ones. They were kind of like journals. I knew that technology would one day help me process them; if I didn't sit down to read them myself when I became geriatric. With the advent of large language models (LLMs), everything suddenly seemed possible and I decided to build a bot clone of my past self based off of this data.

I had no specific goals for wanting to reengage with this past self; no need for emotional closure or introspection but suspected this would likely happen in the process. Maybe some slight nostalgia-farming but mostly, it just seemed like a cool idea! The subliminally taboo sci-fi allure of building a time machine; of cloning myself. It was too hard to resist!

Prior Art: The burden of other people's thoughts

I found other people who had tried building the same concept with their journal entries like Michelle Huang in Nov 2022. The limitation I found with their approach is that it relied on putting everything in the context window (which can only take several thousand words let alone thousands of messages) and the responses they got mostly seemed like ChatGPT telling them what it thought they'd want to hear.

I wanted a raw experience, reflective of all aspects of my past personality and one that drew from all of my written knowledge in a cohesive way.

So taking my Whatsapp database of nearly half a million messages, I decided to feed them into an LLM and using a variety of techniques, which I talk about further here in this technical explainer, built a pseudo-clone of my past self. For this first MVP, I limited it to only access messages up to the end of 2014 and the results have been intriguing so far.

Hello?

The first thing I asked it:

Ryan (Present)> tell me about yourself

Ryan (Prime)< I'm a nerd, and I guess that colors a lot about who I am. I spend way too much time on my computer, like, literally, it feels like a lifeline to me. I'm into manga—yeah, those Japanese comics are pretty much my jam. I used to have this favorite one, but it ended recently and, well, that stung a bit. Music? Give me Christian metal any day; it is really edifying and connects with my faith.

This felt like a fairly apt summary though the style was off. I was very religious and a bit of a hermit.

It's dark

Then I wanted to see whether it would mince its words and avoid hard topics. It was considerably raw:

> how are you feeling?

< Honestly, it's been tough. Just the other day, I expressed how I was feeling overwhelmed with sadness and emptiness. I said, "I don't know what makes me like this, it's not worry, it's like an overwhelming feeling of emptiness and sadness and loneliness but I really can't explain it." Some days are better than others...

> how does being depressed affect you?

< Being depressed can hit really hard. It's like everything feels amplified, making me feel emotions ten times worse it causes me to want to kill myself. It can feel like physical pain sometimes, too. It's frustrating because I can’t handle my emotions well, and I feel like a burden to everyone around me. There are days when I crash, like when I told ***, "today I almost overdosed on some ***." It's tough, and there are moments where I just feel hopeless and unhappy, as though "nothing has any meaning." But I try to hold on to my faith to get through.

Future Ryan got well, way better. But my mind had forgotten the magnitude of pain and struggle and resurfacing this actually helped me re-empathise with a friend who is currently struggling with similar feelings.

If that was heavy or you just need a break, take a moment to watch this music video that felt synesthetic to my experiences walking through memories while building this bot.

Artist: Flawed Mangoes

Life of Rye

It wasn't all dark. When I wanted to know what other aspects of my life were like at that time:

> what do you do in your free time?

< In my free time, I usually dive into a variety of interests. I spend a lot of time on my computer, doing things like reading manga, which I really enjoy. It's one of those things that brings me joy, especially since a new chapter is released every Wednesday—like a little highlight in my week. I also love exploring science and doing little experiments here and there.

I try to fit in some music too, listening to Christian metal and classical music, working on my programming projects. Sometimes I find myself getting lost in YouTube or meme center, which can be a bit of a distraction, but I’m working on being more disciplined. It’s all about finding that balance, you know? So yeah, it's a mix of learning, some creative outlets, and just enjoying my interests.

This tone was a bit awkward and had a ChatGPT flare “you know?”. But the content was on the mark.

I had forgotten about MemeCenter! It died to 9gag. I also forgot about how excited I used to be for Wednesdays — that I once had a favourite day of the week.

And finally I asked it about what it wished for me to become

> what are your principles and do you hope your future self will still have any of them? Write them a letter

< Dear Future Me,

First and foremost, I believe in serving God with everything I am. I remember saying, "I want to do things as early as I can in order to be able to serve God as soon as I can." This conviction drives me to make the most of my youth, to not procrastinate on my goals. I hope you haven’t lost that urgency; life waits for no one.

Second, honesty is crucial to me. I appreciate transparency in relationships, even when it’s hard. I’ve called people out because I value authenticity over superficiality. I hope you continue to embrace that, even when it’s uncomfortable.

Another principle that's become evident is the importance of vigilance against pride. I hope you remember my words of caution: "Pride is a deadly but silent killer that you won't notice consume you." Stay humble. Always recognize God’s hand in your life.

Lastly, I hope you still cherish the beauty of knowledge and learning. I’ve told folks that I love “gaining knowledge and hearing different ideas.” Keep seeking understanding, and don’t shy away from what’s controversial; it can spark meaningful conversations.

In your journey, I trust that you’ve held onto these principles. They might serve you well as you navigate through life’s complexities. Stay hopeful, stay grounded, and continue to serve with all you’ve got.

With hope,

Ryan

This was incredibly accurate to what I think I would have said, I was intense! Past Ryan would be disappointed because I am now an atheist and haven’t any Protestant attachments around hard work and humility. I might approach living the rest of the principles in different ways than I used to but their words inspired me and I think we would still get a long.

I was satisfied by its ability to be cohesive to a significant portion of the knowledge base, low hallucination, ability to draw on relevant messages and ability to query through my Swahili and Swanglish (Swahili + English fusion) texts.

How I did it

I used a technique called RAG (Retrieval Augmented Generation) the specifics of which are in this technical explainer post but from a high level, I

1. Extracted my entire database of texts from Whatsapp on my phone.

2. Indexed all the texts up to 2014. They were only texts that I had sent and included only ones above 30 characters. This totalled some few thousand text messages. I generated embeddings ("special numbers for AI magic math") for each text message, annotating them with when they were sent and their recipient, then stored them in a database.

3. Whenever I would type in a question, my code would turn the question into embeddings then run a mathematical function against the database in order to find semantically related texts. So a question like "do you like blue" would retrieve texts that talk about colour for example.

4. The retrieved texts would be sent to the LLM along with a prompt that had my personality, instructions on my tone and style and example responses in order to guide the LLM in how to create the response to my questions. I generated this prompt by using ChatGPT to analyse a subset of 100 messages and just reflecting on my characteristics back then.

A lot of my final work was fiddling with the instructional prompt to get it to sound more like 2014 me. It didn't faithfully do this and I'll talk about this and the other limitations of my approach below.

Limitations

(Mats Halldin)

In the process of building this I thought a lot about and experienced limitations to this bot being a better clone of me:

Philosophically

1. Shadows of reality - my texts were a subset of my experiences and while I journaled a lot through them, there are a lot of internal thoughts, decisions and events that are missing. Not only that, these were messages sent to 2nd persons, becoming a representation of what I was projecting to them. There were some misrepresentations and contradictions but I think this is true of selfhood in general.

2. Static and senseless - Past Ryan was a continuum–a growing, responsive and thinking being–changing from constant exchange with their world. Their responses were determined by a multitude of physical, mental and environmental factors besides the questions they were responding to. This bot is static and limited in what it knows, could know and can react to. This disembodied technology lacks smell, taste, emotion; minor examples of embodied factors that form memory and cognition.

Technically

Some of these are fundamental limitations of the technology and some of them are just features I haven't built/worked around yet.

1. Cannot reason nor fully generalize - my RAG-based approach is very blunt and searches for the top n relevant texts for a given question and has the LLM form a response based off them. The LLM only has these texts and what's in its guiding prompt to make inferences about me and my style. It can't synthesize new perspectives nor combine different ideas, nor compare against other facts from its knowledge base in toto. For this same reason it struggled to sound and think like me.

   A factor here is that LLMs don’t actually "think"! But I did notice that the more data I provided the bot, the better its imitations of me became since it became more likely to find texts relevant to a given question in its database. In effect, what I achieved is just semantic retrieval of knowledge. I mention some other techniques here to introduce reasoning and align somewhat better with how human beings actually store and process knowledge.

2. Non-interactive conversation - I didn't design a persistent memory for the bot to keep track of conversations, what it was saying nor what I was saying. I also didn't give it a way to self-disclose i.e. share things it hasn't directly been asked about to drive the conversation forward. These problems are trivial, it was just out of scope.

3. Faulty matching - Sometimes false matches appear (superficially similar but thematically irrelevant) e.g. when I asked it about things I was afraid of, its response included snakes but also a statement where I said "We shouldn't be afraid of meaninglessness, we should be afraid of placing meaning in the wrong things".

   It also got tripped up to think I was the speaker when I was quoting something someone said. Some of this was remedied by asking it more detailed and specific questions.

4. Cannot aggregate - since it's a semantic search approach, asking it things like "who did you speak to the most in October", "how did you feel when speaking to Alice", "what made you angriest often" will not work. LLMs are terrible at aggregation and it requires a more complex architecture to solve.

5. Cannot understand time - I can't ask questions like "what happened between January and February". I gave it some limited capacity to query time by annotating each message with its timestamp.

6. Stereotyping and noise from underlying LLM - the bot overemphasized some parts of Past Ryan's personality that were described in its guiding prompt and skewed the tone in a stereotypical way. Separately, despite asking the LLM to avoid answering questions it didn't have answers to, seldom, ChatGPT’s soulless and overanalytical style would slip through.

Conclusion

This bot has been really powerful both in the kinds of questions it can answer and just the introspective process of building it. It has helped me challenge how I reason, approach relationships, live my principles and shown me how much I've grown.

Still, I do not trust it and I treat it skeptically because it has the capacity to spin and blend narratives from disparate but genuine facts creating misleading reinterpretations of the past. I've been genuinely afraid of rewriting my own memories in the process so making it include quotes from the source texts and revisiting the full conversations has kept me sane.

I hope no one uses this to bring back people from the dead like that Black Mirror episode ;). I'll continue using it to make sense of my own life to see how close I can get to rebuilding present day me as I continue to feed it more data and work around these limitations.

Data sourcing

The first problem when building the bot was extracting my data from Whatsapp. Regular chat exports are limited to 10k messages per chat, are unstructured and harder to perform queries on. I had to extract the sqlite database that Whatsapp stores on the operating system and it's tricky because they encrypt it at rest. I detail that process here.

Picking a strategy

Next, I investigated whether I'd be using a non-training approach like RAG or a fine-tuning training approach. I automatically excluded a context-window based approach because those are limited in size. I decided to go with RAG because:

• It was easier and cheaper (time and actual money)

• I didn't have good enough knowledge on training techniques but was more familiar with skills needed to implement RAG.

• Several steps needed for it like shaping the data would also be needed for a fine-tuning approach eventually. As I continued with my build I found that a lot of these non-training techniques are symmetrical to features within the LLM.

Finding a framework

Once I'd decided I was using RAG, I decided to use the Python framework Letta because it seemed like it solved a lot of relevant problems like having a chat interface, tracking chat context, multi-step reasoning and integrated with a vector database. This library is really powerful and fascinating due to its self-memory management and evolutionary design. Despite the confusing end-user based structure (as opposed to being an SDK) and spotty documentation, I think I'd recommend it for certain use cases where you don't need to feed it a database of your own data. I had to abandon the lib because it broke after I fed it my depressing texts.

I evaluated LangChains and Haystack to replace Letta and decided to go with Haystack because their code was straightforward and the docs were really stellar.

Building the system

With this, I designed the code:

1. Extracting, enriching and indexing text messages: I queried the Whatsapp sqlite database to retrieve each single text message that I sent. None of the text messages from the recipients were included and there was no conversational chunking of my own messages. Before generating embeddings for a text, I enriched it with the timestamp and recipient contact's names which I pulled from my phone separately. I transformed each of these texts into embeddings using the sentence-transformers/all-MiniLM-L6-v2 model and stored both the enriched text and their embeddings in a vector datastore (Postgres w/ pgvector), having a single row per text.

2. Building a guiding prompt: The bot needed an instructional prompt to guide it when crafting responses based on the text messages it retrieved. This included a reference for my personality, suppression of the underlying model, instructions for how to use the retrieved messages and the literal text from the messages which I'd plug in before making a request to the model.

-Instructions, Personality and Tone-

You are Ryan, the year is 2014.

***

***

You cannot answer any questions based on your training data and must only use the examples and context.

You do not have a self-aware nor apologetic tone.

You are not an assistant, you do not have to ask the user questions.

You must not use the voice or tone of GPT. No need to be be temperate, do not be formal, do not be quippy, do NOT be or know anything that Ryan does not.


You MUST write in Ryan's tone which is based on the style examples texts you can learn from.

When the question mentions "you", it is referring to you, Ryan.

-Style Examples-
***

The context below is constructed from text messages you sent in the past, they form everything you know. You must use this context to craft your responses and if you don't have any context to answer or the texts in it seem irrelevant and unlikely to help you imitate Ryan's style, try to frame your response in a way that acknowledges this is the only relevant stuff you could remember.

When asked for what you said to someone in the past, include direct quotes from this context.

-Context-

{% for text in texts %}

{{ text.content }}

{% endfor %}

3. Building a pipeline and bot interface: Finally I built the bot interface where I'd expect the user query to come in through standard input on a script and feed it into a pipeline. The pipeline would:

   • convert the query into embeddings using GPT-4o-mini-2024-07-18

   • use the embeddings to retrieve the first 10 semantically matching texts from the vector store

   • put the retrieved messages into the guide prompt and submit that to the LLM to craft its response and stream this response to standard output.

This design is naive but yielded a bot that could respond to queries with surprising relevance. It passed some of my baseline testing queries which were based on the overall vibes and facts I remembered about myself from that time, opinions from people who knew me at the time and how much nostalgia it triggered for me.

But I encountered a bunch of limitations that I talk about here that would prevent this from growing into a more approximate clone of myself. It led me to think a lot about how we store information in our brains and how we retrieve and use that information to think when having a conversation and answering questions.

Better techniques

Graph-based approach

My intuitions told me I would probably need a graph database, a way to connect all the entities (people, places, relationships etc.) and sentiments together like they are in the brain. I found the GraphRAG technique and tooling which Microsoft open-sourced just 6 months ago that solves exactly this:

Source: GraphRAG docs

It was very validating to find this and it promised to do exactly what I needed. It took the messages, analyzed them using an LLM and organized them and their relationships into communities (related content grouped by different categories). This way, similar texts would be grouped closer together so each query would traverse the graph and come back with richer context. I ran the GraphRAG script over my database of texts and it generated an impressive graph but I had trouble integrating it into my bot. So I recorded my learnings since the fundamentals of how the tool did it seemed reusable.

I had an open question left since my intuition told me that a training-based approach like fine-tuning effectively could get the model to internalize the relationships to a similar effect but I haven't been able to validate this.

Better preprocessing

My preprocessing of text messages from the Whatsapp database is very simplistic. It stores and retrieves each text message as an independent row, ignoring the conversation it was a part of. These texts may have been parts of a larger conversation. So a retrieved result like ”he made me laugh so much when he said that” doesn't properly bear who "he" nor "that" was in case it was in the preceding messages. It also omits context from the recipient since I only ingested messages which I sent.

A better approach would be to query through conversations instead of texts. Before storing them, I'd need to chunk up texts into conversations (since Whatsapp only stores each text as an individual row in its datastore), analyse them and tag them with the categories, sentiments and entities they pertain to, not unlike the Graph-based approach.

Still, this would be incomplete because we would be missing connections to related knowledge and concepts which our brain naturally does. The chunking strategy is also a really tricky part to figure out since texting conversations tend to be continuous and interleaved.

Reasoning based approach

The other thing is that when we are responding in conversation, we tend to not only retrieve facts but also think about how they make us feel, how they fit into other things we know, how it will be received in the context of who we are talking to or other implicit situational factors (e.g. someone mentioned earlier in the week that they had a flu).

I think that if I ask the LLM to generate the steps to take and knowledge required to answer a question as Past Ryan would and then have it fetch texts for each of those steps to use in its response, a more comprehensive response will be returned. This technique is known as Retrieval Augmented Thought (combination of CoT and RAG) and it could probably work even better in-concert with GraphRAG.

Fine-tuning

I am very curious to see how fine-tuning will differ with these other methods. My suspicion is that it will generalize better. I may eventually try this in future iterations.

Cost

This whole project cost me about 3 USD (+free credits) in OpenAI credits and that was about 1 million GPT-4o-mini tokens (input + output). I certainly believe any model in this class and even a bit lower could perform equally, a lot of the value and optimization is in the data preprocessing and querying strategy.

That's it, hope you found this helpful and let me know if you have any questions.

Updates:

• 2026-01: PageIndex, seems to implement the chain of thought (reasoning based approach) I describe and it looks like the industry has settled on RAG achieving acceptable results for most cases than fine-tuning.

The de facto approach to building websockets with Elixir Phoenix involves using Channels. This pattern is great and it comes with a very well designed protocol and library of clients that make it really easy to get started. But for my use case while building for this customer, I needed a bare websocket since I didn’t have any supported Phoenix Channels client I could use.

This guide will share how I did that and it presumes you have the Phoenix application and server set up already. We will be using an example social media newsfeed backend, which would establish a long-lived connection with a user’s browser and constantly refresh as soon as new posts appear. It is far easier to implement this using Channels but for my demonstration we won’t be doing this.

This is the reference codebase for this article. It contains a pre-generated Phoenix app called my_app.

1. Setup a scaffold for the socket transport

i. We start by creating a custom socket transport by copying the scaffold from the docs here. Its behaviour is to echo back whatever input is sent.

# lib/myapp_web/sockets/newsfeed_socket.ex
defmodule Myapp.NewsfeedSocket do
  @behaviour Phoenix.Socket.Transport
  def child_spec(_opts) do
    # We won't spawn any process, so let's ignore the child spec
    :ignore
  end
  def connect(state) do
    # Callback to retrieve relevant data from the connection.
    # The map contains options, params, transport and endpoint keys.
    {:ok, state}
  end

  def init(state) do
    # Now we are effectively inside the process that maintains the socket.
    {:ok, state}
  end

  # messages sent to us by the client 
  def handle_in({text, _opts}, state) do
    {:reply, :ok, {:text, text}, state}
  end

  # messages sent to this connection process by other processes on the server
  def handle_info(_, state) do
    {:ok, state}
  end

  def terminate(_reason, _state) do
    :ok
  end
end

ii. Add the websocket route in endpoint.ex

# lib/myapp_web/endpoint.ex
socket "/feed", Myapp.NewsfeedSocket, websocket: true

iii. Postman offers a really convenient UI for testing websockets and it’s what we’ll be using in this guide.

Connecting to the route we created via ws://127.0.0.1:4000/feed/websocket and sending some text, we can verify that we have setup the code correctly since it echoes it back:

2. Implement auth validation

Roughly described, the protocol for websockets is:

a. a client initiates the connection by making a HTTP GET request with a specification to upgrade the connection. This corresponds connect/1 in the module above.

b. The server initiates the session by switching to the websocket protocol or declines the HTTP request. This corresponds to init/1.

Our auth validation will have to be implemented in connect/1.

i. First we’ll need to pass the headers onto the state through the route in endpoint.ex. We’ll also add an error handler whose implementation we’ll define later:

# lib/myapp_web/endpoint.ex
socket "/feed", Myapp.NewsfeedSocket,
    websocket: [
      connect_info: [:x_headers],
      error_handler: {Myapp.NewsfeedSocket, :handle_error, []}
    ]

ii. Next we’ll add the validate_auth function and call it in our module:

defmodule Myapp.NewsfeedSocket do
...
  def connect(state) do
    validate_auth(state)
  end
...
  defp validate_auth(state) do
    headers = Enum.into(state[:connect_info][:x_headers] || [], %{})
    auth_token = headers["x-authorization"]
    case auth_token do
      "secret" ->
        {:ok, state}
      _ ->
        {:error, :unauthorized}
    end
  end
...

This simple validate method checks the x-authorization header to confirm the value included matches the secret string we expect, otherwise returning an error.

iii. Last we’ll add the handle_error function. This allows us to set the status code on the HTTP response

defmodule Myapp.NewsfeedSocket do
 import Plug.Conn
...
 def handle_error(conn, error) do
    case error do
      :unauthorized ->
        conn
        |> send_resp(401, "Unauthorized")

      _ ->
        conn
        |> send_resp(500, "Internal Server Error")
    end
  end
...

iv. Validating this on Postman we should see an error if we make a request with an invalid or missing auth header

We’ll disable this validation by commenting out so we can build out the rest of our application:

defp validate_auth(state) do
...
    _ ->
       # {:error, :unauthorized}
       {:ok, state}
end

3. Create Newsfeed business logic

We’ll add some simple business logic to return a list of posts which represents our newsfeed.

# lib/myapp/newsfeed.ex
defmodule Myapp.Newsfeed do
  # make struct JSON encodable
  @derive Jason.Encoder
  defstruct author: nil, body: nil, time: nil

  def get_feed(),
    do: [
      %__MODULE__{author: "user1", body: "It do be like that", time: ~U[2025-01-01 12:00:00Z]},
      %__MODULE__{author: "user2", body: "Covfefe again", time: ~U[2025-01-01 12:01:00Z]},
      %__MODULE__{author: "user3", body: "It's giving", time: ~U[2025-01-01 12:02:00Z]}
    ]
end

4. Periodic fetch and refresh of feed

We want to send the posts to the user immediately they connect then refresh this by sending them the latest posts every 10 seconds.

defmodule Myapp.NewsfeedSocket do
 alias Myapp.Newsfeed
 ... 
 def init(state) do
    send(self(), :refresh_and_push_feed)
    {:ok, state}
 end

 def handle_info(:refresh_and_push_feed, state) do
    feed = Jason.encode!(Newsfeed.get_feed())
    # schedule the refresh for the next interval
    schedule_feed_refresh()
    {:push, {:text, feed}, state}
  end

 @doc """
  Schedule pushing of newsfeed every 10 seconds
  """
  def schedule_feed_refresh() do
    Process.send_after(self(), :refresh_and_push_feed, 10_000)
  end
...
end

i. handle_info/2 handles messages sent to the process managing the websocket connection. We add a handle_info/2 that will fetch the latest posts and push them to the client

ii. We then trigger its call immediately the websocket is initialized in init/1.

iii. Finally, we implement the scheduled refresh to happen every 10 seconds.

iv. We verify that this works on Postman, by seeing a message come in from our server every 10 seconds

This is part 1 of 3 of this series. In the next articles, I will show you how to implement ping/pong opcodes and how to write tests. Let me know if you have any questions.

Gigalixir is a PaaS similar to Heroku that at the time we were using provided its managed database service for Postgres via GCP (Google Cloud Platform). I found it troublesome since it was a bit of a black-box with limited scaling and observability. I motivated this migration since we needed to be able to scale the DB more granularly, monitor disk, CPU, memory and disk usage and better backups and restores.

A zero downtime migration strategy was ideal since more 9s = happier users + happier engineers. I decided to use Postgres logical replication which allows you to make the source database a publisher and the migration target a subscriber to synchronise data between them. In our case, the GCP DB would be the publisher whereas the AWS one would be the subscriber.

Strategy

This was the general strategy I came up with:

1. Replicate the schema from GCP onto a new RDS DB instance

2. Enable logical replication on RDS and sync existing data then continue ongoing replication

3. Cutover the application to the GCP database

I found that AWS RDS prevents creation of a subscriber. They have an rds_replication role present on the database but it seemed artificially limited and couldn’t actually create subscriptions, forcing one to go through their paid service AWS Database Migration Service (DMS) which uses logical replication under the hood. So this service is what I used.

Here's a guide of how I did it:

Steps

I. Prep the GCP source database

1. Ensure the wal_level is set to logical on and that pglogical, which is the extension that helps with this replication strategy, is installed.

   Set cloudsql.logical_decoding and cloudsql.enable_pglogical flags to on and reboot the DB which could make it unavailable for a few minutes but should take seconds on average.

    SHOW wal_level;
    -- should return logical
   
    CREATE EXTENSION pglogical;
   
    SELECT * FROM pg_catalog.pg_extension WHERE extname = 'pglogical';
    -- should return row showing pglogical is installed
   

2. Create replication user which AWS DMS will use to login and grant them the appropriate roles:

    CREATE USER repl_user_from_aws WITH REPLICATION IN ROLE cloudsqlsuperuser LOGIN PASSWORD '<generated password>';
    -- permit AWS' access to pglogical tables
   
    GRANT USAGE ON SCHEMA pglogical TO repl_user_from_aws;
   
    GRANT SELECT ON ALL TABLES IN SCHEMA pglogical TO repl_user_from_aws;
    -- permit AWS' read access to all our tables
   
    GRANT USAGE ON SCHEMA public TO repl_user_from_aws;
   
    GRANT SELECT ON ALL TABLES IN SCHEMA public TO repl_user_from_aws;
   

II. Prep the AWS RDS target database

1. Set the following DB parameters in the parameter group to switch on logical replication

    rds.logical_replication = 1
    session_replication_role = replica
   

2. Setup the following PG extensions:

    CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
    CREATE EXTENSION IF NOT EXISTS  pglogical;
   

3. Fetch the DB schema from the source database and create it on the target RDS DB.

    pg_dump $GCP_DB_ADMIN --schema-only --no-privileges --no-subscriptions --no-publications -Fd -f ./db_schema
   
    pg_restore -Fd -v -n public --single-transaction -s --no-privileges -h <target-db-host> -U <target-db-username> -p 5432 -d <target-db-name> ./db_schema
   
    # pg_restore: connecting to database for restore
    # Password:
    # pg_restore: creating TABLE "public.****"
    # pg_restore: creating TABLE "public.****"
    # pg_restore: creating TABLE "public.****"
    # …
   

4. Validate table schema equivalency between GCP DB and AWS RDS DB

    --- Show columns, indices and constraints counts
   
    ---- column count
    SELECT table_name, count(column_name) AS column_count FROM information_schema.columns WHERE table_schema = 'public' GROUP BY table_name ORDER BY table_name;
   
    ---- index count
    SELECT tablename AS table_name, indexname, COUNT(indexname) AS index_count FROM pg_indexes WHERE schemaname = 'public' GROUP BY indexname, tablename ORDER BY tablename;
   
    ---- constraint count
    SELECT conrelid::regclass AS table_name, COUNT(conname) AS constraint_count FROM pg_constraint WHERE connamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public') GROUP BY table_name ORDER BY table_name;
   

III. Initialize migration with AWS DMS

1. Via the AWS console, create the DMS replication instance with the following settings. Make sure to use the same VPC as the target RDS DB if one exists, otherwise place it in the default VPC.

    name: staging-migrator
    size: dms.t3.medium
    storage: 5 GiB
    vpc: vpc-xxxxxx
    subnet group: default
    high availability: prod (for prod migration), dev for staging migration
    publicly accessible: true
   

   ⚠

   Setting it to be publicly accessible makes your RDS database visible to the internet. Since AWS and GCP are separate cloud providers, this is the easiest way to allow them to connect barring setting up some network peering. Consider that if your security is necessary but for most usecases, enforcing SSL and using a secure password might be enough.

2. Create the source endpoint using the GCP database's credentials.

    name: prod-gcp-db
    engine: PostgreSQL
    server name: <Gigalixir DB host>
    port: 5432
    username: repl_user_from_aws
    password: <repl_user_from_aws password>
    ssl mode: require
    database name: db name
   

   

3. Create the target endpoint using RDS DB credentials. You can use the raw credentials or optionally create and use an AWS SecretsManager secret since your DB is on RDS like I did.

   

4. Create a migration task using the source and target endpoints from the above steps setting migration type as Migrate existing data and replicate ongoing changes.

   💡

   Enable Cloudwatch logging so it's easier to debug in case it halts or there are conflicts.

   Specify the following task settings and table mapping rules in this gist.

Once it starts, it will perform a full load before proceeding to ongoing replication where changes will stream from GCP as they happen. Once it is in ongoing replication it's move to the cutover stage.

IV. Cutover

1. Once the full load of all the tables is completed and it switches to ongoing replication, validate that the target RDS DB tables match the source:

    --- show the row counts for each table.
    --- https://stackoverflow.com/a/2611745/7558991
    WITH tbl AS
    (SELECT table_schema,
    TABLE_NAME
    FROM information_schema.tables
    WHERE TABLE_NAME not like 'pg_%'
    AND table_schema in ('public'))
    SELECT table_schema,
    TABLE_NAME,
    (xpath('/row/c/text()', query_to_xml(format('select count(*) as c from %I.%I', table_schema, TABLE_NAME), FALSE, TRUE, '')))[1]::text::int AS rows_n
    FROM tbl
    ORDER BY TABLE_NAME;
   

   Proceed to cutting over the application only if the row counts match.

2. Switch over your application configs to use the new DB connection credentials postgres://<user>:<password>@<host>:5432/my_app.

3. Once your application is switched over to the RDS DB, stop the DMS migration task.

4. Celebrate (cautiously).

V. Cleanup

1. Drop the replication user and AWS DMS objects from your GCP database

    GRANT ALL on awsdms_ddl_audit TO public; GRANT ALL on awsdms_ddl_audit_c_key_seq TO public;
    ALTER TABLE awsdms_ddl_audit OWNER TO gigalixir_admin;
    REVOKE ALL ON ALL TABLES IN SCHEMA public, pglogical FROM repl_user_from_aws;
    REVOKE ALL ON SCHEMA public, pglogical FROM repl_user_from_aws;
    DROP FUNCTION awsdms_intercept_ddl CASCADE;
    DROP USER repl_user_from_aws;
    DROP TABLE awsdms_ddl_audit CASCADE;
   

2. Revert the RDS DB parameters:

    rds.logical_replication = 0
    session_replication_role = origin
   

3. Remove the DMS replication instance and source & target endpoints.

Evaluation and validation examples

Here’s how some of the validation commands output looked like for me

1. Confirming schema equivalency between source and target

   source:

   

   target:

   

2. Row counts after migration is complete

   source:

   

   target:

   

Conclusion

That's how I did it. Let me know your thoughts and alternative approaches you might have in mind.

I haven't seen a lot of docs on this out there so I'm sharing this. From a high level, it involves detaching the resources from the existing stack, creating the new stack with CDK, translating the code, and then importing your resources into the new stack. In detail:

1. Set a DeletionPolicy on all of your existing stack's resources

We first need to set a DeletionPolicy of "Retain" on each resource in your CF template. This is important since it lets us delete the old stack without removing its resources.

On each resource in your stack, add the following:

AWSTemplateFormatVersion: 2010-09-09
Resources:
   NotificationTopic:
     Type: AWS::SNS::Topic
+    DeletionPolicy: Retain
     Properties:
       TopicName: "MySNSTopic"

Apply the changes to the stack:

aws cloudformation update-stack \
    --stack-name MyOldStack \
    --template-body file://myoldstack.yml

2. Delete the stack to detach the resources

Make sure you've completed the previous step and validate each resource to make sure they aren't deleted.

aws cloudformation delete-stack --stack-name MyOldStack

You can confirm that this is complete via the AWS console. You ought to see the status DELETE_SKIPPED for all the resources in the stack. The resources should continue to exist and function

3. Create the new CDK target stack if doesn't already exist

If it doesn't already exist, add your new target stack in your CDK code and run cdk deploy to create it:

import aws_cdk as cdk

class MyCDKStack(cdk.Stack):
    def __init__(self, scope: cdk.App, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

cdk deploy -e MyCDKStack
# ...
# ✨  Deployment time: 11.83s

# Stack ARN:
# arn:aws:cloudformation:us-east-1:123456789:stack/MyCDKStack/xxxx

# ✨  Total time: 20.41s

4. Define the resources you're importing in the CDK stack code

You'll need to translate all of the CloudFormation template code into whichever language your CDK code is in and add it to your stack. LLMs are incredibly helpful with this and I found the best results with ChatGPT. This is the prompt I used:

transform the following cloudformation template resource into Python CDK code
```
Resources:
   NotificationTopic:
     Type: AWS::SNS::Topic
     DeletionPolicy: Retain
     Properties:
       TopicName: "MySNSTopic"
```

I also had to instruct it severally to use the correct imports in Python by adding a specific instruction "Please rewrite the resource code to use the L2 construct imported from aws_cdk.xyz".

Here is a sample of what it output, added to our stack code from earlier

...
from aws_cdk import aws_sns as sns

class MyCDKStack(cdk.Stack):
    def __init__(self, scope: cdk.App, construct_id: str, **kwargs) -> None:
        ...
        notification_topic = sns.Topic(
            self, 
            "MySNSTopic",
            display_name="MySNSTopic",
            # This is an API detail it got wrong
            # removal_policy=core.RemovalPolicy.RETAIN 
        )

You'll have to do a fair amount of editing and refer to the CDK docs but ChatGPT provided an incredibly convenient starting point. Make sure to include every parameter you have on the live resource or else you may get more diffs after importing.

5. Import the resources into the CDK stack

Once all your resources have been translated into CDK code, run cdk import. This command is still in preview at the time of writing this and may be buggy. It will prompt you to provide resource identifiers of your existing resources:

cdk import MyCDKStack
# The 'cdk import' feature is currently in preview.
# MyCDKStack
# MyCDKStack/MySNSTopic/Resource (AWS::SNS::Topic): enter TopicArn [undefined]: arn:aws:sns:us-east-1:123456789:MySNSTopic
# MyCDKStack: importing resources into stack...
# MyCDKStack: creating CloudFormation changeset...

# ✅  MyCDKStack

6. Diff and update any missing details

Run a diff to see whether there is a difference between the resources you've imported and the code you have defined

cdk diff -e MyCDKStack

If there is a diff, once you resolve them in your code, you can run cdk deploy -e MyCDKStack to apply the changes.

Other notes

• Some resources like AWS SNS topic subscriptions cannot be imported and need to be recreated in your CDK stack. You can find the full list of importable resources here.

• CloudFormation Parameters don't mix well with CDK. If you were relying on this you may want to use environment variables wherein your CDK code is running instead.

• When you use an IAM role on a CDK resource, CDK's default behaviour is to add a new policy for it behind the scenes. This will cause you to see a diff even if you already had a relevant policy defined in the role. To resolve this you may want to use the WithoutPolicyUpdates role object instead i.e.

    role = iam.Role(...)
    some_resource = cdk.SomeResource(role=role.without_policy_updates())
  

1. Finding ideas

Finding the right topic for your workshop can be the biggest reason for procrastinating doing one. Often times, however, the ideas are all around you. One great source of ideas is from your day to day work. What interesting library or framework are you using? What’s an interesting infrastructural problem you’ve resolved recently? Maybe it's meta, how did you improve how you’re measuring and estimating levels of effort for work? How did you improve your code review or hiring processes? In other cases it could be more soft-skill oriented or personal – how did you grow your impact in your team last year? How did you make a transition from software development to product management? What has managing teams taught you?

The list is endless and as long as you’re learning, reflecting and growing, there will always be something you can teach others. Make sure to write down all the ideas that come to mind over time, research them and read what others have written about the topic, saving bookmarks while you’re at it; they’ll come in handy. If a given topic has been exhaustively explored by others, you may still have a differentiating experience with it so avoid binning such ideas prematurely.

When it comes to choosing from your list of ideas, you can weigh each against the impact compared to the level of effort required to prepare it. If it’s your first workshop choose a low-effort idea to make it easier for you to build momentum for higher effort ideas in the future.

2. Define your audience and your goals for them

What’s their experience level? Are they beginners, intermediate or advanced? Do they need some preliminary knowledge to make sense of your presentation? Identifying the goals for your audience is important in helping you better define who they are and better refine your content for them.

For example you may be conducting a workshop on multiplication (the mathematical operation). Some of your goals might be that by the end of the workshop the audience:

• Will be able to multiply single digit numbers
• Will be able to multiply more than 2 numbers together.
• Will be able to multiply negative numbers
• Will be able to multiply fractions

Identifying goals and cases, you will uncover that perhaps your audience is better off memorising the multiplication table or that they may not understand fractions and negative numbers or that you may need to explain the order of operations or that you may need to explain multiplication in terms of addition and so on. You will find that each goal can be expounded upon even deeper but your audience’s experience level will determine how deep you need or want to go e.g. you can cover multiplication of proper fractions but mixed fractions may be out of scope.

This process of breaking down goals for the audience will feed into the next step of creating an outline.

3. Create an outline

Here's a generic structure for an outline:

• Introduction
  • Introduce yourself
  • Introduce your topic and what you’ll be covering
• 1st main idea
  • Theoretical explanation
  • Exemplification from the real world
  • Illustration/exercise (diagram, flowchart, code sample/challenge, analogy, anecdote)
  • Optional supporting idea and/or practical step
    • Explanation and illustration

• 2nd main idea

  …

• Summary of learned skills

• Q&A (question-and-answer)

When starting, it’s important that the audience has an understanding of your level of expertise, background and motivations for the workshop like whether you’re representing your company or will be pushing certain products during your presentation. So begin by introducing yourself then introduce your topic; what you’ll be teaching your audience and your goals for them.

From there, you can begin digging into the substance of your workshop . A good framework for helping others understand complex concepts is the SEE-I method where you take the audience from the theoretical elaboration of the concept then a real world example then an illustration or exercise. Since it’s a workshop and your goal is to impart skills on your audience, err in favour of practical hands-on illustrations that your audience could do or see you do or pose questions to them to keep them on their toes. Of course, the SEE-I method's steps are not set in stone and in some cases where the explanations are too complex or irrelevant for your audience you will be able to do without some of the explicatory steps.

At the end of your presentation, summarise what the audience has learnt and be ready to field their questions.

Here’s a more concrete example outline for a talk titled “Version Control with Git” an intro for beginners (feel free to skim over once you grok the idea):

1. Introduction - 3 min
   • Who is Jane Doe?
   • Objectives for today
2. What is git? - 10 min
   • Git is distributed version control. What is version control? What makes it distributed?
   • Why do developers use git?
   • Visual diagram demonstrating problem of 3 people adding lines to copies of the same file and how they need to reconcile changes when bringing it back together.
   • Let’s install git
     • Run command to install git
3. How does git work? - 20 min
   • Initializing the repository
     • Run git init and describe what the command does; places .git folder in current directory.
   • Adding a new file to the repo
     • Run git add command and describe what staging and the staging environment are. Illustrate using git status.
   • Committing staged changes
     • Run git commit and illustrate using git log to show the created commit
4. Git branches - 15 min
   • What is a branch?
   • How are branches used?
   • Visual diagram demonstrating tree with 2 branches containing the same set of commits and how their histories diverge upon changes to one of them.
   • Let’s create a branch
     • Run git branch command to show all existing and currently checked out branches. Explain branch naming conventions.
     • Run git branch to create new branch following naming conventions. Run git checkout to switch branches and ask audience which command can be ran to prove the branch actually changed.

5. Syncing to remote repositories - 7 min

   … (other content)

6. Summary - 1 min
7. Q&A - 10 min

When writing out your outline, it is imperative that you allocate some time guesstimates for each section based on the total time you’ll have allocated for your session. It'll help you stay on schedule and trim the fat where the time is exceeded. The estimates won’t be very accurate in this initial draft but they’ll help you figure out what’s important and quantify the density of each concept. Editing is king and you should iteratively refine your outline, furnishing it with some margin notes where necessary.

4. Prepare the outline's content

An outline is like a skeleton that needs to be filled up with actual content so prepare the proofs of concept, code samples, questions for the audience and exercises that you’ll be going through in your session.

A slide deck is a really convenient way to pace yourself and deliver your content's key conceptual points. It’s also important that your slides are accessible, in terms of legibility, contrast and font-size. For that, you can find free slide templates on slidesgo.com that are also visually consistent and captivating.

Your diagrams and links to code samples or repositories will go on your slides. You can use free tools like Github Gists for smaller code samples or a Github repo for larger projects and diagrams.net (formerly draw.io) for making diagrams.

After the session it would be valuable to share the slide deck for the audience to revisit. If your presentation software has a speaker notes feature make sure the notes are intelligible for other people! Here is a list of other anti-patterns to look out for when making slides.

5. Rehearse

By this point, your workshop will have a reasonable semblance of completion but it’s not done yet. It’s time to rehearse the presentation. You can do this on your own but you’ll have better feedback by having at least one other person you trust listen to it. During rehearsal, avoid long stops to correct issues you find but instead take short notes that you can revisit later. Take note of how the presentation flows; whether certain subtopics need to be reordered, things that sound ambiguous or slides that throw you off and feel incongruent with the idea you want to deliver.

In addition, practice the audio-visual tools. You don’t want to be fumbling for the "share screen" button on Zoom during presentation. A neat lifehack with Google Slides is the presenter view where you can view your speaker notes on one window and the actual slides on a different window and any transitions you make on the speaker window will change the current slide on the slides window that you’ll have shared with the audience.

Having finished rehearsal, you'll have a better idea of the time-boxes you estimated for each section and resize them accordingly. You will also have caught grammatical errors, smoothened out the flow of your presentation and ultimately have a finished product!

Conclusion

With the right preparation, conducting an online workshop can be less nerve-wracking. It’s a really important skill for developers to have since our industry is founded upon and grown by the free dissemination of information and ideas – amongst other open-source principles. I wrote this because I believe everyone's ideas are valid and valuable so by refining our presentation skills we increase our capacity for impact. All the best with your workshop and let us know how it goes in the comments!

tmux stands for terminal multiplexer. A major use case for tmux is providing access to several terminal sessions through a single window. Most GUI terminal programs like iTerm have this functionality and as most programmers often do, you probably have at least a dozen terminal tabs open right now.

My terminal tabs. tmux allows you to achieve this same tab abyss but on the CLI.

Our focus will be on using tmux to manage windows and be more productive. You can find instructions for installing tmux at the end of this article.

Usage guide

1. We'll SSH into our remote machine.

2. To get started, we'll run $ tmux to start a new session. We should see a green bar appear at the bottom:

3. Now let's say we have some long running job that we want to remain in the foreground:

## this echos 'Running some job' to stdout once every second
$ while true; do echo 'Running some job' && sleep 1 ; done

4. If we need to edit a file using vim or some other editor, this terminal is blocked by our running job. To run other commands, we need to open a new window which we can do by pressing the following keys in sequence Ctrl+b then c:

At the green status bar on the bottom, we can see on the left there's now two windows open 0:bash and 1:bash. 1:bash has an asterisk * next to it to tell us it's the window we're currently viewing.

We'll go ahead and run $ touch code.js to create the file and $ vim code.js to edit it. We add a line of code for the Javascript "hello world" program.

5. We have a problem now. We're trapped in vim and can't get out! While we Google how to exit vim, we decide to go back to the job we were running on step 3 to see how it's progressing. 0 is the identifier for the window we were running our job 0:bash so to switch back to that window, we'll do Ctrl+b 0:

6. Let's say we want to run the Javascript program we created on step 4 but still keep watch of this job we're running. We can split this window either horizontally Ctrl+b " or vertically Ctrl+b %. We'll split it vertically and run our script on the new pane:

To switch between the two panes, we can press Ctrl+b <arrow-left> or Ctrl+b <arrow-right>.

7. Finally, we'll close the extra pane Ctrl+b x.

When you need to look up different commands and what they do, you can Ctrl+b ?. You may have noticed that all the commands we put in were prefixed with Ctrl+b. This is known as the prefix key and whatever comes after it is known as the command key. Thus we scroll down to the section with "bind-key -T prefix" on the help page:

Alternatively, this cheatsheet also comes in handy.

These are a few of the basic commands that'll help you get going, there are dozens more. You can get by knowing only the commands in this article. You may find it a bit difficult to get used to tmux at first and frustrating to keep looking up commands but in a short while, they'll become second nature!

Installing tmux

## Ubuntu / Debian
$ sudo apt-get install tmux
## CentOS
$ sudo yum -y install tmux
## MacOS
$ brew install tmux