Forem: Dr Nicole Jacqueline Martin

Building "Journal Buddy": A Custom GPT for Personal Reflection

Dr Nicole Jacqueline Martin — Thu, 11 Apr 2024 18:18:04 +0000

I've always wanted to be able to write a daily journal. The science is pretty clear about the benefits of journalling for mental health and wellbeing. The problem is, I'm not that good at writing and the thought of staring at a blank sheet of paper each day fills me with dread. There are other practical problems, I would need to remember to lug a notebook and pen around with me everywhere. It just seems impractical and a tricky habit to get to stick.

I recently read about GPT Actions available when you create a Custom GPT on OpenAI's platform. I've become increasingly reliant on GPT-4 as a useful pair programmer in my daily work as an engineer but had not explored making GPTs. I started thinking about creating a GPT that could help me specifically with journalling. I landed on a set of requirements for the MVP:

Provides useful prompts so that journalling is more of a conversation as opposed to a blank sheet of paper.
Has memory that so that it can prompt based on past events.
Can challenge you if you say things that contradict previous things.
Has appropriate privacy, I didn't want OpenAI using my journal.

This article delves into the technical intricacies of implementing "Journal Buddy" to meet the requirements above.

TLDR; It was super easy to implement and works surprisingly well.

How it works

Database

I spun up a simple MongoDB Atlas instance to store journal entries. These are simple objects containing a date and some markdown for the entry. The idea is that it isn't a full transcript of the conversation with Journal Buddy, but a summary that Journal Buddy creates.

HTTP API

I wrote a very minimal API in Go that has a GET route that currently just gets all the summary entries and a POST route that upserts a new summary on a specific date. At some point, this will probably be extended so I can get Journal Buddy to do either weekly or monthly summaries. The idea here is to provide more fine-grained data for more recent entries when getting context. For example, Journal Buddy could retrieve the daily summary for the past month, a monthly summary for 3 months preceding that, and then a yearly summary before that. I hosted this on Heroku and chucked some basic API key auth to keep things secure.

Custom GPT

The final piece of the puzzle was to create the custom GPT, this was as simple as describing what I wanted it to do and providing a bit of background about myself so each new instance would have the right context. Then I had to provide it with an OpenAPI schema so it knew how to interact with my API. It still blows my mind a little that all I have to do is give it this and it can parse it and understand how to use it. To be honest, this was the most difficult step since the default schema that Gorilla kicks out is version 2 as version 3 isn't supported, I ended up having to feed it through a converter and make some manual changes to get it to work.

Here's a screenshot of the final product:

You just have a chat to it and it prompts you with questions that help you reflect on your day and how you're feeling. It then summarises the conversation and stores it back in your private database.

You can even ask it to remind you of things that happened in the past, which is great for someone like me who is always forgetting things!

Overall, I'm super happy with Journal Buddy! I think someone even with fairly basic software experience could put something similar together. I'm interested in what other things I can do with GPT Actions, next on the list is to try and give a GPT eyes and a body by connecting one to a robot 🤖.

Pattern matching 💖 decision tables

Dr Nicole Jacqueline Martin — Wed, 10 Aug 2022 08:03:00 +0000

Have you ever found yourself writing a massive nested if statement and thinking, 🤮? If so, this might be the post for you.

First, lets talk about the problem. It's not uncommon when developing systems to have to implement some business logic that can be represented abstractly by a flow chart or decision tree. Below is an example of a fairly simple tree/chart to use as an example. Obviously it's likely that your own problem could be much more complicated that this, but hopefully it will serve to illustrate the point:

This decision tree represents the business logic behind which type of apostrophe you should use (or not) in any given situation. It isn't uncommon for Domain Experts to illustrate their business logic through the use of a decision tree similar to this.

Decision trees can be directly mapped to my preffered way of displaying this type of information, a decision table. In a decision table, we take the question nodes in the tree and put them along the top row. Then we create an extra column on the right of the table and fill in the "actions" we should take, these are the leaf nodes in our decision tree. Then we fill in all of the different possibile ansers to our question node, in our case true (✔️) false (❌) or either (🤷).

Decision tables (and trees) are composable, so it's possible to nest them into smaller subtables (or trees). Here are three tables that represent the decision tree above.

Plural?	Single letter?	Abbreviation?
❌	🤷	🤷	See Possessive table
✔️	✔️	🤷	Apostrophe + s
✔️	❌	✔️	Apostrophe + s
✔️	❌	❌	No Apostrophe

Plural table

Possessive?	Is it "it"?	"it is" or "it has"?	name ending in s?	plural name?	ends in s?
❌	🤷	🤷	🤷	🤷	🤷	See Contraction table
✔️	✔️	✔️	🤷	🤷	🤷	Apostrophe + s
✔️	✔️	❌	🤷	🤷	🤷	No Apostrophe
✔️	❌	🤷	✔️	🤷	🤷	Apostrophe at end
✔️	❌	🤷	❌	✔️	🤷	Apostrophe at end
✔️	❌	🤷	❌	❌	✔️	Apostrophe at end
✔️	❌	🤷	❌	❌	❌	Apostrophe + s

Possessive table

Contraction?	Pronoun?	with a verb?
❌	🤷	🤷	No Apostrophe
✔️	✔️	✔️	Use Apostrophe
✔️	❌	🤷	Use Apostrophe
✔️	✔️	❌	No Apostrophe

Contraction table

If your working with a Domain Expert who likes to use decision trees consider asking them to switch over to using tables instead.

Okay, so we've got the logic for our Domain, now how do we implement this in code? We could choose to write a fairly large nested if statement. Or alternatively, if we're given a tree, why not represent this information as a tree? We could create a tree structure with nodes, edges and leaves and model this directly.

These could would work, but have a couple of issues. If our Domain Expert comes back and tells us that the business logic has changed and provides a new tree. It's not so easy to translate the new logic into the code with either of these two methods. There's no direct mapping and in general it can be hard to look at a large nested if statement (assuming you can fit on a single screen) and easily determin the logic behind it.

Pattern matching FTW!

Using pattern matching is my prefered solution to this problem. We can take our decision table(s) and directly map them to code in a way that looks and feels much very similar to the original information.

Lets take the tables above and illustrate them as an example. I'm going to use Rust because it has a great type system and pattern matching built-in. Most languages now support this kind of syntax (I don't think JavaScript does... 🤨).

The whitespace formatting I've chosen is here to help illustrate how closely linked the two concepts are and to help read the table, it's a personal preference thing though.

If you're using a language with a good type system and compiler, then the added benefit of using pattern matching is that you get compile time checking of your logic. Unlike a series of if statements, you'll be warned if one of your patterns (table rows) are unreachable or if you've missed any cases. In C# you'll get a compiler warning with a nice hint suggesting cases that you've missed. It's not uncommon to include a catch-all case at the end where you can decide what to - perhaps throw an error.

That's all really! Let me know in the comments what you think of this patern, have you used it before? Would you use it? Are there any other solutions you've found that work better?

A more functional approach to Event Sourcing and DDD

Dr Nicole Jacqueline Martin — Mon, 11 Jul 2022 21:32:04 +0000

I've spent a bit of time outside of my day-to-day work playing around with functional languages, F# being my favourite so far. In particular the book Domain Driven Design Made Functional by Scott Wlaschin is well worth a read, whether you are into functional programming or not. Scott is also the author of the excellent F# for fun and profit website.

I decided I wanted to use some of the benefits of functional programming in a C# project. C# 9 has seen some great additions to the language, including pattern matching and record types. These along with some patterns borrowed from functional programming play really nicely when developing Domain Models. Many of the ideas I'm going to talk about here have been inspired by Scott, but also Greg Young.

The full source code can be found here.

Rock 🪨, Paper 📃, Scissors ✂️

I wanted a simple domain to test out these concepts, so I went with the game Rock Paper Scissors. In this game, we only have two commands:

Create Game: A new game instance is started with a UUID
Make Move: The players take it in turns to make a move, each player has one move

Once the second move has been made, an end game state is reached with either one of the players winning or the game is tied.

The first departure from "regular" Domain Driven Design is in how we raise and process Domain Events. In most examples I've found online, Domain events are raised by either storing them inside the aggregate root in some List structure, or outside in the Application layer, usually by injecting something into the method. Here we use a different technique, each command returns a list of events. Many people will immediately jump to the fact that this is against CQRS and the "Tell Don't Ask" principal. In this case however, we're not returning part of the object state to manipulate somewhere else (which is what these principals were design to prevent). Instead, we're returning a list of events that describe how the state should be changed. Importantly, we've already carried out the business logic to check if these events are viable, now they are just facts that must be applied to our aggregate or entity. The example below is the Handle method for the Make Move event.

As you can see, I'm using a command handler pattern, where state isn't mutated inside the aggregate at all, but the business logic for whether or not these events can be raised still resides here.

Typically, we would then apply these events to the aggregate so that the state can be mutated. In this approach though, instead of mutating the state, a new instance of the Game aggregate is returned based on the event in question. Here, there aren't that many events to worry about, so I have a single static method, with a pattern matching switch statement to deal with each event type. It would also be possible to create separate methods to deal with specific events.

How do we deal with the domain events when they're returned? These events are handled at the application layer, where they should be, since the details of what happens to them shouldn't be of concern to the Domain Model. In fact, we can prescribe a very clear set of steps that should be the same for every task:

Retrieve a list of domain events from the store relating to the aggregate in question.
Apply a left fold over the events to get the current state of the aggregate.
Issue the command to the aggregate in order to get a new set of events.
Append those new events to the store.

In code, this looks something like this:

As it should be clear now, a left fold is where we apply an accumulator function recursively to a sequence. In C# we can achieve this result using the built-in Aggregate method.

Overall, these techniques should help make a codebase more declarative and easier to reason about. I wont go into all of the other advantages here - although there are plenty. One of those benefits is in how we can start to do application level integration tests. The following snippet shows the test for a game that results in a tie:

Hopefully this shows how, just because you don't explicitly keep track of the state of your application, you can still test for the required behaviour and in a way that in my opinion make testing simple.

There are a few more things I'd like to do to with this code, including converting the domain model to F# and looking at a multi paradigm approach to the application. I'm still fairly new to the world of functional programming (and ES/DDD!), so would be very happy to receive feedback in the comments for how I can improve things.

Dealing with imposter syndrome

Dr Nicole Jacqueline Martin — Mon, 11 Jul 2022 18:53:32 +0000

I have spent two decades solving problems by writing code and developing software. Despite this, I still find it hard to not feel like I'm both under-qualified for my role as a software developer and that I'm fraud, who has managed to pull the wool over the eyes of the people I work with. In other words, I am susceptible to feelings of imposter syndrome.

I want to start by saying that I'm not a an expert on imposter syndrome. This post is a reflection on the experiences I've had throughout my career. I hope that perhaps by reading this it might help others, particularly those earlier in their career who might have similar struggles. That being said, if you're looking for help on imposter syndrome or want to learn more about it, then I'd recommend taking a look at this TED talk by Elizabeth Cox as well as this one by Mike Cannon.

This post depicts how imposter syndrome has effected me as a white, straight, cis man. Imposter syndrome is a gendered and racialised issue meaning its impact can be far more profound for minoritised groups. As a final disclaimer, I want to add that the intention of this post is not to suggest there's a problem with individuals or that individuals hold the solution, there are systemic issues that need addressing.

I first got hooked on writing software when I was doing my A-levels (aged 16 in the UK) and my Maths teacher gave me a numerical methods project and I wrote a little application to solve equations using Newton's Method. I remember thinking how it was almost like magic how the computer did what I commanded it - a feeling that I still get even today!

I studied Aerospace Engineering at University. I took additional modules that would allow me to broaden coding skills, mostly with Fortran and with the engineering focus we also learnt Matlab. I tried to cram as much coding into every module I could. The Computer Aided Design module I took, where typically you learn how to use a specific piece of software, I chose to use the built-in scripting languages to build my models in a fully parametrised way. I graduated with the highest degree in my year and won awards for my dissertation. I went on to do a PhD, where through the ever increasing amount of online resources available I taught myself Python, C++ and LabView (an intriguing visual language for interacting with hardware).

When choosing a career after my PhD it seemed like a no brainer that I should go into Engineering and work as an engineer. The idea of a self-taught person doing "real" software development didn't seem possible to me. So I got a job in the aerodynamics department of a Formula 1 team. However, I quite quickly realised that both my passion to develop software and the lack of software developers in the department meant that I quickly started "side hustling" as developer. I constantly felt like I was having to justify to myself as well as to my superiors the software work I was doing. Despite this, my main contributions to the department in my time there, where all based around these specific projects:

Developing data visualisation tools.
Replacing legacy excel worksheets with "proper" software.
Designing Machine Learning models of the aerodynamic forces on the car.
Implementing new software systems to drive and process data from the Wind Tunnel.
Using software to automate the use of Particle Imaging Velocimetry during testing.

I learnt lots in my time working in F1 and the experience underlined my love of developing software. What's more, the work I did helped the aerodynamics department see the importance of having "full time" software developers as opposed to engineers doing some software "on the side". But when the time came for me to step up and fully take on such a role, I was overlooked. Part of the reason for this was because despite now having "proved myself" there was a voice inside me saying - but you're not a software developer, you don't have any qualifications, you're self taught, you're a fraud, you can't do it. So instead of putting myself forwards, I stepped back.

Not too long after this happened, my wife and I decided to relocate 400 kilometres north to another part of the country. Remote working wasn't really a thing back then, I had to find a new job outside of Formula 1. I brushed off my CV and decided I had two options really: return to academia after a long stint in industry or follow a new (sort of) career in software development.

Every software developer interview I had I remember immediately sitting down and feeling like a fraud. When I passed technical interviews and got feedback on how I was doing I could hardly believe that it was positive and that most places even wanted to hire me! In the end I had a few roles to choose from, including one at a University, which would see me returning to academia. I sat talking through the options with my wife. Looking back on that conversation now, I managed to convince myself that I should go with the role in academia because "I was using my PhD" - which in hindsight is a terrible reason. In my heart I knew I wanted to write code, that's my passion, that's what I love. But I wouldn't allow myself to do that because of my imposter syndrome.

Taking the job at the university was the worst decision I've ever made in my career. Coming back to academia and building up your research, whilst also having a heavy teaching workload are not easy and this coupled with some workplace bullying did not make for a fulfilling experience. That aside, even in this role, I looked for ways to itch my never ending need to develop software. I based my research around projects that would involve me writing code and I used numerical methods to bolster the pure maths that I taught in the classical mechanics lectures. After a year of working the hardest and longest hours that I have ever in my career with no positive feedback or support from the institution I worked for, I quit.

I went from the worst career decision of my life, to the best. I have a very vivid memory of it, it was a Friday morning and I was reading about a local company when I was on the metro to work. They were called Tharsus and their business was to design and manufacture robots and smart machines. After what I can only describe as the worst line manager meeting I've ever had, I came back home feeling depressed, spoke to my wife, who promptly told me "you need to quit and get a new job". Remembering the company I had read about on the metro, I pulled open my laptop and surfed up their careers page. There was an opening for a data scientist role. I wouldn't class myself as a data scientist, but the job description seemed to focus mostly on writing and implementing software.

To cut a very long story short(er) I got the job at Tharsus and within weeks it was clear that my skills lay squarely as a software developer and I've never looked back. I've been working there for three and a half years now. We do incredible stuff, work with new technologies and on a variety of domains.

Despite everything I've been through there are still times when I feel like I'm a fraud. When I feel like someone will see through the smoke and mirrors carefully constructed around me. Like I'll be "found out" and told I shouldn't be doing what I'm doing because I'm not up to the job. This doesn't happen as often as it used to - and to be clear, objectively I know this not to be the case. But when I'm having a bad day or something else in my life outside of work is on my mind, I can feel these nagging thoughts start to creep in.

My advice for anyone else who has these feelings is to:

Tell someone close whose opinion you trust. They will be able to tell you how it really is (you're not a fraud) and hearing it from someone else is sometimes all you need.
Write down objectively why you should be doing what you do. Going through the exercise of writing this post, I can see objectively that there's no reason I should feel imposter syndrome
Don't let your own opinion of yourself get in the way of trying new things. If you want to try a different career, let the people hiring decide if you can do it or not. Otherwise, be confident in your own abilities.

Improving code using the Trinity of Quality

Dr Nicole Jacqueline Martin — Thu, 30 Jun 2022 08:26:32 +0000

I watched this YouTube video recently by Minute Physics (who I highly recommend subscribing to) on the Trinity of Quality, a concept I had not heard of before, but I think it maps directly onto something I think about most days: how to improve the quality of mine and my teams code.

The Trinity of Quality according to Henry Reich (the creator of Minute Physics) is a triangle, made up of three corners:

Quality: How good something actually is
Taste: How good you think something should be
Discernment: How well you can determine Quality

I'll briefly talk about what these mean in more detail, but I suggest you watch the video for a more in depth look at each of the corners.

Quality

How good is the thing your looking at? This can be both objective or subjective. The quality of your code is made up of a multitude of different factors, some of these are very objective: do you have a syntax error, will this function pass it's unit tests, is it even possible to test the code? Some are less subjective: how whitespace has been used, how granular functions are, the naming of variables.

Taste

Or preference. This is a personal viewpoint about the Quality of something. Are you a code perfectionist, do you think all of the metrics that define code quality should be at their highest or do you care more about the function of the code? If it does what it needs to do and passes all it's unit tests, who cares what it looks like under the hood?

So Quality is how good something is on a scale, while Taste is where we think it should be:

Focusing just on how to make something is good is where we usually go when trying to improve our code. But the problem with this is that there is a more useful skill: How good are you at determining how good something is?

Discernment

This is the most under-looked, but potentially the most important corner of the Trinity. If Quality is where your code is on a scale and Taste is where you want it to be, then Discernment is how good you are at being able to determine how good your code is, it's your error bars on your code checking skills. If they are wide, then even if we have high standards (Taste) we wont necessarily be able to determine if our code meets those or we might think that it has even when it hasn't:

While there are plenty of rules of thumb or even best practices for how good our code is, these don't always work and sometimes we don't really know why code is good.

Someone who is more discerning than me who has the same Taste (or preference or standards) might deem my code not to of high enough quality to meet their taste:

Being more discerning as software developers allows us to be better judges on both on how good our own code is, but also on other people's code when we do code reviews.

Taste and Discernment are linked but are not the same. Training yourself to be more discerning might lead you to change your Taste, but there's always an underlying truth, so improving ability to Discern the Quality of code is an important skill. In the video, Henry describes a number of ways that differing discernment between people can lead to issues when working together with others. Not to mention that being more discerning in general should improve your code Quality, how can you improve if you aren't able to reliably measure that?

There are ways to improve your discernment, here are some tips you can apply:

Give yourself time to do code reviews, don't rush them.
Speak to others, don't do your code reviews in isolation
Try to concentrate on objective, rather than subjective Qualities when reviewing code.
Conduct your own code reviews, do this regularly throughout your development cycle.

But overall, I think it's just important when reviewing your code or others, to remember the Trinity of Quality. Is the reason you don't feel someone's code is of the correct Quality because of your Taste (or standards) or is it because you aren't be discerning enough to know?

Cover art by John Schnobrich.

Show Spotify Now Playing in Twitch Studio

Dr Nicole Jacqueline Martin — Sun, 26 Jun 2022 22:08:24 +0000

I decided recently that I would start live coding my personal projects outside of work on Twitch🚀. It's something I've always considered and after reading about how it can help improve your productivity I thought I'd give it a go (here's my channel 😎).

Obviously, before actually starting my first stream I had to procrastinate a little.. so I spent some time getting everything setup. I had originally planned on using OBS as my streaming software, but ended up choosing Twitch's own software "Twitch Studio" as it seemed to be more user friendly for the newbie streamer. For the most part it is, but I quickly ran into a problem.

I managed to get everything setup apart from the ability to display my currently playing song from Spotify. While this is a little bit of an unnecessary addition to my overlay - I thought a tiny bit of extra effort to get it right would be worth it.

Turns out it's not that straight forward to setup 🙄. I couldn't easily find a solution without writing my own HTML page - so that's what I did. I thought I'd post what I came up with here to save someone else 30 minutes of their life...

The full HTML page is saved in a Gist on GitHub (sorry for my terrible JavaScript):

The JS just uses the last.fm API to grab your most recently played track(s) from their API. It continues to ping it every 10 seconds (which is fast enough for a Now playing feed). I made a little card to display it nicely.

To get it up and running, just add a Browser Source Layer to the scene you want your feed to appear in and then open the HTML file (which you should save locally). You'll need to edit the HTML to include your own Auth Token from LastFM - which you can grab from their API documentation easily enough. You will also need to hook up your Spotify account to LastFM. Obviously you shouldn't host this page anywhere or people could steal your Token...

A brief note as well that you shouldn't stream with any copyrighted music or you could get banned from Twitch. There are lots of playlists you can choose from, two of my favourites are this one and this one 🦄.

That's all really, not too much to it!

Cover art by Maik Jonietz