DEV Community: Kenny Dubroff (froggomad)

Why is ChatGPT talking to itself?

Kenny Dubroff (froggomad) — Sat, 27 May 2023 21:43:20 +0000

Human Language as a Programming Language

Today we’re going to take a break from programming (sort-of) and discuss a unique take on improving ChatGPT’s problem solving abilities.

I’ve recently been leveraging AI to create children’s coloring books. I have zero artistic creativity, but so far I’ve been able to publish several and with each iteration I explore new ways to automate the process. I’m to the point now where I can create around a 120–200 page coloring book in less than an hour. But I have a problem…

I’m not making any sales

I’m not really surprised since my focus has been entirely on generating “passable” content in the quickest way possible. I have some focus on quality as well beyond passing the publisher’s quality checks, but I digress. So far I’ve made $0.13 in royalties and I’d like to start improving that. So I thought I’d leverage AI more and start getting ChatGPT to write my titles, marketing descriptions, and choose keywords. “Default” ChatGPT does well enough at this, excelling at creativity, but without direction, the results won’t be great… and could even get you slapped with a takedown order or lawsuit.

Prediction Engine

When I first started using ChatGPT, I approached it as if it were a search engine and this produced far better results than using a search engine. I remember telling everyone I came across that it was amazing — it was like “having a conversation with Google”. But I soon started running into the common problems we have with large language models in the form of “hallucinations” (the model tells you a wrong answer with 100% confidence that it’s truthful and accurate).

Since it’s a prediction model, if you don’t “shape” it, it will sort-of blindly predict what comes next and may give you more misleading information than if you give it a specific role. It’s not trying to do that at all, and there are safeguards in place to prevent things like that from happening, but in my experience, it needs a lot of help from me in pointing out mistakes and errors. This is not only time-consuming, but eats away at my (currently limited) number of messages I can exchange with GPT-4 (the latest ChatGPT model).

My First Attempt at a Good Title May Have Resulted in a Lawsuit 👮

My latest coloring book features princesses in various situations. I know ChatGPT does better with more information, so I gave it a general purpose and fed it a bunch of my prompts.

Did ChatGPT just say the “D” word? In my title? That I’m commercializing… yeah pretty sure that’s not ok… and Barbiecore seems a little dicey.

Ok, let’s break that interaction down in reverse:

ChatGPT is aware of the legal consequences of using another entity’s trademark
ChatGPT is aware that Disney is trademarked
ChatGPT is aware I want to generate revenue
ChatGPT advised me to use Disney

While #4 isn’t strictly a hallucination because I didn’t ask “not to get sued”, ChatGPT generally attempts to look out for a user’s well-being and provides disclaimers when it notices something in its advice may be harmful to the user.

Further, I asked about the use of “BarbieCore” and ChatGPT admitted this is a gray area since Mattel doesn’t hold a trademark over “BarbieCore” and it is a widely-used term, but it could bring legal consequences anyway.

So what can we do to reduce hallucinations such as this?

Human Language as a Programming Language

A lot of software developers are afraid of losing their jobs to AI right now, but I think we’re probably in one of the best positions to be in for a number of reasons that I’ll maybe explore in another post. In this one, I’ll focus on the one that makes the most logical sense to me — using my words as a tool to shape and manipulate a software application.

Role-Playing with AI

One of the most effective strategies I’ve found for shaping and manipulating AI chat bots, particularly ChatGPT, is role-playing. This involves simulating a conversation between different roles, each with their own unique perspective and objectives. For example, in my coloring book project, I simulated a conversation between a kindergarten teacher, a marketing professional, a business professional, and a legal professional.

The kindergarten teacher’s role was to focus on the well-being of children, suggesting ideas that would be exciting and engaging for them. The marketing professional’s role was to focus on revenue generation, emphasizing the need to appeal to parents who would be making the purchase. The business professional kept the conversation focused on the topic of generating revenue, and the legal professional ensured all suggestions were legally sound.

This role-play approach led to a more comprehensive and balanced discussion. It allowed the AI to consider a wider range of perspectives and generate solutions that were more comprehensive and balanced. It also made the conversation more engaging and relatable, as I could see my own concerns and objectives reflected in the different roles.

Establishing a Baseline

I don’t know the inner-workings of ChatGPT, but I know when I design chat bots using large language models, I direct them with a role and formatting instructions to begin with and I ensure this message is carried forward in every conversation had with the bot so it’s always directed. I also carry the user’s first message forward, or first few messages depending on token usage. This ensures that the bot is directed by me for use in my application as I intend and also meets the user’s goals.

I assume ChatGPT is the same, and maybe they’ve built some “forgetting” into their “memory”. My best bet actually probably would’ve been to start a new conversation, but this worked this time.

There’s a lot going on here, so let’s break that down:

I reset the conversation by asking ChatGPT to forget all prior messages and use this message as a baseline. I then introduced my problem (not making sales). Then I introduced the key players in the conversation and their roles. Finally, I used a separator, then asked for what I was seeking — a title, description, and 7 keywords.

As I mentioned, resetting the conversation may not always be effective so it may be best to start fresh with a new conversation. What you should definitely do is introduce your problem, think about people you’d like to have on your “team” if you were solving this problem together, and specify what their focus is in the conversation

The Power of Directed Conversation

This strategy of directed conversation, using human language as a programming language, has the potential to greatly improve the problem-solving abilities of AI like ChatGPT. By providing clear direction and context, we can guide the AI towards more accurate and useful predictions. This can help to avoid the issue of “hallucinations” and make the AI a more reliable and effective tool.

In my case, this approach helped ChatGPT to generate more effective titles, descriptions, and keywords for my coloring books. It also helped me to avoid potential legal issues by ensuring that all suggestions were legally sound.

Testing This Approach

Ok, but was it really effective? What would happen for instance if someone purposefully asked one of the players to do something legally questionable? 😅

Looking Ahead

As AI continues to evolve, I believe that strategies like role-playing will become increasingly important. They allow us to harness the power of AI in a more controlled and directed way, leading to better outcomes and fewer errors. As software developers, we are in a unique position to leverage these strategies due to our well-honed ability to direct, shape, and create software applications using language (natural and otherwise).

So, while AI may be changing the landscape of software development, I see it as an opportunity rather than a threat. By embracing new strategies and approaches, we can continue to innovate and create value in this exciting field. And who knows? Maybe one day, we’ll all be having conversations with entire codebases, refactoring them to our heart’s content with a mere phrase such as “Make this codebase more modular”.

How I Use Xcode's Template Library To Reduce Boredom

Kenny Dubroff (froggomad) — Tue, 24 Nov 2020 15:39:11 +0000

If you're anything like me, you make a lot of Xcode projects. You also may have noticed that if you like your projects organized a certain way, perhaps by a certain paradigm - then you're doing a lot of repetitive, boring work.

Repetitive, boring, work?

But... I'm a programmer

I know, right? Aren't we supposed to be automating things? I think we are. So why the heck are we manually rearranging our files and folders? Haven't we noticed yet that we can create different kinds of projects in Xcode and they come with different files and folders?

Have you ever wondered just how they generate all that code? Me too, so let's find out...

What exactly can you generate with a template?

files, folders, groups, dynamic lines of code

In this tutorial, we'll be building a simple file template with dynamically generated code. Trust me... you definitely don't want me to cover everything you can do with a template in one tutorial. It's a lot - you can even customize entire projects up to and beyond editing and adding entries to your info.plist file.

Generating Files

With this:

You'll get to make a model file that conforms to Equatable, each time with a different name for the file and class:

File->New->File Dialog

New Model With Equatable Conformance!

The Anatomy of a Template

At their core, templates are pretty simply woven together. You have a folder with the extension .xctemplate and a .plist file in that folder named TemplateInfo.plist. From there, you can make things pretty complex, but it's easy to get "in the weeds" pretty quickly. We could generate a file solely in the TemplateInfo.plist file if we use the right options and do everything just right, but let's keep this simple and see how you can start putting the Xcode Template engine to use right away to cut down on a little bit of boilerplate code.

1. Find the Folder Where Custom Templates Go

Xcode's default templates live in various places inside of the Xcode App Package. We could store our templates there, but then every time we update the Xcode app, they'll get replaced. The good news is, we have a place where we can more permanently store our templates.

Open up your finder window, and press cmd+shift+g

Type in the following path ~/Library/Developer/Xcode/Templates and click Go

Congrats! You're inside of the custom template folder. Now let's create our first custom template. The first thing you'll want to do is create 2 separate folders to organize your Templates. Name one File Templates and the other Project Templates.

2. Create Your Template Folder

Now, open the File Templates folder, and create a new folder. Name this whatever you'd like, but make sure to end the folder name with .xctemplate. For example, devTo.xctemplate.

3. Create Your `TemplateInfo.plist`

Inside of the xctemplate folder you just created, we're going to need to create a TemplateInfo.plist file. This is kind of like template inception, but let's create a new .plist file using Xcode's existing .plist file template.

Open up Xcode and choose File->New->File. Select Property list (I like to filter the files so it's easier to find).

Now, you'll need to navigate to the xctemplate folder you just created in ~/Library/Developer/Xcode/Templates. ⚠️Important!⚠️ name this file TemplateInfo.plist.

NOTE: Sometimes the easiest way to put this file in the right folder is to save it to your desktop, then move it there manually using `cmd`+`shift`+`g` in Finder.

4. Start Populating Your `TemplateInfo.plist`

Once you've created the TemplateInfo.plist file and have it in the right directory, it's time to create your template! Open your TemplateInfo.plist file and create a new entry by clicking the small plus sign that appears when you hover over an existing row.

Identify what type of template this is.

By default this shows a list of values such as Bundle Identifier. We're first going to identify this template as a file template. In order to do that, we'll need to name this entry Kind. Leave the type as String and double click where the value would be to input a new value.

Copy and paste Xcode.IDEKit.TextSubstitutionFileTemplateKind, and Xcode will know this is a file template rather than project template.

Identify which platform(s) this template can be used on.

We'll use this on iOS. Create a new Entry named Platforms and change the type to Array.

Now, click the small dropdown next to Platforms and create a new entry. This should create Item 0. For the value, enter com.apple.platform.iphoneos

5. Create Options

Collapse Platforms and create a new entry called Options. Make this an Array. Options is an Array that contains Dictionaries. These Dictionaries define text boxes, checkboxes, dropdowns, combo boxes, and static text. Each gets its own unique identifier and can be used to populate fields.

First, we're going to create an option with an Identifier of productName. productName is a special identifier that can be referenced throughout the template as either ___FILEBASENAME___ or ___FILEBASENAMEASIDENTIFIER___. FILEBASENAME references the name exactly as input while FILEBASENAMEASIDENTIFIER references the name in a way that can be used for class names, variables, and more by stripping out special characters and spaces.

Expand the Options Array and create a new entry.
- Make this type Dictionary.
Expand the Dictionary (item 0) and create a new entry.
- Name this Identifier. Give it a value of productName
Create a new entry in the Dictionary named Description.
- Give it a value of "Enter Name" (no quotes)
Create a new entry named Name.
- Give it a value of "Enter Name"
Create a new entry named Default.
- Give it a value of "Model Name"
Create a new entry named Required. Make the Type Boolean
- Give it a value of 1 (true)
Create a new entry named Type.
- Give it a value of text

Here's what this does:

2. Our default identifier we use in the file.
3. The tooltip that appears when you hover over the option
4. The text that appears next to the option
5. The option's default value
6. Whether or not the option is required to have a valid value in order to create the template.
7. The type of option this is. Text makes this a text box.

6. Create Your File!

I like to do this from terminal to get a fresh file, but you can do it from Xcode and use the blank template or Swift File template. Using the Swift File template includes the header though, and you can choose to include or exclude it with your own blank file.

No matter your method, create a new file named ___FILEBASENAME___.swift. This will name the file after whatever you type in the text box when you choose this template in Xcode.

I'm going to create a model file with the header included (___FILEHEADER___). Feel free to make whatever you'd like! 🧑‍💻👩‍💻

Anywhere you would normally type the name of the file/struct/class/whatever - you can substitute that with ___FILEBASENAMEASIDENTIFIER___

Save this file in the same place you saved your TemplateInfo.plist file. Now, the next time you open Xcode, go to File-New->File and behold the glory of your template!

Free From Boredom, Safe From Mistakes

I've created several file templates and a few project templates of my own, some that I use on a frequent basis. This helps me not waste so much time typing boilerplate code because I only have to make one template and it's done forever. More importantly, it gives me the confidence and security knowing that my initial implementation will work, because it worked last time. Create your templates with the best of care and intentions, and you have something you can use that's safe, reliable, and fast.

Drop a note in the comments about your experience with Xcode Templates.

Happy Templating!

How To Use DispatchGroups To Gather Information From Multiple Sources At Once

Kenny Dubroff (froggomad) — Fri, 23 Oct 2020 16:35:43 +0000

Before We Begin

It's helpful, but not required to know:

Basic Swift
Object-Oriented Programming (OOP)
Asynchronous programming
URLSession

What We'll Be Doing

Let's say you're creating a simple catalog of Car Brands. For each brand, you want to know what makes and models the brand has available. You have an API with the information and it's in JSON. In Swift, we might model something like that in this fashion:

struct CarBrand: Codable {
    let id: Int
    var makes: [CarMake]
}

struct CarMake: Codable {
    let id: Int
    let name: String
    var models: [String]
}

Then if we were so fortunate, we'd make one API call, get an array or two of associated data, and get all of the information we want. Ah, bliss...

This time, things wouldn't be so easy...

Linking information from decoupled sources.

I recently ran into a problem where I had to do something similar in a totally unexpected way. I was downloading information from a single source, but for some reason, relationships couldn't be established properly at the parent endpoint and we had to access a pivot table where the relationship between the two objects existed. We could then go and retrieve information about the related object from another endpoint.

In other words, parents had no information about their children. So in order to link properties, it was necessary to initiate one network call, wait for several other network calls to come back, then complete our method. This was what the JSON from the base URL (/brand) looked something like:

[{
  "id":1,
  "name":"AmazingCarBrand"
},
{
  "id":2,
  "name":"AnotherAmazingBrand"
}]

As I described, all we get is information about the brand itself. It was then necessary to find the linked pieces at their own endpoints, and use a middleman (pivot table) endpoint to figure out which children to retrieve. Here's sample JSON from a pivot table (/brand/details/id) endpoint:

{
  "brandid":1,
  "makeids":[1,2,3,4]
}

We could then go to the /make/id endpoint to get the following JSON:

{
  "id":1,
  "name":"Junker"
}

... then repeat the middleman/pivot table process to get information on models for each make. But for "simplicity's" sake I'll stop this tutorial one level deep.

This doesn't easily facilitate OOP

My team's goal was to do things in an Object-Oriented way, so instead of coming away from a method with a bunch of separate arrays at different times, we wanted to just have one object that had at least the top-level child objects as properties so we could use what we needed when we needed, and keep the data coupled where it needs to be... the way we typically expect things.

No big deal right, just use a loop...

Well, yeah - a loop is definitely part of what's necessary here... a couple of them actually (if we needed another property, or to go another level deep such as getting models). But when we're working in an asynchronous environment (which Networking automatically is) we don't know when we'll be getting the information we need back from the remote source. In our case, this means our Car Brand will have an incomplete list of Makes and/or Models - even though we made requests to get that information through those loops... unless we had a way of knowing when those requests were also complete.

I was using a URLSession Wrapper so it was a little cleaner, and I promise (🤞) I knew it wouldn't work... but my initial implementation looked something like this after making the initial call to get brands:

/// "https://www.example.com/base/brands"
let baseURL = URL(string: "https://www.example.com/base/brands")!
/// "https://www.example.com/base/brands/details"
let baseDetailURL = baseURL.appendingPathComponent("details")

// get Make information for one CarBrand
func getMakeInformation(for brand: CarBrand, complete: @escaping ([CarMake]?) -> ()) {
    getMakeModelIds(for: brand) { ids in
        // the ids that come back are optional, so we need to unwrap them
        guard let ids = ids else {
            print("no ids came back from makeModelId request")
            complete(nil)
            return
        }
        // initialize an empty array of CarMake
        // to hold our objects when they come back
        var makes: [CarMake] = []

        for id in ids {
            // this URL has information about which makes a brand has
            let brandMakeDetailURL = baseDetailURL.appendingPathComponent("\(id)")
            let brandMakeDetailRequest = URLRequest(url: brandMakeDetailURL)
            URLSession.shared.dataTask(with: brandMakeDetailRequest) { (data, _, error) in
                if let error = error {
                    print("error getting make details: \(error)")
                    // Normally I would continue here, but we get an error
                    // that we're outside of a loop. Because we're asynchronously
                    // programming, we're no longer on the same thread as our loop.
                    // We're on some background thread waiting for a response
                }
                if let data = data {
                    let decoder = JSONDecoder()
                    do {
                        let carMake = try decoder.decode(CarMake.self, from: data)
                        makes.append(carMake)
                    } catch {
                        print("Error decoding CarMake: \(error)")
                    }
                }
            }.resume()
        }
        complete(makes)
    }
}
func getMakeModelIds(for brand: CarBrand, complete: @escaping ([Int]?) -> Void) {
    ... // implementation here
    complete(ids)
}

Why didn't this work?

Because we're asynchronously programming, when we get to the part where we loop through ids and make requests, the requests are made immediately, not waiting for a response before making the next request. When we finish the loop, we may get one or two responses back, but the rest are still out in the ether.

What we need is a signal to know when all of the makes and models have come back and have been linked to the brand... what we need is a basic implementation to make sure I'm right before we get into this any deeper!

My initial idea was to keep count using a placeholder Int property that I would increment as requests completed. There was then a conditional check that would complete the method with the entire array after every request had come back with a response.

And it worked!

...

var i = 0
for id in ids {  
    ...
    // we're in the completion here meaning
    // this cal has come back, so increment    
    i += 1
    ...
    if let data = data {
    let decoder = JSONDecoder()
    do {
        let carMake = try decoder.decode(CarMake.self, from: data)
        makes.append(carMake)
       } catch {
        print("Error decoding CarMake: \(error)")
       }
    if i == ids.count {
        complete(makes)
    }    
}

While it worked, it just didn't feel... right. I'm sure this is fine, though it could probably use more error handling and the code could be more reusable. But those weren't the issues I was having. I just knew there was a built-in way to do this because I had used different methods to do things like this before; just not often enough to remember.

Did I Need A `Semaphore`?

A semaphore was my initial thought, and I did some preliminary research, and it seemed to check out. A semaphore allows you to start n tasks, and signal when they're complete. As I went through implementations though, the logic just wasn't tracking for me. So I started looking into other methods.

Was using a `DispatchGroup` the answer I was seeking?

A DispatchGroup (group) is an object that holds a group of n tasks. Tasks enter a group when they begin their task and leave a group when they finish.

DispatchGroup then has a notify method that checks to see if the group is empty as a task leaves. If it is, the code inside of the notify block gets executed. Perfect!

But doesn't a Semaphore work the same?

Yes, and no. A Semaphore probably also would've worked here, but a Semaphore is more for limiting the number of tasks that can run concurrently. For instance, only allowing one login from one device at a time to prevent DDOS attacks to your login server.

A DispatchGroup is for allowing n tasks to run before completing.

While similar, a DispatchGroup is really what's appropriate here.

Finally, let's implement our `DispatchGroup`

let group = DispatchGroup()
// get Make information for one CarBrand
func getMakeInformation(for brand: CarBrand, complete: @escaping ([CarMake]?) -> ()) {
    getMakeModelIds(for: brand) { ids in
        // the ids that come back are optional, so we need to unwrap them
        guard let ids = ids else {
            print("no ids came back from makeModelId request")
            complete(nil)
            return
        }
        // initialize an empty array of CarMake
        // to hold our objects when they come back
        var makes: [CarMake] = []

        for id in ids {
            // each task enters the group at the beginning of our loop
            group.enter()
            // this URL has information about which makes a brand has
            let brandMakeDetailURL = baseDetailURL.appendingPathComponent("\(id)")
            let brandMakeDetailRequest = URLRequest(url: brandMakeDetailURL)
            URLSession.shared.dataTask(with: brandMakeDetailRequest) { (data, _, error) in
                if let error = error {
                    print("error getting make details: \(error)")
                    // Normally I would continue here, but we get an error
                    // that we're outside of a loop. Because we're asynchronously
                    // programming, we're no longer on the same thread as our loop.
                    // We're on some background thread waiting for a response
                }
                if let data = data {
                    let decoder = JSONDecoder()
                    do {
                        let carMake = try decoder.decode(CarMake.self, from: data)
                        makes.append(carMake)
                    } catch {
                        print("Error decoding CarMake: \(error)")
                    }
                }
                // each task leaves the group when it's finished
                // you want to make sure if you're exiting the method
                // anywhere else to also exit the group
                group.leave()
            }.resume()
        }
        // This will complete on the main thread
        // when all tasks complete.
        // If you want to complete on a background
        // thread, you can initialize a new background thread
        // here or use a `DispatchQueue` and pass it in
        group.notify(queue: .main) {
            complete(makes)
        }
    }
}

Wrap-Up

What we've done here is linked multiple dependencies to one object using multiple asynchronous tasks, and we're only completing the top level object when all asynchronous tasks related to it are complete.

We did this using a DispatchGroup which allows us to begin multiple asynchronous tasks, and notifies us when they've all finished.

If we wanted to limit the number of calls we could make at once, we could use a Semaphore.

Where to go from here

There are certainly a lot of improvements that can be made to this code.

For one, it could be more modular.
- As I mentioned earlier, I normally use a URLSession Wrapper
Second, error handling could be improved. Look out for an article from me that links that URLSession Wrapper to an Error Handler using the Result Type
- In addition, some of this is assuming "The Happy Path". I believe there are one or 2 places where I'm force-unwrapping Optionals for instance.
Third, we didn't touch on how JSON Decoding is working using the Codable protocol
Lastly, if you tried to run any of this code, you got a bunch of decoding errors - this is because www.example.com isn't hosting JSON for us!
- Please go forth and find an API that's structured in a similar way, or string several together... heck - you could roll your own using Firebase or something similar. Play around with DispatchGroups and Queues and see what you can come up with. It's probably the best way to learn.

Or you can watch me babble more words ⏬

DEV Community: Kenny Dubroff (froggomad)

Why is ChatGPT talking to itself?

Human Language as a Programming Language

I’m not making any sales

Prediction Engine

My First Attempt at a Good Title May Have Resulted in a Lawsuit 👮

Human Language as a Programming Language

Role-Playing with AI

Establishing a Baseline

The Power of Directed Conversation

Testing This Approach

Looking Ahead

How I Use Xcode's Template Library To Reduce Boredom

Repetitive, boring, work?

But... I'm a programmer

Have you ever wondered just how they generate all that code? Me too, so let's find out...

What exactly can you generate with a template?

files, folders, groups, dynamic lines of code

Generating Files

With this:

You'll get to make a model file that conforms to Equatable, each time with a different name for the file and class:

File->New->File Dialog

New Model With Equatable Conformance!

The Anatomy of a Template

1. Find the Folder Where Custom Templates Go

2. Create Your Template Folder

3. Create Your TemplateInfo.plist

NOTE: Sometimes the easiest way to put this file in the right folder is to save it to your desktop, then move it there manually using cmd+shift+g in Finder.

4. Start Populating Your TemplateInfo.plist

Identify what type of template this is.

Identify which platform(s) this template can be used on.

5. Create Options

Here's what this does:

6. Create Your File!

Free From Boredom, Safe From Mistakes

Happy Templating!

How To Use DispatchGroups To Gather Information From Multiple Sources At Once

Before We Begin

It's helpful, but not required to know:

What We'll Be Doing

This time, things wouldn't be so easy...

Linking information from decoupled sources.

This doesn't easily facilitate OOP

No big deal right, just use a loop...

Why didn't this work?

And it worked!

Did I Need A Semaphore?

Was using a DispatchGroup the answer I was seeking?

But doesn't a Semaphore work the same?

Finally, let's implement our DispatchGroup

Wrap-Up

Where to go from here

3. Create Your `TemplateInfo.plist`

NOTE: Sometimes the easiest way to put this file in the right folder is to save it to your desktop, then move it there manually using `cmd`+`shift`+`g` in Finder.

4. Start Populating Your `TemplateInfo.plist`

Did I Need A `Semaphore`?

Was using a `DispatchGroup` the answer I was seeking?

Finally, let's implement our `DispatchGroup`