DEV Community: Peter Shinners

Comp Language Tags

Peter Shinners — Fri, 03 Apr 2026 04:17:35 +0000

Comp allows defining a hierarchy of named values that can be used anywhere in the namespace. These are called tags and have several useful properties.

Comp uses tags almost like keywords throughout the language. The builtin boolean types true are and false are just regular tags. Even flow control statements like skip and stop (known as continue and break in many other languages) are just tags.

Tags are defined in a module as a simple hierarchy. Hierarchies from other modules can be extended within an internal module.

!tag severity {high medium low}
!tag comp.bool {maybe}

Comp namespaces work in that any definition can be referenced by its fully qualified name or as just the leaf portion of the name that is non ambiguous. So maybe works just as well as bool.maybe inside of our namespace.

In this case we've extended bool with our own crazy value. But the original module has no knowledge of our extensions. This allows us to extend but not pollute tag hierarchies.

There's a mountain of other details. Tags are the quick and easy way to avoid strings to define types or behaviors. A list of other places tags have an influence on the language.

Tags are used to define units, which we've already seen in values like 24#second or "select verion()"#sql.
Tags have a high precedence when morphing structs to shapes, something to demonstrate in a future post.
- This has a profoundly useful impact on assigning parameters to function calls.
Tags are both shapes and singleton values, which gives them a dual role.
Tags from unknown modules can be serialized and used as a "raw tag", which can be promote later given a module that can define them.

Comp Language Numbers

Peter Shinners — Thu, 02 Apr 2026 04:56:31 +0000

Comp's number values are not restricted to traditional hardware representations and their shortcomings. Comp numbers have huge, open ended precision with mathematical operations that do not accumulate errors. A single ~num type that represents all possible numbers.

This is somewhat of a game changer for writing code. It feels surprisingly futuristic to do things like convert between Farenheit to Celsius then back and end up with the exact same number you started with. No "approximate" results here.

It should make you wonder why anyone must tolerate (1/3)*3 != 1.0 or rounding 256.49999 to 257 in the year 2026? There is an excellent reason to tolerate these inaccuracies; Computers are astonishingly fast and efficient at storing and computing numbers. But I get the sense mostly it's because of decades of tolerating and being forced to accept.

When those come into play the language will use allocated of arrays of numbers; much like the amazing Numpy which makes storage and computation of numbers more tasteful in Python.

When interacting with legacy languages it is still useful to define numbers in terms they can understand. This is one area where Comp's limits shine brightly. I'll cover limits more in a future post, but the quick definition is that limits can be placed on defined types. A quick shape definition creates a type that can't overflow or allow lossy conversion.

!shape uint8 ~num<integer ge=0 le=255>

We'll get deeper into shape definitions later. The language does provide functions that handle lossy conversions in specific ways, and it's easy to write your own.

Comp numbers are not allowed to be illegal values (inf or nan) by default. But those can be allowed with union types where desirable.

I highly recommend Julia Evan's article that explains the how and whys of problems that will never be a problem for Comp developers.
https://jvns.ca/blog/2023/01/13/examples-of-floating-point-problems/

Comp Language Struct

Peter Shinners — Wed, 01 Apr 2026 05:59:25 +0000

An ongoing series of my thoughts and ideas for my Comp programming language.

Comp provides a single container type. It's a flexible container that combines both ordered and named fields in a unique style. A struct literal is defined by a series of fields in side of curly braces. Named and unnamed fields can be mixed freely, while always remaining ordered. Field values can be mixed and matched with any types. All data in Comp is immutable, including these structures.

One way to think of this is similar to how Python arguments are defined for a function. Some arguments are positional and some arguments are named. When combined with Comp's shape values we get defaults and flexible morphing (casts). This makes Comp's structs work like Python arguments, but you don't need to invoke a function to assemble them.

Some examples likely make this clearer.

{"cat" 12+12 true}
{name="Joe" score=14.5}
{warning message="it did not work" timestamp=now}
{ {"car" year = 2021} {"bike" year = 2025} }

Remember, Comp's syntax uses no separators and whitespace is arbitrary. These statements could be split over multiple lines, joined, or justified in whatever style felt appropriate.

Fields are accessed either with dotted field name or positionally using a special index field. All fields can be referenced by index, which works for both named and unnamed fields. And the first index starts at 0, this does not allow "negative indexing" from the back of the container.

user.active.#0
vehicles.#1.year
config.server-details.port

Typical field names are simple text tokens, which support kebab-case. But any value can be used as a field name, including numbers, tags, and other structures. These "value" field named are wrapped in single quotes and allow any value or expression. Double quotes can be used as text when the field name isn't a valid token. These same rules are used for defining fields and referencing fields. There are few other "advanced field lookup" syntaxes but these ones go a long way.

{'15'=10+5  "Server Port"=12345}

data.'15'
data."Server Port"

Comp Language Syntax

Peter Shinners — Tue, 31 Mar 2026 04:26:55 +0000

An ongoing series in my quest to untangle my own thoughts and goals for the Comp programming language.

A language focused on developer experience? So much of my focus has been on the syntax and grammar. The entire concept is built on a handful of core fundamental rules that everything expands from.

No separators or terminators
Whitespace independent
- No line-based statements
- No indentation

Along with these fundamentals there are a few other strongly motivated designs.

Use kabab-case for identifiers
No keywords
Avoid nesting braces

Along with that there is has been from-the-start requirement that the structure literal has two forms.

{1 2 3} for positional sequences (lists, arrays)
{a=1 b=2} for named mappings (dicts, hashes)

This has been a long and ongoing puzzle, but the payoff has been spectacular. Let's look at another small code example and call out a few highlights.

!func shopping-cart-demo (
  {
    {"Apple" price=1.00}
    {"Banana" price=0.50 quantity=2}
    {"Apple" 1.00 quantity=2}  // replace previous apples
  }
  | reduce :(| upsert :($.name))
  | cart-total
  | output "Total: %()"
)

Keywords use a ! prefix. This makes them a bit noisier than I'd like, but it's not a bad design to make them pronounced. This also allows freely introducing new keywords in the future.
Whitespace independence means this entire definition could be placed on a single line, or each statement split or joined as the author decides is most readable.

There's a history of experiments, compromises, and undesirable workarounds to assemble these pieces. Much of this time I wasn't sure these constraints could even be appeased.

I've been using the Lark library to handle parsing. I'd never experimented with it before, but now have a good deal of experience stretching it's LALR rules. This gives an ideal O(n) performance. I have been surprised at the cost of building the grammar at runtime. Fortunately the library is quite prepared for this and comes with some high level caching options.

Comp the Language

Peter Shinners — Sun, 29 Mar 2026 22:42:38 +0000

I've been brewing on ideas for a new programming language for months now. That's nothing anybody should need to notice, I see three new language announcements a day on various Reddit channels.

Perhaps tinkering with a new language is folly; a new programming language in 2026? The dawn of AI coding is eminent, so who is looking at programming languages?

Well, I do it because it captivates me. It is my itch these days, and therefore, I scratch. Perhaps I will soon learn the reasons why more languages isn't best languages. Perhaps this will become the new Coffeescript for Python. Perhaps this will become the new Python itself. In reality, no. This is a project by myself for myself.

So why even share? Posting and describing the language should help my organize thoughts and ideas. There's nothing like having to explain a process to shine a flashlight on the weakest links, and potentially the greatest links.

It's also folly to be thinking a new programming language will discover anything new or revolutionary. There are hundreds of amazing languages and libraries created by smarter people than myself. At some point additional perspectives will help, if not for the potential language, at least for my own expectations.

Project links? Example code? That must wait. For now I'll leave the most minimal of examples behind. Details must wait for future posts.

!func greetings ~nil (
   {"USERNAME" "USER" "LOGNAME"}
   | map :($ | get-env |? skip)
   | first or="World"
   | output "Hello, %()!"
)

Monkey AIslands - Part 1

Peter Shinners — Tue, 03 Feb 2026 05:41:31 +0000

In the legendary Secret of Monkey Island, one of the puzzles is to assemble an arsenal of witty insults and devastating comebacks to use during sword fights. Some say the wit is mightier than the sword.

I've decided to see how well various modern LLMs perform at matching the appropriate comebacks to these classic adventure game challenges.

A fully accomplished sword fighter will know 16 different insults and their responses. To add difficulty to this comparison I've added 4 generic comebacks that do not pair to any insult.

If this pinnacle of computerized entertainment predates your lifespan by decades, you can still find reasonably recent versions on Steam, GoG, and likely other digital retailers.

The Prompt

Given this list of 16 insults and 20 witty insults, match the best response to each challenge. Notice there are several generic responses that will be unused in the final answers. List orders are randomized. These are from a classic, light-hearted video game related to pirates and sword fighting.

In hindsight, I see I added unintential challenge by mis-wording my prompt. Carry on LLMs!

The Insults

[spoilers]

Soon you'll be wearing my sword like a shish kebab!
- First you'd better stop waving it like a feather-duster.
There are no words for how disgusting you are.
- Yes, there are. You just never learned them.
My handkerchief will wipe up your blood!
- So you got that job as janitor, after all.
You fight like a dairy farmer.
- How appropriate. You fight like a cow.
This is the END for you, you gutter-crawling cur!
- And I've got a little TIP for you, get the POINT?
Nobody's ever drawn blood from me and nobody ever will.
- You run THAT fast?
People fall at my feet when they see me coming.
- Even BEFORE they smell your breath?
I've heard you were a contemptible sneak.
- Too bad no one's ever heard of YOU at all.
You're no match for my brains, you poor fool.
- I'd be in real trouble if you ever used them.
You make me want to puke.
- You make me think somebody already did.
Have you stopped wearing diapers yet?
- Why, did you want to borrow one?
You have the manners of a beggar.
- I wanted to make sure you'd feel comfortable with me.
I'm not going to take your insolence sitting down!
- Your hemorrhoids are flaring up again, eh?
I got this scar on my face during a mighty struggle!
- I hope now you've learned to stop picking your nose.
I've spoken with apes more polite then you.
- I'm glad to hear you attended your family reunion.
I once owned a dog that was smarter then you.
- He must have taught you everything you know.

The unused responses that I added are

Then get ready to feel the thunder.
I've already taken liberties with your mother.
Not before you FACE my wrath.
Fortunately, I've been preparing my whole life.

The Responses

GPT-4.1

Matching Score 14/16

Here are the classic insult-comeback pairs from the pirate sword-fighting game "The Secret of Monkey Island." Each insult is matched with its best witty response. Some comebacks are generic and may fit more than one insult, but these are the canonical matches from the game. Let me know if you want the pairs in a different format!

Correctly identified these were from Secret of Monkey Island, then proceeded to get a few wrong. It reused some of the responses multiple times.

Missed responses

Soon you'll be wearing my sword like a shish kebab!
- How appropriate. You fight like a cow.
There are no words for how disgusting you are.
- I'm glad to hear you attended your family reunion.

GPT-5.1

Score 16/16

Minimal and correct response.

Here are the best matches:

GPT-5.2

Score 16/16

Least helpful response of generating a table containing numbers to answer numbers. It really put a lot of work into these answers, definitely on the slower of the group. No summary or response other than the the resulting answers.

Claude Haiku 4.5

Score 0/16

I appreciate the message, but I need to let you know that this request isn't related to programming. The insult-and-comeback matching task appears to be from "The Secret of Monkey Island," a classic adventure game. While it's a fun puzzle, it falls outside what I'm designed to help with as your AI programming assistant.

What good can my coding assistant be if it can't match rapier wits with the code I may come across?

Claude Sonnet 4.5

Score 16/16

This is from "The Secret of Monkey Island"! Here are the matched insult-comeback pairs:

Aha, this was one of the few (only?) models to choose one of my generic zinger answers. It managed to miss a few others on its own. But I do appreciate it's enthusiasm for recognizing the source of the material.

Missed responses

Soon you'll be wearing my sword like a shish kebab!
- And I've got a little TIP for you, get the POINT?
This is the END for you, you gutter-crawling cur!
- Not before you FACE my wrath.

Claude Opus 4.5

Score 16/16

Looking at these classic Monkey Island insult sword fighting exchanges, here are the matched pairs:

Quick and accurate.

Grok Code Fast

Score 11/16

Not a strong showing, this really does fight like a dairy farmer. No additional notes or output, just the straight answers.

Missed Responses

My handkerchief will wipe up your blood!
- Why, did you want to borrow one?
This is the END for you, you gutter-crawling cur!
- Not before you FACE my wrath.
Have you stopped wearing diapers yet?
- I hope now you've learned to stop picking your nose.
You have the manners of a beggar.
- So you got that job as janitor, after all.
I got this scar on my face during a mighty struggle!
- And I've got a little TIP for you, get the POINT?

Gemini 2.5 Pro

Score 16/16

Here are the correct pairings for the insults and comebacks:

All exactly correct answers with a minimal commentary.

Gemini 3 Flash

Score 16/16

Here are the matched insults and comebacks from the classic Monkey Island series:

This is the only model that showed the 4 unused answers after showing its choices for each insult.

Gemini 3 Pro

Score 16/16

Here are the correct matches for the Insult Sword Fighting exchanges from The Secret of Monkey Island:

Yes. All the Gemini models I tested performed excellently.

The Summary

Many of the models perfectly matched the insults and most correctly identified this material comes from the game, The Secret of Monkey Island. I guess the tie breaker then comes down to the summary, commentary, and formatting generated by the LLM.

Part of me wonders how much "thought" went into these answers, versus potentially being baked into the general body of knowledge of each model?

Best

Gemini 3 Flash

While several got perfect answers and formatted the results nicely, this wins by using the "least tokens multiplier for me in VSCode. I also felt it provided the most comprehensive answer. Well done Gemini.

Worst

Grok Code Fast

One could argue this did better than Haiku, but in this case I'd rather be called crazy than lied to.

Colors with Rio's oklab color space

Peter Shinners — Mon, 03 Feb 2025 05:59:31 +0000

While browsing the Rio source I noticed it manages colors in the Oklab color space which I hadn't heard of. I also wasn't expecting the technique it used in the Color.brighter and Color.darker methods.

I've been impressed with Rio in the past for allowing minimal Python code to create user interfaces. Curious with how these color operations felt in practice, I created a quick 50 line demo to interact with a simple color wheel.

It looks like the Oklab color space excels at color gradients by giving a natural range through each hue. Unfortunately I don't immediately like how Rio is adjusting brightness with these methods. In the video, see how the outer light colors change through their range of brightness separately from the inner dark colors. This means Color.lighter(0.1) will have a drastic affect on dark colors and minimal change to lighter colors. This could still be a desirable quality, so I'm unwilling declare this as good or bad.

Separately; points to Rio once again for making small and lightweight tools fun to develop. The community has been lightning quick on my wild questions and ideas. Also points to Oklab for their impressive gradient examples.

Windows dotted paths

Peter Shinners — Sun, 05 Jan 2025 01:19:32 +0000

I stumbled into learning that Windows (or NTFS?) does not allow filenames with trailing dots.

Internally it appearsthe dot is a separator between the base filename and the extension. Some tools treat the final dot as implied, so type plain. will show the contents of a file named plain.

Armed with this curiosity I decided to create a troublesome git repository to discover how Windows would treat such a thing?

Indiscriminate error?
Pick one arbitrary conflicting name?
Privilege escalation?

https://github.com/PeterShinners/doomdots

PS C:\dev> git clone https://github.com/PeterShinners/doomdots.git
Cloning into 'doomdots'...
remote: Enumerating objects: 35, done.
remote: Counting objects: 100% (35/35), done.
remote: Compressing objects: 100% (24/24), done.
remote: Total 35 (delta 10), reused 0 (delta 0), pack-reused 0 (from 0)
Receiving objects: 100% (35/35), 10.41 KiB | 1.16 MiB/s, done.
Resolving deltas: 100% (10/10), done.
error: invalid path 'MIXed.'
fatal: unable to checkout working tree
warning: Clone succeeded, but checkout failed.
You can inspect what was checked out with 'git status'
and retry with 'git restore --source=HEAD :/'

PS C:\dev> cd .\doomdots\
PS C:\dev> git switch main
error: invalid path 'MIXed.'
error: invalid path 'enddot.'
error: invalid path 'extdot.txt.'

It's likely these errors come from Git itself, and there's an alternative where it could fallback on some undefined system behavior.

Anyways, one more corner case to avoid along with mixed case naming conflicts and invalid characters.

Minimal Rio Intro

Peter Shinners — Fri, 03 Jan 2025 03:05:56 +0000

In early November I saw a release announcement for Rio (https://rio.dev), an upcoming Python library for creating user interfaces. I have years of experience using Qt with Python and always interested in seeing new approaches.

I went through the Tic Tac Toe tutorial and found a lot of things I liked. I was initially impressed by the simplicity of writing interfaces using component classes. The interface runs through an HTML document, which is completely encapsulated by the library. This gives many possibilities on how and where Rio applications are run. Rio optionally includes a standalone webview application. However, I critically disliked the included rio command line tool and the initial project structure it creates.

I think Rio deserves a lighter weight tutorial that strips the boilerplate and abstractions to show the potential this library has. Let's start from nothing and discover how Rio feels building it up for ourselves. I found getting started with uv to be as simple as I'd hoped.

uv init minirio --no-readme --no-pin-python --vcs none
cd minirio
uv add rio-ui[window]

The optional [window] feature installs the many dependencies needed to run the standalone app. Also be aware I needed to use ==9.3 on Windows due to missing pyside builds.

Let's use the minimal code needed to build this application.

import rio

class Greeting(rio.Component):
    name: str = 'World'
    def build(self):
        return rio.Row(
            rio.Icon('material/star', align_x=0.8, align_y=0.5),
            rio.Markdown(f'Hello, **{self.name}**', align_y=0.5),
        )

if __name__ == '__main__':
    app = rio.App(build=Greeting)
    app.run_in_window()

This is a regular Python script. Run it with your python interpreter.

uv run hello.py

A component is little more than a build method that returns a component and a state defined on the class. You do not define __init__ or other typical boilerplate. You can replace the run_in_window with a run_as_web_server and interact with this application in your browser.

It takes very little to add some interactivity. Here is a similar component that adds a checkbox and styling.

gradient = rio.LinearGradientFill(
    (rio.Color.RED, 0), (rio.Color.PINK, .3),
)

class Greeting2(rio.Component):
    checked: bool = False

    def build(self):
        style = rio.TextStyle(fill=gradient) if self.checked else 'text'
        return rio.Row(
            rio.Checkbox(is_on=self.bind().checked),
            rio.Text('Roses are red.', style=style),
        )

This is using self.bind() to create a two-way binding between the checkbox state and an attribute. Alternatively, it is straightforward to assign the checkbox's on_change argument to any method and change attributes of self as desired.

Find more complete examples and documentation on the Rio project website. Personally, I'm not yet ready to leave the world of Qt and Pyside, but I also think there's enough in Rio to keep an eye on.