For all the wonderful sex and relationship-building Sarah and I have had, we skipped over a lot of the chaste pleasures of meeting and starting a new relationship.  This was by necessity as our relationship has been built upon my ability and our mutual interest in BDSM; my ability was the primary reason I sought Sarah out in the first place.  Regrettably, we missed the Dance: the innocent meet cute; the crush; the flirting on unsure footing; the Does she like me, or is it all in my head?; the burgeoning excitement that at last culminates into a vulnerable confession of feelings and the climactic relief of discovering that those feelings are reciprocated.  We condensed this entire process into a single 26-hour period.

I intend to remedy that, at least in part.

It’s Sarah’s turn to plan a date, and she invited me to go see Ant-Man and the Wasp: Quantumania on Friday.  As clichéd as a movie is for a “first” date, it lends itself perfectly to my idea.

First things first, though.  Sarah has been teaching me a bit about programming and how to organize functions.  One bit she’s explained is that if you would do something in two or more places, it is probably best to abstract a reusable function.  As this will be the second time I’ve planned a scenario in which Sarah forgets that we’ve ever met, and since I want to backfill the Dance over multiple sessions, it makes sense to write such a memory manipulation function.

I begin writing my function on my laptop in order to organize my thoughts.  The parameters will be:

• a name—or perhaps a list of names?—of people whose memories I want to alter
• which memories are forgotten
• the scenario to take place while their memories are altered

Despite my recent growth with my ability, I know instinctively that for this function to work, anyone affected will need to give their explicit consent.  Even Sarah, who’s given me her general consent, will need to. 

Hmm, I think.  Because I’m essentially crafting an early relationship piece-by-piece, each time I use this function, I want us to pick up where we left off since the previous time I used it.  But sometimes, for one-offs like Sarah’s lips-meet-vagina fantasy, I do want her to forget the entire relationship.  I add a fourth parameter to my list: a true/false value determining whether to wipe all memories of our relationship or only the ones since the previous step of the Dance.  And if it is part of the Dance, then which memories are forgotten will already be determined, I think.  Wait, there’s a “corner case” as Sarah calls it: the first time I use this function I will need to specify which memories are forgotten and I’ll need to tell the function it is part of the Dance.

At this point, my head is swimming so I text Sarah and ask if she has some time to help me design this function.

Sarah knocks on my door and I let her in.  We embrace—God, I love being wrapped in her arms—kiss, and gaze stupidly into each others’ eyes for more than a moment.  Then, I restore her feminine physique.

“What’s up?” she asks.

“I want to make a function that temporarily makes the target forget certain memories, but it’s getting kind of complicated.  Sometimes I want to target specific memories, like I did when I had you forget we had ever met and then made it impossible for your lips to move away from my pussy.  Other times I want to make the person pick up where we left off since the last time I had them forget memories.  I’m not sure how to organize it properly, and”—I paste on my best distressed damsel expression—“I am in desperate need of your abstractions.  Help me Sarah-Wan Delfobi; you’re my only hope!”

Sarah snorts.  “Okay, sounds fun.”

Fun, huh?  Such a nerd.  I truly adore her passion and intellect.

“Do you have anything written down yet?”  I nod, and show her to my laptop.  “Alright,” she says after scanning my short document, “this looks like a good start.  What’s ‘the Dance’?”

I blush and explain what I want to use this function for.  I don’t want to ruin the surprise, so I make a mental note to make her forget my explanation when she leaves.  Memory manipulation is the theme of the day, it seems.

“Aww, that’s cute.  I love it!” she says.

Consent received, I think.  “Would it be alright if I tried this out on our date?  I don’t want to step on your toes if you already have something special planned.”

“Be my guest!  I’m, er, not very good at planning dates.  Bringing you to the movie was as far as I got.”

“Then it’s too bad you’ll be attending it alone,” I tease.

“What?”

“Don’t worry about it.”

“Okay, let’s address the simple case first, where memories don’t persist between uses.  First I should explain a programming concept called ‘overloads’.  In many programming languages, you can use the same name for a function with a different number of parameters or different parameter types, and the compiler—the thing that converts text code into instructions the computer can execute—determines which version of the function to use based on which parameters are supplied by the function that calls it.  Does that make sense?”

I gesture “so-so” with my hand.  “An example might help.”

“I suspect as we work through designing this function, overloads will become more clear, but let me know if you don’t understand by the end.”

I nod.

“In the first case,” she continues, “our parameters will be the first three that you listed: a list of names, the targeted memories, and the thing to do while their memories are altered.  I know you understand how to specify the first two.  Do you know how to specify the third one?”  I shake my head.  “That makes sense.  It’s actually a concept that is difficult to grasp for most beginner programmers.  In their minds, functions are these sacred things and treating them like any other object is counterintuitive.  I felt that way until I dove into JavaScript which uses this pattern all over the place.

“When you pass a function into another function, it’s called a ‘callback’.  Naturally, programmers have multiple terms that mean the same thing, but let’s kiss.”

Confused by the non sequitur, I lean in for a kiss.  Sarah snorts and presses her lips to mine.

When we pull back, Sarah says, “KISS is an acronym: keep it simple, stupid.”

I chuckle.  “I’m not sure you wanted me to know that ahead of time.”

“Trust your instincts.

“Anyway, callback functions define arbitrary code that you want the ‘wrapping function’ to execute, usually somewhere in the middle of the wrapping function.  In this case, our wrapping function– err, do you have a name for this you want to use?”

I consider for a second.  “Donald Duck?”

“Ha!  Nice.”

“How about ‘with forgotten memories’?”

“Perfect.  So, this overload of WithForgottenMemories will erase the specified memories from the target or targets’ minds, call our scenario callback function, and then restore those same specified memories.”  She taps out some “pseudo-code” as programmers call it.

// makes the specified list of people forget the described memories for

// the duration of the specified scenario

function WithForgottenMemories(

  people: List<Person>,

  memoriesToForget: List<Memory>,

  scenario: Function

):

  forEach person in people:

    forEach memory in memoriesToForget:

      person.Forget(memory)

 

  scenario()

 

  // when Speaking, this can probably just be “restore everyone’s

  // temporarily forgotten memories”

  forEach person in people:

    forEach memory in memoriesToForget:

      person.Remember(memory)

I read the function.  The syntax is still new to me, but I think I understand what’s happening.  “So in this case, the ‘scenario’ parameter is the callback?”

“Exactly!”  She beams at me, and I feel the warmth of her pride.  It bolsters my own esteem.  “I’m going to assume that your intent when creating this function will ensure that each memory is tied to the person who made it.  That is, we don’t want people to remember other people’s memories.”

I nod.  “Makes sense.  I’ll remember that when I Speak this function into existence.”

Sarah pauses, then.

“What?” I ask.

“Oh, I’m just considering whether to explain the programming concept called ‘attributes’, but let’s KISS and come back to that later.”  She looks at me expectantly and puckers her lips.  I giggle and give her a quick peck.

“Now for the more complicated overload,” she says, “where memories from previous scenarios persist.  If we were writing this as a computer program, we would need to save those memories somewhere permanent so that when the program ends and starts up again, the function can load them.  This would usually be a file or a database.  With your ability, I think we should be able to say something like ‘store these memories for future use’ and ‘load this person’s stored memories’.  Your intent should be enough to make it work without getting into the nitty-gritty details.”

I take her word for it.

“Huh,” she says after a pause.  “Your ability really feels like cheating sometimes.  I wish I could write computer programs with the hand-wavy shortcuts that Speaking allows.”  She begins to type out some more pseudo-code, then pauses and smacks her forehead.

“What?” I ask, somewhat alarmed.

“Well, I had thought overloads would be best for this, but as I think about it, your corner case—the first time we handle the Dance—and good job identifying that, by the way—presents a problem.”  I feel my cheeks heat at the praise.  “In that case, you do want to specify which memories to forget.  Unless….”

“Unless what?”

“Well, will there ever be a case where you want the target to forget something other than their relationship with the other people in our list?”

I consider.  “Hmm, no I don’t think so.”

“Good, that will simplify things.”  She resumes typing.  I watch as she writes one version, then deletes sections and moves them around to simplify the code.  After three versions and—I glance at the clock—forty-five minutes, Sarah turns to me, indicating that she’s finished.  Compelling, Hollywood-style hacking this was not.

I read through the code a few times, trying to grasp its meaning.

// since this is an overload, when you Speak, you might say something

// like “Overload WithForgottenMemories” so that you don’t simply

// override the first version

//

// 1. makes the specified people forget everything about each other

// 2. restores the memories made during previous scenarios using this

//    wrapper function

// 3. runs specified scenario

// 4. restores all temporarily forgotten memories

// 5. saves the memories made during the scenario so they can be

//    restored in the next scenario augmented by this function

function WithForgottenMemories(

  people: List<Person>,

  scenario: Function

):

  let memoriesToForget = new List<Memory>()

 

  forEach targetPerson in people:

    // don’t forget memories about oneself

    // likely your intent will be enough to handle this case

    forEach otherPerson in people.Exclude(targetPerson):

      let memoriesAboutOtherPerson =

        targetPerson

          .GetMemoriesAbout(otherPerson)

          .Exclude(danceMemoryStorage.Get(targetPerson))

 

      forEach memory in memoriesAboutOtherPerson:

        memoriesToForget.Add(memory)

 

  // store a snapshot of all memories so later we can determine which

  // new memories should be added to the Dance memory storage

  let previousMemories = new List<Memory>()

  forEach person in people:

    previousMemories.AddMany(person.GetMemories())

  

  WithForgottenMemories(people, memoriesToForget, scenario)

 

  // Speak something like “Each person’s new memories made during this

  // scenario are stored in the Dance memory storage”

  forEach person in people:

    danceMemoryStorage

      .Get(person)

      .AddMany(person.GetMemories().Exclude(previousMemories))

“It looks,” I say, “like toward the end of this overload, we call the function again.  That seems strange.  Wouldn’t that create an infinite loop?  Is that the right term?”

“It is the right term, but see how there are three parameters in that function call instead of two?  That means that it will call our first overload which simply makes the person forget the specified memories, calls the callback—the scenario you want to play out—and then restores all the forgotten memories.  This second overload is, itself, a wrapper function for the first one.

“I’m not sure how closely you were watching me type, but the first two versions were much more efficient, though more complicated.  What I’ve written for the final version would be very slow for a computer to handle: lots of repetition of work for stuff that we could just store in the computer’s memory, but it’s also much simpler to convert into English for Speaking.”

“I appreciate that,” I say with a smile.  She nods.

“That gets me wondering.  Does your ability care about efficiency?  Is it instantaneous or does it take time to process?”

I blanch at the question.  “I honestly have no idea.”

“Me neither.  Something for future testing, but for now, I suspect you want to get on with planning whatever it is you want to use this function for, yeah?”

“That or make out with you and that big, nerdy brain of yours.”  She smiles.  I find competence and passion really sexy, and Sarah writing out this code and teaching me what it means has made me hot for her.  I pull her to my bed with an invisible leash and I have my way with her.

As Sarah leaves my room, I Speak, “Sarah forgets everything related to the Dance.  She remembers helping me with our programming framework, but the details are fuzzy.  She will not bother trying to remember them more clearly.”

Now to Speak Sarah’s code into existence.  “Whenev–” I say, then cut off as an idea occurs to me.  “Convert the code Sarah wrote here to English and apply it as if I Spoke it.”  Did it work?  How would I test that?  Then it occurs to me: I didn’t feel any energy drain.  For reasons I don’t understand yet, it seems I’ll have to do this the old-fashion way.  Maybe because I didn’t write it?  Or maybe it’s that I don’t have an intricate grasp of what precisely is going on?

Eh, whatever, I think, and I get to work on converting the code to English and Speaking my new functions.  Once complete, I Speak, “The next time Sarah hands me a movie ticket, with forgotten memories for Sarah and me, we will enter the theater separately and find it completely normal to watch a movie alone.”  From there, I finish Speaking out the scenario.

“I forget I set up this scenario and will make no further plans for this date.”