Forem: taarimalta

The Art of Reverse Prompting

taarimalta — Sat, 25 Apr 2026 15:39:26 +0000

A couple of years ago I had to write documentation for my team's next epic. All the ideas were in my head. POCs done, tradeoffs clear. But nothing was on paper. And the meeting was soon.

Staring at a blank page, I tried something that felt a little silly at the time. Instead of telling the AI what to write, I asked it to interview me:

I have a plan for the team's next epic. I have done some POCs. I would 
like to write some documentation about it. I need your help. Ask me 10 
short questions about this which will help you help me.

Ten quick answers later, the AI offered to draft the doc. I wasn't done yet, so I pushed back:

No, not yet. Ask me about the X contingency plan. And ask me about any 
gaps you see in the plan. Keep the questions short.

After that round, I had a solid document in front of me. Total time: under 30 minutes.

I've been doing this regularly ever since. I call it reverse prompting. It works with whatever AI you're using. ChatGPT, Claude, Gemini, anything that can hold a conversation.

A.K.A. Flipped Interaction Pattern

Many people have probably come up with this technique independently, like I have. Turns out it has a name. Researchers at Vanderbilt published it in 2023 and called it the Flipped Interaction Pattern (White et al., arXiv:2302.11382).

Fun part: I only found out about the Vanderbilt paper while writing this article, because I was using reverse prompting to write it. Partway through the interview, the AI mentioned there's academic literature on what I was describing. That's how I learned the name.

Here's the prompt I used to kick off the interview for this piece:

I have been using a technique which I called reverse prompting. I use 
it a lot and it has boosted me and my team's productivity. I want to 
write a dev.to article about it.

Ask me questions about my thoughts about this. Ask me 2 short 
questions at a time. Based on the answer ask me 2 more questions. I 
will tell you to stop at some point.

Here's a snippet from a few rounds in:

AI: Two more.

You said you use this "on a regular basis now for everything." Have you hit a type of task where reverse prompting actively made things worse or slower than just writing a direct prompt?

When the AI is interviewing you, do you ever feel it's asking the wrong questions or wasting turns on obvious things, and if so, how do you course-correct mid-interview?

Me:

Nope.

Yes it does ask wrong questions sometimes. So I correct the course and give it more context in mid conversation.

AI: Good. Two more.

On the "never made things worse" answer, I want to push a little here. A technique that works for literally everything is a suspicious claim in an article. What about very short tasks, like "rewrite this sentence"? Is it fair to say reverse prompting is specifically for tasks with enough ambiguity or scope to justify an interview?

When you redirect the AI mid-interview, does it ever drop threads it was handling well before?

That exchange tightened a lazy claim. I'd been telling myself the technique worked for everything. It doesn't. The AI pushed; I revised. That's the whole pitch in miniature. Multiply it by a dozen rounds and you get the article you're reading.

Why it works

You've probably been using reverse prompting without knowing it had a name. Tell an AI about a bug, and the AI almost always responds with questions. Have you checked the syslogs? What's the exact input? Does it reproduce locally? Can you share the stack trace? You answer one at a time. The AI is interviewing you toward a fix. Most engineers do this several times a day and never call it anything.

Most write-ups sell flipped interaction as "the AI knows what to ask because it's an expert." In my experience that's only half true. For a narrow domain the AI doesn't know, it'll ask generic-senior-engineer questions. Useful, but not magical.

The real benefit is different: you don't initialize the AI with your bias.

When you prompt directly, you quietly constrain the answer. Your framing, your vocabulary, your assumed structure, all of it leaks in. When the AI interviews you, it's working from a clean slate. It'll ask about the thing you were hoping nobody would notice. It'll occasionally lead you somewhere you hadn't planned.

There's a second thing too. Answering questions is cognitively easier than generating structure from scratch. A lot of documentation paralysis is actually structure-block. When you're just answering, sometimes yes or no, the structure assembles itself as a byproduct.

Pattern 1: Extraction (ideas in your head, nothing on paper)

This is the original use case. The thinking is done, the document isn't.

I'm about to work on [X]. Ask me 10 short questions about it. When you 
have enough information, produce [the deliverable].

The key phrase is the goal. Without a goal, the AI will wander.

If you have a lot to say, ask for 10 questions, then tell it to ask 10 more. If you're not sure where you're going, ask for fewer and let the AI guide you:

Ask me one question at a time. Based on my answer, decide the next 
question. Don't produce anything until I tell you to stop.

This second mode feels like explaining your problem to a senior colleague. Sometimes you work out the answer just by articulating the question, and the colleague barely had to speak.

A real example. I needed to document our use of Airflow to move data between our transactional system and our warehouse. Without reverse prompting, I'd have managed maybe a short paragraph by my deadline. With it, I had a full document in the same time, low-level design and all. That's the gap this technique closes.

Once I shared the technique, teammates started using it the same way. One documented our disaster recovery practices. Others are writing technical implementation plans for new features. Anywhere a single person holds the knowledge and just needs to get it out, this is the pattern that fits.

Pattern 2: Audit (the document exists, but something's missing)

This one's subtly different from extraction. You have a draft. You suspect there are gaps.

Here's a document I've written: [paste]. Interview me about the gaps 
you see. Ask short questions. After I've answered, suggest edits to 
fill the gaps.

I used this to significantly improve the documentation stack of a massive project. I could have just said "generate documentation on X and Y" and gotten something plausible. Instead I got a document where everything was properly linked, redundancies were gone, and the gaps I didn't know I had were filled, because the interview dragged them into view.

Pattern 3: Tough communication (feedback, appraisals, hard emails)

Some messages need the right words and a careful read of how the receiver will feel. That's a lot to hold in your head while also drafting.

For appraisals, what works for me:

I need to appraise an individual and provide them with feedback. I use 
the following template: [template]. The following documents show their 
historical appraisals: [paste]. Ask me questions about their recent 
performance in the past quarter. Ask 2 short questions at a time and 
based on my response create more questions.

For tough feedback in general:

I need to give tough feedback to a team member. Here are the criteria 
I care about: [list]. Here's the template I usually follow: [template]. 
Ask me questions one at a time to help me figure out what to say and 
how to say it.

Sometimes I tell the AI the feedback is tough. Sometimes I don't. Either way, it defaults to a professional tone even when my answers are rough, which is usually what I want. Thinking about the receiver's likely reaction one question at a time is much less overwhelming than trying to craft the whole message at once.

Pattern 4: Knowledge base building (long-running, reference-fed)

Most recently I used reverse prompting to build a knowledge base for the team. This one's different in scale. Not a single interview with a single deliverable. It runs for hours. Maybe across days.

I want to build a knowledge base for [topic / team / project]. Ask me 
10 short questions at a time. As I answer, build the document in 
canvas mode. Keep going past the obvious questions. I'll often answer 
with links and references instead of prose.

I started the same way. 10 short questions at a time. I used Gemini's canvas mode so the document was building in parallel as I answered.

After about 50 questions, I had a good document. The AI offered to wrap up. I told it to keep going.

Around that point, my answers stopped being typed sentences. They became links. Repository URLs, other docs, screenshots, anything relevant. The interview kept generating questions; I kept feeding it references instead of writing prose.

When the output started spanning multiple markdown files, I switched to Claude Code. The chat interface wasn't built for that scope, but a coding agent could update many files at once and keep them linked properly.

The final result: a well-organized, low-redundancy knowledge base where everything cross-references where it should. If we had just dumped all the team's existing docs into one place, we'd have ended up with overlapping, unlinked content. Instead the AI did the connective work as it went.

We tested by loading the result into NotebookLM and asking domain experts on the team to query it. Rough satisfaction: over 90%.

Two things made this work:

Don't type when you can link. Once the interview is rolling, references are denser than prose.
Switch tools when the deliverable outgrows the chat. Single-doc output is fine for chat. Multi-file is when you need a coding agent.

Pattern 5: Decision-making (clarifying scope and direction)

Reverse prompting works well when the deliverable isn't a document but a decision.

I wanted to build a certification practice app, but with two constraints. Keep hosting cost low, and let the developer community contribute. That was all I had. I let the AI interview me.

It asked about the features I cared about, which helped me scope the thing realistically. It pulled up similar applications and competitors I should be aware of. By the end of several reverse-prompting sessions, I had a clear feature list, a sharp sense of where my idea sat in the market, and enough confidence to start building.

The result is live: quizplay.io, free Azure certification practice tests with community-contributed quizzes stored in GitHub repos. The cost-and-contribution constraints I started with shaped the whole architecture. Reverse prompting is what got me from a vague idea to a buildable plan.

I want to build [X]. My constraints are [list]. Ask me questions to 
help me scope this, identify similar applications, and figure out 
whether the idea is worth pursuing. Ask 2 questions at a time.

Tips and observations

Pace it to your mental state. Lots to say? Ask for 10 questions at a time. Not sure where you're going? Ask for fewer and let the AI guide you. Both modes work; they just feel different.

Course-correct when it asks wrong questions. It will, sometimes. Just redirect:

That's not the direction I want to go. Focus instead on [X]. Also ask 
about [Y], which you haven't covered.

How fast you can steer depends on how well you can articulate what's off. That's a skill that improves with practice.

Personas mostly change tone. Telling the AI it's "a senior architect with 20 years of experience" reliably shifts the tone. Whether it shifts the quality of the questions is less clear. I'd be careful about overclaiming there.

Voice mode might be the killer feature. I haven't tried this myself, but if your AI tool supports voice, you could run an interview while doing household chores or walking. Talk through your epic while folding laundry, end up with a document. Worth trying.

Whatever the AI produces needs revision. Two things I do:

Give specific pointers. "The intro is too long, the security section is missing X, restructure the API examples by use case rather than alphabetically."
Apply Pattern 2 (Audit) to the AI's own draft. "Do a gap analysis..."

The second one is funny...

You can flip it to generate prompts instead of deliverables. Slightly meta, but worth knowing:

I'm about to work on an epic. Ask me about it. Use my answers to 
generate a prompt, written in the persona of a senior frontend 
engineer with years of experience, that will let an AI complete the 
epic accurately.

Inside my answers I'll paste PRDs and other references. What comes out is a dense, context-rich prompt I can hand to a fresh session or a coding agent. Interview as scaffolding, prompt as product.

Closing thought

The closest analog I have is walking to a senior colleague's desk to explain a problem, and realizing halfway through that you already know what to do. The colleague barely had to speak. The structured articulation, prompted by an attentive listener, did the work.

One caveat before I let you go. This is overkill for short tasks like "rewrite this sentence" or "what's the syntax for X". Just prompt directly there. And it's a worse fit when the AI genuinely lacks the domain knowledge to ask useful questions. But on ambiguous, generative work? It earns its keep.

That's the art of reverse prompting. You're not getting a smarter collaborator. You're getting a better-structured conversation with yourself.

If you've stumbled onto this technique yourself, or use it for something that didn't make this list, drop a comment below. I'm always collecting new patterns.

References

White, J., Fu, Q., Hays, S., Sandborn, M., Olea, C., Gilbert, H., Elnashar, A., Spencer-Smith, J., & Schmidt, D. C. (2023). A Prompt Pattern Catalog to Enhance Prompt Engineering with ChatGPT. arXiv:2302.11382.
QuizPlay. Free Azure certification practice tests, built using Pattern 5. Source: github.com/quizplay-io.

azure

taarimalta — Sat, 14 Mar 2026 02:08:13 +0000

QuizPlay - play certification quizzes straight from GitHub

taarimalta — Fri, 13 Mar 2026 17:35:15 +0000

After taking AZ-204, AZ-104, and AZ-305, I realized that while Microsoft Learn is free, it's not enough to pass. You need practice and practice costs money.

The paid platforms want $30-$50/month. The free ones are mostly outdated multiple choice questions with no explanations. And none of them have the question types you actually get on the exam - case studies with tabbed reference material, hotspot images where you click on a diagram, drag-and-drop ordering, fill-in-the-blank dropdowns.

So I built QuizPlay. Think of it like a music player, but for quizzes.

How it works

You point it at a GitHub repo that has quiz questions and it plays them. No backend, no account, no database. It runs entirely in your browser.

It supports seven question types:

Single and multiple choice
Ordering (drag items into the correct sequence)
Hotspot (click on the correct region of a diagram)
Hotspot-dropdown (dropdown menus on image zones)
Matching (pair items to slots)
Fill-in-the-blank (complete statements using dropdowns)
Case studies (tabbed reference scenarios with linked questions)

That last one is the big one. Real Azure exams give you a case study with tabs - company overview, business goals, network diagram - and then ask you questions about it. I haven't seen a free practice tool do that

Here's what the quiz player looks like with a case study question:

You get a timer, mark-for-review, a question navigator and detailed explanations after every question

Quizzes live in GitHub repos

This is the part I'm most happy about. Quiz content doesn't live in the app. It lives in GitHub repos

Each quiz is just a repo with this structure:

my-quiz/
├── quiz.json          # manifest
├── questions/         # individual question JSON files
├── scenarios/         # optional case study files
├── assets/images/     # diagrams, exhibits
└── README.md

The player fetches the manifest, loads the questions, renders them. No API keys, no admin panel

The quiz content repos on quizplay-io are all open - you can fork them, improve them, submit PRs for corrections, or use them as a starting point for your own. The player app itself is not open source but all the content that feeds into it is

What questions look like

Each question is a JSON file. Let's look at a few

A single-choice question:

{
  "id": "q-001",
  "type": "single",
  "question": "What does HTML stand for?",
  "options": [
    { "text": "Hyper Text Markup Language", "correct": true },
    { "text": "High Tech Modern Language" },
    { "text": "Hyper Transfer Markup Language" }
  ],
  "explanation": "HTML stands for **Hyper Text Markup Language**."
}

The explanation field supports Markdown so you can use code blocks, links, images etc

A hotspot question has zones defined as percentages of the image dimensions:

{
  "type": "hotspot",
  "question": "Click on the Load Balancer in the diagram.",
  "image": "assets/images/architecture.png",
  "zones": [
    { "x": 10, "y": 5, "width": 25, "height": 20, "label": "Load Balancer" },
    { "x": 40, "y": 30, "width": 20, "height": 25, "label": "Web Server" },
    { "x": 70, "y": 50, "width": 20, "height": 20, "label": "Database" }
  ],
  "correctZone": 0
}

And a case study question references a shared scenario file:

{
  "caseStudy": "scenarios/cloud-migration.json",
  "question": "Which service meets Contoso's HA requirement?",
  "options": [
    { "text": "Azure Traffic Manager", "correct": true },
    { "text": "Azure Load Balancer" },
    { "text": "Azure Application Gateway" }
  ]
}

The scenario file has tabs just like the real exam:

{
  "tabs": [
    { "title": "Overview", "content": "Contoso Ltd is migrating to Azure..." },
    { "title": "Requirements", "content": "- High availability across two regions\n- Budget: $5,000/month" }
  ]
}

Multiple questions can share the same scenario

How to create your own quiz

The fastest way is to fork the sample quiz repo. It has working examples of every question type

Edit quiz.json with your quiz info:

{
  "title": "Your Quiz Title",
  "description": "A short description for the quiz card.",
  "category": "Your Topic",
  "questions": [
    "questions/01-your-first-question.json",
    "questions/02-your-second-question.json"
  ]
}

Replace the sample questions in questions/ with your own

If you don't want to write questions by hand, the sample repo also includes a quiz-folder-creation-prompt.md that you can paste into Claude or any AI assistant. It'll generate a full set of 36 questions with case studies, correct question type distribution, proper JSON schemas and fictional company names. The official AZ quiz sets were all created this way

One thing I want to be clear about - these are not exam dumps. None of the questions are copied from real exams. The AI prompt is specifically designed to generate original questions based on the exam objectives, using fictional company names. I wanted to keep this legal and useful for actual learning, not just memorization of leaked answers

You can test locally before publishing - go to quizplay.io, click the folder icon and select your quiz folder from your computer

When you're ready, add the quizplay topic to your repo on GitHub (gear icon next to "About" on your repo page). That's it. QuizPlay discovers repos via GitHub's topic search so your quiz shows up in the Community Quizzes tab automatically. No pull request, no approval needed

Quizzes can be about anything - Azure, AWS, programming languages, history, science, whatever you want. People have already contributed an AWS SAA-C03 set and a PL-400 (Power Platform Developer) set

Current official quizzes

The quizplay-io org hosts practice sets for:

There's also a JavaScript Fundamentals sample quiz that demonstrates all seven question types - useful as a reference if you're building your own

Give it a try at quizplay.io. And if you make a quiz, tag it with quizplay - I'd love to see what people come up with!

All Star Polygons with Python Turtle

taarimalta — Fri, 18 Jun 2021 17:54:19 +0000

In the previous article we showed how to draw a regular star polygon which was not degenerate i.e it could be drawn without lifting the pen from the paper. In this one we will attempt to come up with a way to draw two types star polygons.

By two types I mean degenerate (must lift pen) and non-degenerate/regular (no lift pen) but I don't know the true names of these star polygons types. But I hope I get the idea across

Repeated regular polygon method

In this method we are going to look at how to draw a degenerate star polygon by repeatedly drawing regular polygon polygons (like triangles, squares and pentagons)

The Star of David

Let's begin with the simplest degenerate star we know of the Star of David. This type of star can be draw by simply drawing one equilateral triangle and then overlapping it with another one which is upside down

Note that you can draw a triangle using the circle function! See the code below

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=200

t.circle(LENGTH)
t.circle(LENGTH,steps=3)
t.circle(LENGTH,steps=4)
t.circle(LENGTH,steps=5)

In the code above, we are drawing a triangle, square and a pentagon inscribed within the same circle making use of the steps parameter. Here's what we get:

Now we know how to use the steps argument, we can use it twice from two different places on a circle to draw our star

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=200

def star_of_david():
    """Draws two overlapping triangles
    """
    t.circle(LENGTH,steps=3)
    t.penup()
    t.circle(LENGTH, 180)
    t.pendown()
    t.circle(LENGTH,steps=3)

t.circle(LENGTH)
star_of_david()

In the code above t.circle(LENGTH, 180) makes the turtle go to the top of the circle so that it can draw another triangle from there. Here's what we get

Degenerate Octagram

You can draw a degenerate octagram using a similar method

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=200

def degenerate_octagram():
    t.circle(LENGTH,steps=4)
    segments=8
    t.circle(LENGTH,360/segments)
    t.circle(LENGTH,steps=4)

t.circle(LENGTH)
degenerate_octagram()

After drawing the first square, we are moving the turtle to a location determined by 360 / segments. segments = 8 because an octagram has 8 equal segments.

Remember that a n-gram star has n equal segments

Degenerate enneagram

According to wikipedia, enneagram is a 9 pointed star. Unlike the hexagram and the decagram, the enneagram cannot be drawn with just two regular polygons. But how many do we need?

A degenerate enneagram should be drawn by using 3 equilateral triangles (You can try drawing this on a piece of paper too).

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=200

def enneagram():
    segments=9

    t.circle(LENGTH, steps=3)
    t.circle(LENGTH, 360/segments)
    t.circle(LENGTH, steps=3)
    t.circle(LENGTH, 360/segments)
    t.circle(LENGTH, steps=3)

t.circle(LENGTH)
enneagram()

In the code above, we are calling the circle(LENGTH, steps=3 function 3 times

A General method - 1 (Regular non star Polygon based)

Now, how do we know the number of times we need to repeat the circle and step commands? To answer that we can make a few observations about the examples above:

A hexagram is a (6,2) star where the vertices - 6 is divisible the order- 2, 3 times
A octagram is a (8,2) star where the vertices - 8 is divisible the order- 2, 4 times
A enneagram is a (9,3) star where the vertices - 9 is divisible the order- 3, 3 times

With the above, we might be able to say that for a degenerate n-gram with the order m, the quotient of n/m is the number of sides of the polygon while the order m is the number of times we need to draw the polygon

So, we should try the following:

For an n,m degenerate star draw m number of regular polygons
And the polygons drawn should have n/m sides

Let's code that

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=200

def degenerate(n,m):
    segments = n
    order = m

    sides = int(n/m)

    for _ in range(order):
        t.circle(LENGTH, steps=sides)
        t.circle(LENGTH, 360/segments)

t.circle(LENGTH)
degenerate(10,2)

The code above works! It drew the 10 gram and the 12 grams below

(10,2)	(12,2)

You can also draw (12,3) and (12,4)

(12,3)	(12,4)

Interestingly if you try to draw (10,5) and (12,6) it draws this:

(10,5)	(12,6)

This is a reminder that the possible orders (values of m) are
2 through (n-1)/2-1. Basically the order can't be 1 and it also can't be half of the number of vertices

With the general code above, have we covered all the degenerate regular star polygons?

The (10,4) star

In the examples that we have looked at a degenerate star polygon can be composed of multiple regular (non-star) polygons. But (10,4) is a curious case. In the previous article we had written a code that draws regular stars. Let's see what happens when we use it here

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=150

def regular_star(n,m):
    """ n = number of pointies
        m = order of the star,
            (number of skips + 1)
    """

    angle = 360*m/n

    for count in range(n):
       t.forward(LENGTH)
       t.right(angle)

regular_star(10,4)

Yes we get a pentagram! But we were supposed to have 10 vertices :(

A new type of degenerate

Hence, (10,4) is a new type of degenerate star where n is not divisible by m and as such we cannot draw it with the degenerate function we wrote earlier.

We can draw this type of degenerate stars by overlapping two stars. Unfortunately we cannot use the circle's step parameter anymore. We need to draw a regular star then rotate it to draw another star. To do that we will first begin by modifying our regular_star function as follows

def regular_star(n,m):
    """ n = number of pointies
        m = order of the star,
            (number of skips + 1)
    """

    angle = 360*m/n

    t.left(180-angle/2)

    for count in range(n):
       t.forward(LENGTH)
       t.right(angle)

    t.right(180-angle/2)

The code above adds t.left(180-angle/2) to place the regular star to the left side of the turtle. This is similar to how a circle command behaves

Notice above that both the stars are drawn to the left side of the turtle

We will additionally make the following changes to our code

import turtle as t
import math

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

RADIUS=150


def regular_star(n,m):
    """ n = number of pointies
        m = order of the star,
            (number of skips + 1)
    """

    angle = 360*m/n
    center_angle = 2*m*math.pi/n

    t.left(180-angle/2)


    length=2*RADIUS*math.sin(center_angle/2)

    for count in range(n):
       t.forward(length)
       t.right(angle)

    t.right(180-angle/2)

regular_star(7,2)
t.circle(RADIUS)

In the code above, we have made the following changes

Replaced the global LENGTH with RADIUS. This is to allow us to draw the star of a defined radius
Computed a center angle which is the angle subtended by m segments on the center of the circle. center_angle is the representation of arch length in radians
We used the center_angle and the RADIUS to compute the length of the arms of the star

(5,2)	(7,2)	(7,3)

We can now draw a star to the left side of the turtle having defined radius. We can even overlap them all

A better general method

Our goal is to build a better general method to draw any degenerate regular polygon star of a given number of vertices and order. Let's begin again by listing the properties of the degenerate stars

Star	Properties
(6,2)	2 overlapping triangles
(8,2)	2 overlapping squares
(9,3)	3 overlapping triangles
(10,4)	2 overlapping pentagrams
(14,4)	2 (7,2) stars
(14,6)	2 (7,3) stars
(15,6)	3 overlapping pentagrams

The above can be verified by trying them out on a piece of paper (or by just thinking way too hard)

Here's an algorithm that we might be able to use to draw all the of the above stars

Find the greatest common divisor (gcd) of n and m
Divide n and m by the gcd to obtain a star (n/gcd,m/gcd)
Draw the (n/gcd,m/gcd) star
Move the turtle to another position on the circumcircle determined by 360/n degrees
Repeat 3 until we have drawn the star gcd number of times

Let's try it:

import turtle as t
import math

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

RADIUS=150

def regular_star(n,m):
    """ n = number of pointies
        m = order of the star,
            (number of skips + 1)
    """
    angle = 360*m/n
    center_angle = 2*m*math.pi/n

    t.left(180-angle/2)

    length=2*RADIUS*math.sin(center_angle/2)

    for count in range(n):
       t.forward(length)
       t.right(angle)

    t.right(180-angle/2)


def star(n,m):
    """ n = number of pointies
        m = order of the star,
            (number of skips + 1)
    """
    gcd = math.gcd(n,m)
    new_n = int(n/gcd)
    new_m = int(m/gcd)
    segment_angle = 360/n

    for _ in range(gcd):
        regular_star(new_n, new_m)
        t.penup()
        t.circle(RADIUS, segment_angle)
        t.pendown()

star(10,4)

With the code above it turns out that when the gcd is 1, we get either a regular non-degenerate star or a polygon. So we have written code to generalize:

Regular Polygons
Regular Non-degenerate stars!
Regular degenerate stars!~
Weird stick star :)

Examples:

Name	Drawing
(10,1)
(10,2)
(10,3)
(10,4)
(10,5)
(14,4)
(14,6)
(15,6)

Bonus

You can overlap all orders for a fixed number of vertices to get beautiful images such as these

def all_stars(n):
    for x in range(int(n/2)):
        star(n,x+1)


all_stars(10)
t.hide()

Yay!!~

Regular Star Polygon with Python Turtle

taarimalta — Fri, 11 Jun 2021 18:30:04 +0000

If you are a doodler, you most certainly have doodled a pentagram or the Star of David at some point in your life.

Pentagram	Star of David

Maybe some of you have also tried to add more lines to draw even more complex stars. Did you know that these stars had names too?

Heptagram	Octagram

Anyways, I thought that it might be fun to try drawing these stars with Python. So let's begin drawing these polygons

A star is a polygon?

Turns out that the stars above are a class of polygons called complex polygons. Basically, as opposed to normal polygons, the lines intersect each other in complex polygons

A complex polygon	A complex polygon of star shape

The star polygon is a type of complex polygon. And there are two types. You must have realized that to draw the Star of David on a piece of paper, you have to lift your pen, but you don't have to do so to draw a pentagram. The former type of stars are called regular star polygons whereas the latter type are called degenerate star polygons

Regular octagram	Degenerate octagram

Rules of regular star polygons

As you may have noticed above, we can draw a star with a certain number of vertices in multiple ways. For example you can draw a star polygon with 9 vertices as follow:

Method 1	Method 2	Method 3

1 vertex skipped	2 vertices skiped	3 vertices skipped

To understand what's going on count the number of vertices skipped in each of the above diagrams. Also notice that when 2 vertices are skipped the star is degenerate whereas in the other cases the star is regular. You can try to skip more vertices but you will end up drawing the same stars.

Here are the rules and formulas which are going to be useful for us

For a star with N vertices you can draw abs(N/2)-1 stars

For example for a star with 9 vertices you can only draw abs(9/2)-1=3 stars
The order of a star M can be defined as the number of vertices skipped +1.

So the possible orders for a 9-vertex star are 2, 3 and 4 for 1, 2 and 3 vertices skipped respectively
If N is divisible by M, the star is degenerate

Exterior angle of a star

Before we trace the star we need to know the angles, specifically the exterior angles. This is to know how much to turn the turtle after each forward move. We will not be rigorously deriving a formula but will simply try to understand the following:

When the turtle starts at a point, goes around then returns, 360 degrees are turned in one full rotation always (also the reason why sum of exterior angles of a polygon = 360 degrees)
In case of a star, the turtle performs multiple full rotations
The number of rotations is equal to the order of the star - M
Therefore, the sum of exterior angles of a star is 360*M
Which means that for a regular star with N vertices each exterior angle = 360*M/N

Hope that's convincing enough

Enough talk let's draw

Now that we understand our favorite doodle, we are ready to code it in Python turtle. Notice that the angle of turn is set to what we just discussed

import turtle as t

LENGTH=500

def regular_star(n,m):
    """Draws a regular star polygon (not a degenerate one)
       n = number of pointies
       m = number of points to skip
    """

    angle = 360*m/n 

    for count in range(n):
       t.forward(LENGTH)
       t.right(angle)


t.hideturtle()
t.pensize(2)
t.color("green")

regular_star(103,51)

The above code only draws any regular star polygons (the one which can be drawn without lifting the pen). We will leave it to another post to draw a degenerate star

Here's a 103 pointed star

Yay!

Starry Night with Python Turtle

taarimalta — Fri, 04 Jun 2021 16:54:47 +0000

In the previous posts we did

In this article we will draw a night sky with a crescent moon. This will give us an opportunity to play with the random library of Python.

Set up the canvas

Let's set up the screen to a defined size and color it black like the dark of night.



import turtle as t

SCREEN_WIDTH=1000
SCREEN_HEIGHT=1000

t.Screen().screensize(SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().setworldcoordinates(-SCREEN_WIDTH,-SCREEN_HEIGHT,SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().bgcolor("black")

We are setting up a square grid of coordinates

Generate stars

We can approximate stars by simply using white dots



import turtle as t

SCREEN_WIDTH=1000
SCREEN_HEIGHT=1000
STAR_COLOR="white"

t.Screen().screensize(SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().setworldcoordinates(-SCREEN_WIDTH,-SCREEN_HEIGHT,SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().bgcolor("black")


t.penup()
t.color(STAR_COLOR, STAR_COLOR)

t.goto(100,100)
t.dot(1)
t.goto(20,20)
t.dot(2)
t.goto(-100, -10)
t.dot(1)
t.goto(10,-100)
t.dot(1)

t.hideturtle()

In the code above all we're doing is moving the turtle into different coordinates on the screen to plot dots.

Instead of manually defining the coordinates of the stars lets randomly generate them. Here's how we can do that



import random

for _ in range(1000)
    x = random.randint(-1000,1000)
    y = random.randint(-1000,1000)

    print(x,y)

This will print a series of coordinates which are pseudo-random

We will use the method above to generate the coordinates of the star. Here is the code



import turtle as t
import random

SCREEN_WIDTH=1000
SCREEN_HEIGHT=1000
STAR_COLOR="white"

t.Screen().tracer(0,0)
t.Screen().screensize(SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().setworldcoordinates(-SCREEN_WIDTH,-SCREEN_HEIGHT,SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().bgcolor("black")



def random_star():
  t.penup()
  t.color(STAR_COLOR, STAR_COLOR)

  x=random.randint(-SCREEN_WIDTH,SCREEN_WIDTH)
  y=random.randint(-SCREEN_HEIGHT,SCREEN_HEIGHT)

  dot_size=random.random()*3

  t.goto(x,y)
  t.dot(dot_size)


for _ in range(1000):
    random_star()

t.hideturtle()
t.Screen().update()

In the code above we have not only randomized the location of the stars but also the size of the stars (using dot). The size of the dot uses random.random()*3 instead of randint function. This gives us continuous random sizes as opposed to discreet.

Here is the result:

Now all we need is a moon

Draw a crescent moon

A direct approach to drawing a moon could be to draw a semicircle, then turn the turtle around and draw another arc to complete the loop. We will use an easier way where we don't have to compute the angles.

Here is the function that draws a moon



def moon(size=100):
  t.penup()
  t.left(20)

  t.color(MOON_COLOR, MOON_COLOR)
  t.dot(size)
  t.forward(size*.25)
  t.color(NIGHT_COLOR, NIGHT_COLOR)
  t.dot(size)

We are simply drawing a large white dot and then overlapping a large black dot on top of it.

One disadvantage of this approach is that some stars that are located outside the sphere of the moon are erased, but maybe no one will notice ;)

Here is the final code:



import turtle as t
import random

SCREEN_WIDTH=1000
SCREEN_HEIGHT=1000
STAR_COLOR="#f0ffff"
MOON_COLOR="#FFFFF0"
NIGHT_COLOR="black"

t.Screen().tracer(0,0)
t.Screen().screensize(SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().setworldcoordinates(-SCREEN_WIDTH,-SCREEN_HEIGHT,SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().bgcolor(NIGHT_COLOR)

def moon(size=100):
  t.penup()
  t.left(20)

  t.color(MOON_COLOR, MOON_COLOR)
  t.dot(size)
  t.forward(size*.25)
  t.color(NIGHT_COLOR, NIGHT_COLOR)
  t.dot(size)

def random_star():
  t.penup()
  t.color(STAR_COLOR, STAR_COLOR)

  x=random.randint(-SCREEN_WIDTH,SCREEN_WIDTH)
  y=random.randint(-SCREEN_HEIGHT,SCREEN_HEIGHT)

  dot_size=random.random()*3

  t.goto(x,y)
  t.dot(dot_size)


for _ in range(1000):
    random_star()

moon(150)

t.hideturtle()
t.Screen().update()

Note that the location of the moon is going to be random too

Yay!!~~

Rainbow and Clouds with Python Turtle

taarimalta — Fri, 28 May 2021 15:53:34 +0000

In the previous posts we did

We will draw a rainbow with some clouds today. This one should be especially fun for kids because of the brights colors and the joyful objects that we will be drawing

Setting up the screen

To set up the stage let's first configure the height and the width of the canvas. We need the screensize command to set the size of the window, and the setworldcoordinates command to subdivide the window into the desired number of pixels. setworldcoordinates also sets up the coordinate axes for us



import turtle as t

t.Screen().screensize(500,500)
t.Screen().setworldcoordinates(-300,300,300,900)
t.Screen().bgcolor("lightblue")

We will be using a square grid. We have also set the color to lightblue using bgcolor

In the code above we have set the coordinate y-axis range to be within 300 and 900. This will make sense in the upcoming sections

We now have a blue sky

Draw a cloud

We will be using circles to draw a cloud but there could be multiple other ways to draw a cloud.

First start with a filled circle



import turtle as t
t.Screen().bgcolor("lightblue")

t.color("white","white")
t.begin_fill()
t.circle(50)
t.end_fill()

Now, lets put that code into a function



import turtle as t
t.Screen().bgcolor("lightblue")

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()

filled_circle(50,"white")

Filled circle function. Code does the same thing as before

Next we will draw multiple circles using the function above



import turtle as t
t.Screen().bgcolor("lightblue")

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()


radius = 50
cloud_color="white"

filled_circle(radius,cloud_color)
t.forward(radius)
filled_circle(radius,cloud_color)
t.right(90)
filled_circle(radius,cloud_color)
t.right(90)
filled_circle(radius,cloud_color)
t.right(90)
filled_circle(radius,cloud_color)
t.right(90)

Multiple calls to filled_circle at different positions

We have a cloud now! ( Hope you think so too :) )



import turtle as t
t.Screen().bgcolor("lightblue")

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()


def cloud(radius, cloud_color="white"):
    filled_circle(radius,cloud_color)
    t.forward(radius)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)

radius = 50

cloud(radius)

cloud function for use later

Concentric circles

Let's work on the rainbow now. Our approach will be to use concentric filled circles to draw the rainbow. Let's see if we can get what we want by progressively reducing the radius of the filled_circle function.



import turtle as t
t.Screen().bgcolor("lightblue")

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()


filled_circle(100,'red')
filled_circle(95,'orange')
filled_circle(90,'yellow')
filled_circle(85,'green')
filled_circle(80,'blue')
filled_circle(75,'indigo')
filled_circle(70,'violet')

Reducing radius progressively and changing the color

We have a roygbiv but the circles are not concentric

Let's see how to make the circles above concentric. Let's also use a loop



import turtle as t
t.Screen().bgcolor("lightblue")

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()

roygbiv=['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']


radius=200
interval=10

for r_color in roygbiv:
    filled_circle(radius,r_color)
    radius -= interval

    # Move turtle a up by a little
    t.left(90)
    t.forward(interval)
    t.right(90)

In the code above we move the turtle up a little every time it completes a circle. We have also stored the colors of the rainbow in a list.

There are two additional things we should do. First, a rainbow could be circular but generally we see just a portion of the rainbow. To get that effect, we can move half the rainbow off the screen. Second, the center of the rainbow should be the sky. So let's make those adjustments



import turtle as t
t.Screen().bgcolor("lightblue")
t.Screen().screensize(500,500)
t.Screen().setworldcoordinates(-300,300,300,900)

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()


def rainbow(radius=200,interval=10):
    roygbiv=['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'lightblue']

    for r_color in roygbiv:
        filled_circle(radius,r_color)
        radius -= interval

        # Move turtle a up by a little
        t.left(90)
        t.forward(interval)
        t.right(90)


rainbow(300,10)

In the code above, we have changed the screen size and set up the coordinates such that only half the rainbow shows. Also, the rainbow code is now in a function. Lastly to show the center of the rainbow as the sky, lightblue has been added to the roygbiv variable

Putting it all together

We can now use the functions that we created to draw a rainbow amongst the clouds



import turtle as t
t.Screen().bgcolor("lightblue")
t.Screen().screensize(500,500)
t.Screen().setworldcoordinates(-300,300,300,900)
t.Screen().tracer(0,0)

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()

def cloud(radius, cloud_color="white"):
    filled_circle(radius,cloud_color)
    t.forward(radius)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)

def rainbow(radius=200,interval=10):
    roygbiv=['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'lightblue']

    for r_color in roygbiv:
        filled_circle(radius,r_color)
        radius -= interval

        # Move turtle a up by a little
        t.left(90)
        t.forward(interval)
        t.right(90)

t.penup()

t.goto(100,900)
cloud(20)
t.goto(-50,850)
cloud(30)
t.goto(50,600)
cloud(50)
t.goto(200,500)
cloud(5)

t.goto(0,0)
rainbow(300,10)

t.goto(-200,500)
cloud(15)
t.goto(50,400)
cloud(10)
t.goto(50,300)
cloud(10)

t.Screen().update()

Note that we have also added the t.Screen().tracer(0,0) and t.Screen().update() lines to speed up the drawing

And we get:

Yay!

How to draw a spiral with Python turtle

taarimalta — Sat, 22 May 2021 04:17:11 +0000

In the previous post , we learnt how to draw a filled star using Python turtle. In this article lets do a spiral because why not.

Circle

We can easily draw a circle using turtle.circle but we're going to draw it in a different way



import turtle as t

t.tracer(10,1)

for i in range(360):
 t.forward(1)
 t.right(1)


t.update()

In the code above, tracer and update commands are used to increase the drawing speed. We can remove them if we want.

The turtle moves a step forward then turns right by 1 degree. By the time the loop completes the turtle has turned by 360 degrees so has completed a full rotation and we get a circle

Increasing radius and rate of turn

Instead of moving at a constant distance what would happen if the turtle moves more on every iteration



for i in range(360):
 t.forward(i)
 t.right(1)

i replaces 1 as parameter to forward

We'll get something that quickly moves past the screen. Let's see if we can make it turn faster



for i in range(360):
 t.forward(i)
 t.right(20)

20 replaces 1 as parameter to right

Here's our spiral. But notice that the curve isn't smooth

Make the curve smoother

Let's see how we can make the spiral curve smoother. But first try out the following code



# Quadrant 1

t1 = t.Turtle()
t1.penup()
t1.goto(125, 125)
t1.pendown()
t1.circle(100)

# Quadrant 2

t2 = t.Turtle()
t2.penup()
t2.goto(-125, 125)
t2.pendown()
t2.circle(100, 270)

# Quadrant 3

t2 = t.Turtle()
t2.penup()
t2.goto(-125, -125)
t2.pendown()
t2.circle(100, 180)

# Quadrant 4

t3 = t.Turtle()
t3.penup()
t3.goto(125, -125)
t3.pendown()
t3.circle(100, 90)

Code prints 4 circle sections in 4 quadrants

We can use turtle's circle function to draw a portion of a circle. We can use this feature to make our turtle move in a smoother way along the spiral



import turtle as t

t.tracer(10,1)

for i in range(360):
 t.circle(i,20)

t.update()

forward and right function calls are replaced by circle

The circle function above moves the turtle forward but also turns by a certain angle. Here's what we get

We now have a smooth spiral!

Add more arms

But what if we wanted something that looks a little different - like a spiral galaxy or the milky way? We first need to add more arms.

To do this we're going to create multiple turtles



import turtle as t

t.tracer(10,1)

t1=t.Turtle()
t2=t.Turtle()
t1.setheading(0) # Looks to the right
t2.setheading(180) # Looks to the right

for x in range(360):
 radius = x
 angle = 1
 t1.circle(radius,angle)
 t2.circle(radius,angle)

t.update()

In the code above, t1 and t2 are two turtles that have been initially set to look to the right and to the left respectively using the setheading command

Both turtle have now started their own spiral in their own direction. Now let's see how to make this more configurable



import turtle as t
t.tracer(10,1)

N = 10
angle = 1

turtles = []
for position in range(N):
  look_at = 360/N*position
  new = t.Turtle()
  new.setheading(look_at)
  turtles.append(new)

for radius in range(360):
  for my in turtles:
    my.circle(radius, angle)


t.update()

We have simply changed the code such that any number of turtles can be created by changing N, and they all look towards different directions in a symmetric manner

Interestingly the spiral arms seem to intersect. We can prevent that from happening by making a few adjustments



import turtle as t

t.tracer(10,1)

N = 10
angle = 30

turtles = []
for position in range(N):
  look_at = 360/N*position
  new = t.Turtle()
  new.setheading(look_at)
  turtles.append(new)

for radius in range(360):
  for my in turtles:
    my.circle(radius*radius, angle)

t.update()

We set angle to 30 and we squared the radius

By making the angle of turn on each iteration larger and increasing the rate at which the spiral increases (by squaring the radius - radius*radius) we can prevent the spirals from intersecting. (Note that I found this out by accident)

Yayy!

How to draw a filled star with Python Turtle

taarimalta — Sat, 15 May 2021 07:48:32 +0000

I overdid things a little when trying to teach 6th graders how to draw a star using Python Turtle. But I thought that it was fun anyways so I'm sharing it here.

Note that this is also my first dev.to article. I appreciate any suggestion.

Start with a zig zag

A zig-zag can be simple to explain. We just have to move the cursor left then right over and over



import turtle as t

angle=150
side=100

angle_left=angle
angle_right=angle

t.forward(side)
t.right(angle_right)
t.forward(side)
t.left(angle_left)
t.forward(side)
t.right(angle_right)
t.forward(side)
t.left(angle_left)
t.forward(side)
t.right(angle_right)
t.forward(side)
t.left(angle_left)

Here's what we get

As we have repeating code we want to use a loop to reduce the code



import turtle as t

angle=150
side=100
pointies = 10

angle_left=angle
angle_right=angle

for p in range(pointies):
 t.forward(side)
 t.right(angle_right)
 t.forward(side)
 t.left(angle_left)

Above we can change the value of pointies = 10 to change the number of zig zags

Rotate the zig zag

What happens if we rotate the zig zag by a certain value



import turtle as t

angle=150
side=100
pointies = 10
ROTATION = 30

angle_left=angle
angle_right=angle

for p in range(pointies):
 t.forward(side)
 t.right(angle_right)
 t.forward(side)
 t.left(angle_left)

 t.right(ROTATION)

All we did above was added this statement t.right(ROTATION). We also said ROTATION = 30

and here's what we get

But wouldn't it be nice if the ends were connected? To achieve this we just need to set rotation to ROTATION = 360/pointies. Remember that 360 degrees is a full rotation.



import turtle as t

angle=150
side=100
pointies = 10
ROTATION = 360/pointies

angle_left=angle
angle_right=angle

for p in range(pointies):
 t.forward(side)
 t.right(angle_right)
 t.forward(side)
 t.left(angle_left)
 t.right(ROTATION)

The result:

Color the star

To color the star we first set the color using t.color("red","red"). We then use the begin_fill and end_fill commands to start and stop filling the area. Here's it is:



import turtle as t

t.speed(0)

angle=150
side=100
pointies = 10
ROTATION = 360/pointies

angle_left=angle
angle_right=angle

t.color("black","red")

t.begin_fill()

for p in range(pointies):


 t.forward(side)
 t.right(angle_right)
 t.forward(side)
 t.left(angle_left)
 t.right(ROTATION)

t.end_fill()

In the code above we have also added a statement t.speed(0) to speed things up

We can now draw stars with any number of points of any color. Here are some examples:

Rotate the star

Why stop at drawing a star when we can rotate it! To do this we use a nested for-loop. This means a loop inside a loop



import turtle as t

t.speed(0)
angle=150
side=100
pointies = 5
ROTATION = 360/pointies
angle_left=angle
angle_right=angle

t.color("red","black")

for r in range(10):

 t.begin_fill()
 for p in range(pointies):

  t.forward(side)
  t.right(angle_right)
  t.forward(side)
  t.left(angle_left)
  t.right(ROTATION)

 t.end_fill()

 t.right(2)

In the code above we added an extra loop that runs 10 times - for r in range(10):. We have also added a t.right(2) to the end of the loop to make the turtle rotate slightly everytime the inner loop completes

Check it out: