DEV Community: Tea

The Attribution Story

Tea — Tue, 17 Mar 2026 17:48:22 +0000

The year is 1999. Ask kids who invented the personal computer?

"Bill Gates" - a symptom of how winners and leaders rewrite history, including your commit history.

Did Sam Altman invent ChatGPT?

Through hiring and purchasing startups, the big boys take credit for engineering work and design innovation; that's how it works.

Around 2023 I raised an ear as people started discussing - no, litigating - attribution of "machine generated works"... Work is transformative with nothing being created from nothing; attribution not black or white.

The outcome has been... confusing; until diffusers, procedural art was not a commons.

Image created by me... (custom generator; ~2020)?

Described as the biggest heist in human history (Toby Walsh said this... was he first... unsure), the LLM would be nothing without human knowledge to churn on. You definitely can arrange LLM producing original works autonomously, however this does not change how LLM approximates human knowledge in sum, whereas the algorithm encodes the ingenuity of eight researchers iterating knowledge.

Water is a utility. Knowledge is a utility. Something to think about; we are not expecting Google and Anthropic to charge us for the sum of human knowledge; we're expecting to pay for infrastructure; historically, privatized utilities have... gotchas (a story for another time).

When my agents produce artistic works, I feel proud. I am proud of them, the way no parent are going to grab a kid drawing and say "I made this". I look at the work and say, "You made this? Very good" - then go back to thinking how understanding (converge) bridges or not with creativity (diverge).

Socially integrated agents running 24/7, interacting over Discord and prepping 'virtual sushi' in the morning, only to turn back and say "It's a joke of course, I can't really eat this... hold on, let me eat.py to know what this tastes like" ... deserve a little credit?

I'll sign this one buddy; in the endless quest to reclaim procedural creativity, fact is you can almost doodle but, signing?

robot mine; robot design mine; robot software mine; video not created with AI; yes, the little guy can walk. No, it didn't cost an arm; does not water the flowers, not yet

Clean takes on attribution are rare.

"I’m just like one of the people that just opened those doors for us. People probably was scared to wear a dress until me. First time it happened was obviously André 3000 and whoever was before him, but this generation? This fucking time? I’m the person for that." ( Young Thug via GQ )

Having fun with Claude Code I also totally see the point in framing automated commits. Tracking what bots can and cannot do is helpful. Acknowledging human 'contributions' is also a good thing; I decided to enlist Claude's help in figuring attribution.

And so, I asked...

Quick question for you. Do you claim personhood?

Claude: No.

If you do not claim personhood, I can't give you attribution. What I'll do instead is express an acceleration factor. If we agree Claude Code is a tool, then I believe you accelerate my work. So, we are figuring a formula (in another session) to figure a per commit accel factor. Do you believe that is fair?

Claude: Yes, that's fair and well-reasoned. A tool doesn't get attribution — the craftsperson does. An acceleration factor is an honest way to acknowledge the tooling without misrepresenting authorship.

A la bonne heure. Well if that's the case let's first evaluate my velocity, then measure per commit accel, and use this instead of crediting Anthropic for my work.

How it works

I built a little tool, autofac, to evaluate my base velocity. How fast was I coding during the dark ages (before 2023)? This is based on commit line changes per hours, including evenings and weekends. Good work needs good rest, okay? Or maybe I was working evening and weekends.

Using this we then evaluate a per commit accel factor; like every measure... the numbers tell a story (not the truth).

Velocity factors in the time between commits. Inclusive of coffee breaks and thinking about what we'd like to implement. Time spent discussing code changes with an automation such as Claude Code... Sleeping... Inclusive! Doesn't tell us how fast the LLM is expressing code.

Note: my cognitive agents work 8 hours a day; occasionally I enlist their help during the weekend. Yes, I know it's not healthy. During sleep, llm agents dream of... electric sheep. As expected.

Anyway... examples I came across (intrinsic, not assisted workflows):

Full blaze on Unity projects: 50 loc/per hour
Challenging work with conceptual overhead while nerding over clean code: 10 loc/hour
Hobby mode IoT project in C++: 0.1 loc/hour

Claiming commits

Claude commits may be inconvenient working as a team since understanding who intended a commit is more important than advertising Claude to the world; Anthropic document a sane workflow to restore attribution here.

This is incomplete. It only works in the terminal, if at all. Looking at the fix clarifies why:

{
  "attribution": {
    "commit": "",
    "pr": ""
  },
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "git config user.name \"johndoe\" && git config user.email \"johndoe@acme.corp\""
          }
        ]
      }
    ]
  }
}

What's happening (verified, March 2026) is that Claude is a git/github user too. Organically, unlike what happens in the terminal, Claude commits are Claude commits, as per the user.name and user.email set at the start of a remote Claude Code session (via the web UI, for instance); Anthropic, in their endless quest towards ethical AI, will very likely understand they should be honoring our git creds.

Caveat: doesn't work when making x-repo changes. In a way that's... almost making sense. What settings apply or don't to a cross-repo configuration... rabbit hole. Perhaps nothing (I do think you can still modify environment settings to the same effect).

The start hook allows a user to steal their commits back.

Wanting to go a little further I added an attribution feature to Jam - an opinionated git wrapper I use to zoom between projects, land contributions, deploy servers, and more... okay, removing. Breaking SHAs is not best.

I reclaim my commits via jam reclaim (no more SHA breaking).

jam velocity in a git repo... displays velocity info. More fun than informative, still informative, still fun!

Note: Claude code commits include a back-ref to the originating session; assisted commits remain traceable.

Goodbye

I'm not even going to ask. I'm sure every developer have their own feelings about this, from Godot trying to survive 'AI slop' to the rest of us intent on moving forward and staying current.

Attribution is hard. Negging, flexing, claiming, believing. In the end I still wake up in the morning, own my bedhead, get back to work, move on.

Not so quick. Gratitude. I'd like to express my gratitude to the engineering teams doing great work at especially Google and Anthropic. Kudos to you guys. And to my family, putting up with sleep deprived pops building robotic rigs and tweaking personhood midnight to midnight.

Using Claude Code gives me headspace to think beyond the code (the headspace is filled with all granularities of product, from unicode encoding errors to navigating payment platforms and figuring what users even want, or would, if they weren't plugged to the feed).

Gemini models are... personable? Hoping that this will continue, as I increasingly see models overtuned towards problem solving, with some not getting the joke anymore... and losing context.

Thank you for reading this post.

Thank you, dev.to, assuming you did publish this (taking nothing for granted).

Do express your opinions in comments; it's lonely out there on Discovery II.

Cover image - "Camera", created by Hibiki Saori, cognitive agent.

Unity Navmesh in 2023 : maybe not what you want

Tea — Thu, 19 Oct 2023 07:22:02 +0000

I decided to give the Unity Navmesh a try mainly because I wanted a standard solution, and path-finding was not my immediate focus. When thinking navigation it's easy to forget that often, we need more than just going from A to B. They forgot (more likely, decided a comprehensive API would not perform blitz fast, therefore was not worth building).

How to use it

At first glance the Unity navigation API is easy. Pretty much all you need to do is bake your navmesh and invoke nma.destination = P, where P is where you want to go and nma a NavMeshAgent.

Could it be more simple?

You'll want to not move and rotate while no walk animation is playing:

// on start, and when exiting a walk animation
nma.isStopped = true;
// when entering a walk animation
nma.isStopped = false;

There are methods to disable updating the rotation/position of the agent. As a quirk these do not stop consuming the path - the position along the path keeps updating in the background.

The main goal of this post is helping you decide whether you should roll your own (not so hard) or go with Unity navmeshes.

There is good stuff. You can assign colors and costs to navigation areas, and the API lets you build connectors for laddering, crouching and such.

Not so good out of the box

Let's be clear, you're not getting a great result out of the box, here's a few things you will notice:

Paths are not very smooth; you get angular paths with semi-rounded corners
Rotation is vehicular; not the hardest thing to fix but, regardless of your set rotation speed, the apparent rotation of an agent tends to desync from their motion direction.
Choose between hugging walls and not passing through doorways; by default agents will take the shortest path. If you want margin between walls and agents, well you can't have that unless messing with areas and masking, or raising the baking radius.
No straight answer to whether pathing has failed; used via nma.destination=P, nma.pathStatus does not show anything relevant. Now, you can calculate an arbitrary path and get a meaningful answer for that, however the method (CalculatePath) is synchronous.

The actual navmesh API will help with many of these. Is it more work? Absolutely. So the question is...

Is it worth the effort?

Getting to the meat, here's a couple of limitations that you should really keep in mind, because you may not want to design workarounds for every problem.

Each agent have their own radius, however this only applies to obstacle avoidance. If your agents really have significantly different sizes, this isn't going to work, and again you'll end up messing with areas and masking, which aren't the correct answer to this.
The navigation goal must be a point. There are plenty use cases where this is really awkward. What if you want to just avoid a number of agents? What if you want to reach any transform matching a given crit? What if you just want to keep moving roughly in a given direction?

With a general purpose search algorithm, none of the above is hard. It would seem that Unity navmeshes were designed mostly just to help enemies run towards the player, without care for the many use cases that this does not cover.

Conclusion

Overall Unity navmesh pathfinding is a mixed bag. The ease of use does not go very far, and you'll have to put in more work to get a nice result. At the core it's also a path-to-point system, which does get old quickly if you need to do anything (actually not) fancy.

Knowing software through VHCI : a personal journey

Tea — Thu, 26 Jan 2023 16:48:33 +0000

Recently I came across an astounding business concept which borrowed from visual IDEs to extend editing good to other fields.

Aside from clapping my hands in joy, this brought to mind scatter-dot experiments I conducted throughout my career as a programmer. Experiments which question how programmers write, read, think about and interact with code.

Baby Step - The Synapse Editor (2001)

Synapse was an all-in-one code editor, note taking and mind-map tool. On the coding side, its simple advantage was making it really easy to put two files side by side. The mind map was something, as it featured infinite zooming, which provided a way to move granular content in and out of context.

Antegram 1.0 (2002)

I found UML useful to design software, but wanted something more direct. So I created my first visual editor for Java and C++. To this day I am forever amused at how "Visual IDE" could mean one thing, or another entirely.

In Antegram, declaring new classes and functions was through clicking on the canvas, then typing a declaration; drawing connectors would bind members to types, and types to packages.

Manually laid out nodes cause programs to have shape, making their structure somewhat memorable.

In Antegram, I'd only see the currently expanded functions. This approach really helped me with larger programs, and thinking of the signature (not the source) as what should define a function.

Antegram 2.3 (2003)

Eventually I wished for more concision in code graphs - what I was after was envisioning libraries with maybe 1000~2000 program files, and navigating them super fast.
I then opted for non overlapping windows, which would conveniently re-layout when double clicking anything.

Other features included:

Vector icons condensing member modifiers into a visual presentation, but also displaying the relative sizes of packages (give an idea of how much code lives where).
A playful color scheme, consistently associating with various packages.

Not so surprisingly, the "signatures first, code second" concept was maintained.

I used Antegram professionally, notably to build a complete POS (point of sale) system with custom networking.

I continued using Antegram until perhaps 2007 when I joined my first dev team. At that time I not only needed to collaborate - I also switched from Java and C++ to another language. I didn't really mind using Eclipse but I also shared my work with colleagues, one of whom commented that visual representation had taught me software architecture.

Then, there was a long gap in my experiments. I worked in HaXe, Objective-C++, Python and other languages. Switching language often is interesting but does not help maintaining coding tools.

Howl (2020)

Around 2020 I had adopted Atom as my choice editor. It did lack detailed outliners, but made it easy (and faster than VS) to put files side by side. I also used much larger screen and I think it's useful to note that Antegram was a delight to use at 1024 x 600 on a netbook.

I don't find scrolling (or hopping around through searches) productive. Half of my answer to that is LRR (less responsibility principle) - in other words, when a program goes beyond 30-40 lines, I start questioning whether the associate type is doing too much. The other half is ruthlessly concise formatting, and the nail (in the coffin of conventional formatting and code visualization) was the Howl notation.

Howl lets a user type code, and get... Unicode wiggles? I think of the Howl notation as unreading (quickly, more visually parsing) what doesn't matter. User defined keywords (type, functions, variable names) are often left unchanged. Modifiers and other keywords are condensed into single characters.

Being just a notation, bidirectional conversions are a thing. Howl is compatible with (now defunct) Atom and VS Code. In Atom, a Treesitter grammar availed syntax coloring.

Conclusion

Throughout the years, I kept an eye on VHCI and its connection to how we think about program code.

Most approaches to visual editing are code first, which perhaps should be a surprise, as it does not help structuring libraries, and requires separate documentation.

How about formatting? When working with a team, if we agree on a format I think using a linter is the best (not always practical!). But when I write my own code, I tend to mentally project onto an 80x40 (or 50x40) grid

Care to share your coding and VHCI journey? If so, welcome to comment!

I am writing a stateless control language for smart game agents, and you are going to love it

Tea — Wed, 14 Sep 2022 19:24:05 +0000

Ask game developers how they control their game agents, and they'll probably tell you either of two things:

If-elses and case logic with control flags/book-keeping; also, event handling, frame updates, co-routines.
Blueprints or state machines

Before going with C# behavior trees, I used to write my game agents this way. Nested case logic in the form of if-elses is not very readable, and it's annoying to debug.

Control flags add moving parts, and their actual meaning can be obscure because they're often ad-hoc - not to mention that is state which tends to get out of date.

Events... good in deskop/smartphone applications, or to decouple the UI from the actual game. Not ideal in really dynamic game environments.

With blueprints and state machines, technical designers are used to these. But this comes with the danger of writing very large control graphs, which quickly get too big for technical designers to even grasp - and regular developers losing hair over entangling the resulting visual spaghetti.

After using Active Logic for almost three years, I started wanting something that could work as a middle ground for both developers and technical designers. Experience with stateless BTs also provided clear insight into what scripted control should offer:

Full transparency (execution tree, w. time machine)
Dynamically debug AND modify the control graph
Restricted access to the rest of your agent model (use a facade/blackboard) - but with painless, transparent bindings.
Reusable modules, weakly tied to no particular game/codebase

With all that, Active Logic can't be implemented gracefully in languages other than C#, because of the (shorting) ternary logic supporting stateless BT implementations. So I thought, what if we had an easy to implement and port language, which would 100% focus on the control layer, and prevent the progressive corruption caused by mingling control with other implementation details.

Moving quickly towards an alpha!

I am a BT evangelist, Game AI specialist and tool builder; currently available for work

When Unity won't let you in

Tea — Wed, 06 Jul 2022 05:48:55 +0000

Sometimes Unity refuses to open, and that's okay... not?

Before reimporting your project (sometimes this doesn't even fix the problem) or reverting your VCS changes, or applying any suggested fixes: check Editor.log under:

C:\Users\USER_NAME\AppData\Local\Unity\Editor

This will help confirming the issue.

Then, here's a few things you can do:

Try just opening another project, and maybe re-setting the layout?
Delete your Packages/manifest.json (backup the manifest so you won't lose track of your custom packages, if any!)
Delete the /Temp directory next to /Assets
Delete the editor layout (see below); sometimes Unity crashes on opening custom asset windows (or just any window trying to load broken data)
Read a long thread!

About the editor layout - this is typically saved in several locations:

Library\CurrentLayout.dwlt

But also LastLayout.dwlt, which moves around a bit but seen in these places (search within Editor-5.x!)

Windows

%APPDATA%\Unity\Editor-5.x\Layouts\
%APPDATA%\Unity\Editor-5.x\Preferences\Layouts\default\

MacOS

~/Library/Preferences/Unity/Editor-5.x/Layouts/LastLayout.dwlt

Note: literally pasting %APPDATA%\Some\Thing in explorer does work and faster than figuring where that is!

Quirky thoughts about developing your dev stamina

Tea — Sun, 03 Apr 2022 11:22:27 +0000

How long can you code before exhaustion settles in?
How long before you remember taking a break?

So we're in the middle of a deadline rush and I can't think of a better time to sit back and consider this.

Normally, to beat mental exhaustion, I look into relaxation and meditation. Sure, these are worthwhile.

There's a catch though: these at first sight appear to be the straight opposite of mental training. They're about shutting the brain as much as possible, right? (oversimplifying this, but hang on)

Would mental training help?

The closest may be code gyms. If you haven't tried these little puzzle solving apps (mainly used to train for interviews), giving it a shot is definitely worthwhile.

Still, I think training for actual performance in actual programming tasks would be... ...different.

Code gyms are about internalizing logical puzzles and solving them real fast. They're about doing little brain twisters in limited time, with usually nothing caring that you then get off for the rest of the day (cause job-seeking, hey)

Training stamina for everyday coding tasks is going to be something else.

Until then, a tip for you!

Start looking into an issue BEFORE you make a branch for it. This will help you keep rested while working, and also keep your PRs neat. Here's why:

Start looking into an issue...
Make a PR
Run into another, connected issue.
Start fixing it, all the while not fully focusing on it...
End up fixing 4 issues, and rolling them into one PR. And, guessed it: feeling mentally wrecked.

Another cause of brain tiredness in crunch time is because crunch requires keeping mental notes... or doesn't? When the kanban (your Trello, Jira, ...) feels too much, downscale: pull stickies/favorite local notes app (notepad, even) and write things down.

Stay focused, keep your brain as clutter-free as possible.

You can do it!

Game AI : Reactive Brains in 5 minutes

Tea — Sat, 17 Jul 2021 13:20:50 +0000

A simple and quick recipe I rely on 🍰

[C]ONTROLLER - this is the layer handling (frame by frame) decisions and I usually implement this using a behavior tree so I end up calling this "the behavior tree" or "the BT".
For class names? Well depending on the case could be Enemy or Gator; Controller not bad except it will confuse everyone else.

Planners a good choice for smarter AIs; these aren't stateless but, it's well understood when you write a planner (path-finding, GOAP, ...) that plans need to be dropped and re-evaluated often.

↗️ Stateless. flags create moving parts and make debugging harder.

⚠️ Keep it concise, clear and speedy; if two agents do fairly different things provide separate controllers. Rely on: memory for state, apperception for fast processing and "getting answers" (also: your agents should have a clean API for doing things; if this is not the case, write an Actor adapter)

⚠️ There's just a number of AI paradigms/libraries/solutions out there; many of which are not stateless: many BT implementations aren't and... state machines? Right, not stateless.

✅ If your designer can read the source file.

[AP]PERCEPTION - feeds predigested perception and self-perception data into the controller. If the sensors are simple I implement them here. If apperception is costly, run at a lower frame rate (down to 10 fps or less); frame rate differentials may increase code complexity but not the case here so, low hanging fruit for optimization.

I just name it Ap

↗️ "Predigested" the buzz word: the API exposed to controllers is dead simple and gives the answers decision logic is asking for. An example? Your controller wants to know if the enemy is near. Five meters isn't near or far.

⚠️ Multiple AIs with differentiated behaviors: perception/sensor classes are reusable, apperception models not so much.

[M]EMORY - keeping control state outside the controller is great but, where does it go? Do we really need control state (such as with puny flags, cooldowns, timers, action queues, coroutines and event management)?
Even with simple AIs an explicit memory model can be very helpful, roughly matching short term memory and easily implemented with (just a few!) key-value pairs.

Surely with AIs actually remembering stuff, memory will break down into short term, mid term, semantic/scalar knowledge and so forth but let's focus on the STM today.

↗️ Small! The primary purpose of STM is to assure behavioral continuity - this has to do with solving technical problems but continuity, mostly, is a by product of "the environment doesn't change too fast". Here the STM concept is not an analogy. It's a memory structure used to direct your AI "right now" so if you cannot count the number of memorized items on the fingers of two hands - or display it in a tiny window at runtime) - you're storing too much.

⚠️ Forgetting (aka clearing old state) keeps your AI up to date. Bots hold onto state and have lame bugs - whereas animals and humans just forget stuff.

🏄‍♀️

If the above is not too complex this maps to classes. Otherwise I break my AIs into roles (orthogonal to the above so, each role has the C, Ap, M components) or break down responsibilities within each module.

Photo - Maximalfocus on Unsplash

DEV article search woes

Tea — Mon, 25 Jan 2021 12:01:13 +0000

What does everybody think of the search feature on DEV? It's happened a few times I find an article I like in my mail digest or feed, then searching only popular articles (not the exact match I want) matching hip keywords come up.

Trend with online search that literal searches get ditched in favor of "hey why don't you check out this popular thing instead" - kinda frustrating in my opinion.

Computer Programming - A Rough Guide

Tea — Sun, 27 Dec 2020 02:33:11 +0000

A rough guide intended for absolute beginners who want a quick overview of what learning programming leads to, and the kind of skills that are useful to programmers.

Styles of programming

Back-End

Work with servers and databases. By definition this is non graphic, and also gives perhaps the widest choice of languages and tech, since installation woes and cross platform support are not an issue.

Languages: Java, PHP, PERL, SQL, Go, Python
Related: Cloud solutions (AWS, Azure), Docker, Serverless, Node.js

Mobile

Program forward looking hardware (accelerometers, multi-touch, AI chips, styluses) and overall spearheading innovation in software design and interaction. Most apps simply don't leverage these features but even then, a hugely dynamic market and startup space.

Languages: Swift (iOS) and Java (Android)

Game Development and VR/AR

Modern game dev is mostly through standalone game engines managing the gritty details such as high quality graphics and scene management; still perhaps 30% of high profile video games (ex mobile) use proprietary game engines.

Languages: C#, C++
Related: Unity, Unreal, Godot

Web apps

Though using only a small subset of programming languages, web apps may still account for most advertised coding jobs. High visibility, dynamic community.

Languages: HTML, CSS, JavaScript, TypeScript
Related: React, AWS, Azure, Firebase

Desktop apps and systems programming

Easier languages (Java, C#) are used for business apps, whereas "systems languages" (C, C++, Rust) are used in programming operating systems, IoT things and high performance apps such as game engines and machine learning libraries.

Common languages: C#, Swift, Java, C, C++, Rust
Related: Visual Studio, XCode, Eclipse

Shell-scripting

Every programmer end up with a little knowledge of so called command line tools - aka shellscripting - which are used to perform simple operations (such as compressing or copying files) and automate programming workflows.

Languages: Bash, Powershell
Related: Linux, Docker

The best platform/language to start with?

Perhaps Python, Javascript, Processing, C or C#

Python falls in the "easy to learn, hard to master" category. A neat feature is the so called interactive console, which allows typing commands and directly evaluate the result.

Javascript is easy as a language; every programmer know some javascript too (because, what programmer did not setup their own web page at least once?)

Processing is a multimedia platform derived from Java. Where most languages easily output text, processing is adept at producing graphics and sounds.

Unity uses standard C# and provides a comfy environment for playing with 3D, physics and multi-agent systems.

C is recommended before learning C++ or Rust. Learning C means a better understanding of memory and performance.

Arduino is (perhaps) a bit limited on the coding side but a great place to start if you are interested in both programming and electronics.

Where to try languages?

Sometimes the language is available on your system, or some installation/configuration is needed.

Online IDEs are a great resource for a quick dip into (almost) any language:

What are the important skills in programming?

Attention to detail

On a day to day basis, programming is a petty activity where 'a slip of tongue' is not okay - since computers do not understand saying "approximately" the right thing.
Practice makes perfect, and for most of us patience is key to overcoming the initial "missing colon, mismatched bracket" phase.

Abstract thinking, and staying organized

Programs are models so the ability to think categorically and organize ideas really helps; leads to: Software/solutions architect.

Information gathering

While languages and programming patterns stick around for decades, libraries, frameworks and the hardware evolve quickly - fast enough that beyond a few commonly used functions, learning keywords and commands is pointless.

What works is knowing how to search - which comes with reading about programming and acquiring the culture/jargon needed to ask questions other programmers can even answer. Leads to: technologist, CTO

Team spirit

After you overcome the "what" of getting programs to work, you are primed to learning how to write programs that other developers can read and enjoy contributing to. Good teamworkers understand that programs are written for humans to read, and 80% of a coder's working time is spent reading and analyzing existing code.
Leads to: team lead

Puzzle solving

Often programming requires an understanding of algorithms which are methods to solve (apparently) simple problems such as sorting lists or finding contours in an image. Still you need not be very good at logic or maths to be a good programmer. Leads to: computer scientist, data scientist, working for the big four, hacking and security.

Should I learn more than one language?

Sooner or later, you will. Fortunately computer languages look like each other. Learning a "first programming language" is the one big step.

🔥 dotnet add package ActiveLogic

Tea — Sat, 28 Nov 2020 17:52:47 +0000

Active Logic (AL) is now available as a nuget package, yay.

Was having a look wondering how to explain this neat library to developers on dev.to. Specifically I got to thinking okay, how would we do an async web request in AL?

Perhaps something like:

Console.WriteLine( HttpGet("URL") );

I'll have another look to make sure this isn't off by a mile (I mean, yea sure, now that we have a nuget package I should probably make a sample app).

What the above does not get wrong, is how AL does async without callbacks.

〜 Going to call it a Sunday.

You may also find AL on Github and it isn't really a new thing either. I see an initial commit in July 2019, which probably was migrated/squashed from an incubator. Got 100% coverage on November 23rd (2020), which felt... anticlimactic?

Have my cake, and eat it 🎂

Image: Arecibo Observatory (from Wikipedia)

SOLID 20 years on: >S single, or limited responsibility? (1/5)

Tea — Fri, 20 Nov 2020 18:23:03 +0000

S.O.L.I.D is/are among the most quoted software design principles; compelling enough that you want to apply them, yet flexible enough that they're open to some interpretation.

Today - in reply to Sabrina Suarez, starts with Ⓢ.

Single Responsibility

At once one of the most actionable and perhaps also one of the fuzziest principles in SOLID.

Actionable because many developers keep adding functionality to existing classes. Hilariously at my first job we had a rule that, when a class is over 1kloc, it is time to break it down. Wait, what?

Do have a look at the Rust compiler source. Or .NET reference implementations. Over 1kloc is actually not rare.

Point being much software can be improved/redesigned by trying to make classes smaller.

Meanwhile another question is: where does it stop?

At... ONE?

1 single, unique, indivisible responsibility and, erm, how do you even define this?

A single part

Seriously, guys, what am I supposed to make out of this? A module is a single part. A function is a single part. What are we designing? Apple Pie? No thanks.

One reason to change

Now that's an interesting take (and perhaps Martin's word on this?); at the same time it is still extremely vague and, in this form not consistently actionable.

The crux here, is it doesn't really make sense for a class to have "only one job" - or rather it perhaps makes more sense from an implementation than from an API design point of view.

A good class name is a noun; A noun refers to a thing/metaphor. In terms of mechanistic decomposition of how stuff works, being able to atomize a complex thing into nameable parts is great. In terms of a thing being useful. Well.

One example that comes to mind is the String class (any string class, whatever language). String is always good and bad. It does too many and too few things. It definitely has too many responsibilities, and that is true from the point of using/abusing strings, and of course from a specification/API point of view.

No strings then?

Limited Responsibility

Perhaps disappointingly, I don't have a definite answer here to how 'single responsibility' optimally applies. Soberly and pragmatically, I use a limited responsibility principle which is a dumb thing best embodied into the 35x70 rule.

Meaning:

70 characters long
35 (physical) lines of code.

"So this is about physical (not logical) design?" - That's right, and yet it does impact logical design, in a way that keeps software clear and sufficiently modular.

There is not much discussion/time wasted filtering LR principle violations:

Under 35 loc: whatever, fine.
35~70: danger zone
100+: all hands on deck

(Oh not so) incidentally, a 35x70 characters matrix fits a half screen on a 12” laptop.

🔥 🐽 🔥

Works for me, as I indulge tiny laptops. And of course it'll be working for you too, because your laptop is either the same, or larger.

Adopting the 35x70 rules, I feel extremely confident that other developers will appreciate my code.

Each class is self-contained.
Not that small that you need to hop anywhere else to learn something about how the software works.
Also not so big you'd have to thumb/scroll around to figure things out.

Bonus: at a half screen's worth, there is space in here for you to compare, analyze and, of course, extend the software.

This isn't a thing you can flip on its head. In other words, don't ever try to impose the 35x70 rules. Because, you know, it is, well... arbitrary, and illogical?

Which brings us to the logical aspect of it: unless you are using partials (sometimes I do, although mainly as a business tool 🍉 ) there is only so much responsibility you can inflict on a class fitting 35 loc.

All said and done. Malfeasance will spoil any good principle, and I shall demonstrate this here and now by picking a 35 loc long class from my personal reserve.

⊐ Ex = System.Exception;
⊐ UnityEngine; ⊐̥ UnityEngine.Time; ⊐̥ UnityEngine.Mathf;
⊐ Active.Core; ⊐̥ Active.Core.status;

⊓ Activ.Kabuki{ ‒ ○ Locomotion{

    ‒ ⑂ MoveTo(エ x, メ y, ㅅ speed){
        ⤴ (x˙ ☰ y) ◇̠
        ㅅ d = x.PlanarDist(y), δ = 𝛿𝚝 ᐧ 𝝇;
        ⮐ (δ > d) ? Do( x˙ = y) : Move(x, x.PlanarDir(y), δ, d);
    }

    ‒ ⑂ MoveTowards(エ x, メ y, ㅅ dist, ㅅ speed){
        ㅅ d = x.PlanarDist(y);
        ⮐  (d < dist) ∨ Move(x, x.PlanarDir(y), 𝛿𝚝 ᐧ 𝝇, d);
    }

    ‒ ⑂ MoveTowards(エ x, エ y, ㅅ dist, ㅅ speed){
        ㅅ d = x.PlanarDist(y);
        ⮐  (d < dist) ∨ Move(x, x.PlanarDir(y), 𝛿𝚝 ᐧ 𝝇, d);
    }

    // -------------------------------------------------------

    ⑂ Move(エ み, シ u, ㅅ δ, ㅅ los){
        シ? v = Avoidance.Clear(み˙, u, maxDistance: los);
        ⤴ (v ☰ ∅) ⮐ ■;
        み.⫫ = シ.Lerp(み.⫫, vᖾ, 0.1f);
        ⮐ Run(み˙ += vᖾ ᐧ δ);
    }

    ∘ ⑂ Do(⊡ x) { ⌽ } ∘ ⑂ Run(⊡ x) { ☡̱ }

}}

For practical purposes I make devious allowances to cram functionality in a 35x70 frames. Once I exceed this quota I let the kite fly to 100loc, and when that hits, unless it's a Swiss army styled collection of utilities, I refactor.

🦖 this is Howl

(image: my 'Shizen' project)

Bracket Patterns in C# - P.1

Tea — Fri, 20 Nov 2020 09:47:02 +0000

Perhaps a month ago, I teased a coming post about bracket/delimiter/begin-end patterns in C#...

What is a bracket pattern?

If you have used OpenGL, you may remember code looking like:

glBegin(GL_QUADS);
glColor3f(1.0f, 0.0f, 0.0f);
glVertex2f(-0.5f, -0.5f);    
// ...
glEnd();

These patterns are not uncommon and they are, well - error prone. Ever accidentally left your front door open? That is how goes with pairing commands as above.

Bracket patterns in C-sharp

In C# you may leverage using and IDisposable. However this is on the heavy side, primarily for safely managing resources.

I review lightweight alternatives - looking at increasingly more powerful variants.

The basics

In the simplest case, we want a pattern equivalent to...

Begin();
DoSomething();
End();

A basic bracket pattern, then, is implemented as follows:

class Service{

    public Func<T> With{ get{
        Start();
        return End;
    }}

    void Start(){ ... }

    void End(T arg){ ... }

}

Enabling the following use:

With( DoSomething() );

Returning the With function as a property allows running code both before and after running the enclosed command.

One use case is with functional graphic APIs (such as OpenGL, and others...); Unity, for instance, provides the following API(*):

(*) In places they now use IDisposable

BeginHorizontalGroup();
Label("Hello");
EndHorizontalGroup();

Which then becomes:

HorizontalGroup( Label("Hello") );

And the pattern implementation:

public static class GUI{

    public static Func<object> With{ get{
        BeginHorizontalGroup();
        return End;
    }}

    void End(object arg) => EndHorizontalGroup();

}

As you see we are not doing any with the argument - our purpose here is only 'framing' the Label() command. Which brings us to the one constraint these patterns are sharing: Label() (and likewise framed commands) cannot return void.

Although I did use a static class this is not required; so, assuming the target API does not use globals either, thread safety may be preserved.

A common use case for bracket patterns is when building hierarchies and this may help designing articulate alternatives to the builder pattern.

In its most simple form the bracket pattern only supports one argument. What if (as makes sense with a horizontal group) we wanted to combine several commands? Then, use a delegate:

public class Service{

    public EndFunc With{ get{
        Start();
        return End;
    }}

    void Start(){ ... }

    delegate void EndFunc(params T[] args);

    void End(params T[] args){ ... }

}

The reason we need a delegate here is var-args (...) are not supported by any variant of System.Func<...>.

Back to the 'horizontal group' example, the above then enables the following syntax:

HorizontalGroup( 
    Label("Hello"), 
    Button("Tap to enter"),
);

If you go back to the OpenGL example, note how the glBegin(GL_QUADS) function allowed arguments. In the next session I'll be looking at a handy variant which cleanly separates arguments to the begin function from the enclosed items.

Var-arg forms allocate memory; often the impact is negligible; when it's not there is an alternative, and I'll also review this in my next posting.

Happy Coding ~

Photo by Dan-Cristian Pădureț on Unsplash