Author: Chris F Carroll

A Proposal for Credit Assignment — Concerning the U.K. Goverment’s consultation on Copyright and Artificial Intelligence

The training of A.I. and machine learning models is, in the technical vocabulary of the field, a problem of credit assignment [1]. The entire achievement of a machine learning training algorithm lies in accurately tracing the myriad miniscule connections — assigning credit — to those features of the input data responsible for achieving each output target in its training data and targets.

It would be ironic then if, tasked with assigning credit to their inputs for their outputs, A.I. modellers should baulk and call that too daunting a challenge.

It is not necessary to achieve a great degree of accuracy, or timeliness or even consistency in assigning credit to content creators and IP holders whose property has been used to train models. A little effort to provide something that is half accurate most of the time would be a helpful start.

It is not necessary to invent a new compensation model, or a new process for registering the interests and contact details of IP owners. The music industry designed and implemented solutions for this problem over a century ago. Without the aid of A.I. Or a computer.

There is such a thing as legalized robbery. For instance, loan sharking used to be legal, but it was still robbery even when it was legal. We prefer to make such things illegal because it is wrong to let those with the will to do so to take advantage of people over whom they have an advantage of, for instance, physical strength.

In commerce, strength is largely financial, partly political. The bigger, better-connected company is immensely more powerful than the individual content creator. Just as with SLAPP cases and with libel laws, the legal battle is too one-sided to even contemplate.

The UK consultation on IP and A.I. provides a unique opportunity to develop and implement a far better vision. The relationship between A.I. developers and IP holders can and should be a positive, mutually beneficial, symbiotic relationship.

A.I. certainly depends, utterly, on IP creators. If the A.I. developer monetizes whilst the IP holder is left with nothing that would be parasitic and destructive[2], not symbiotic. If an algorithm and system is implemented to reasonably share with IP holders fair recompense for their works' contribution to A.I. output, the relationship could be symbiotic, mutually beneficial, and even a virtuous circle of increasing benefit to both. Not to mention the rest of us.

[1] https://www.google.com/search?q=back+propagation+as+an+algorithm+for+credit+assignment

[2] https://www.inet.ox.ac.uk/news/new-study-reveals-impact-of-chatgpt-on-public-knowledge-sharing

On Learning To Be A Strategist. “The 10-minute Strategist” Book Review

The 10 Minute Strategist
Martin Turner, Ingenios Books, 2018
9781980750956

Anyone wanting to be anyone these days needs a good line on strategy. It pretty much defines itself as “the important stuff”.

One route to strategic expertise could be to sign up for business school. A faster, cheaper option might be to get the textbook. Mintzberg, Ahlstrand & Lampel’s “Strategy Safari” could lead you, in 400 pages, through Ten Schools of Strategy and explain what each one offers, with its strengths and weaknesses.

Or—for those whose goal is to become very good at forming strategies, instead of at writing essays—there is Martin Turner’s The 10 Minute Strategist.

The book uses Mintzberg’s ten schools as ten angles on strategy. It scores over the older more pedestrian work in two important respects. First, it is a fraction of the size, readable in a few hours. And secondly, it is immediately usable. Its notable tactic is showing you how to deploy each school as a strategic question, together with an appropriate tool or framework to explore that question and evaluate candidate answers. Equipped with this, you can use each strategy school to explore the challenges you face from the point of view, and using the strengths, that each one offers.

The result is outstandingly well-rounded and practicable. Instead of being strategically limited, knowing only one or two ideas of what a strategy is, having ten approaches at your finger-tips enables you to rapidly pick out the angles most important to your current situation, and yet still be confident you have considered the other angles too. Your risk of shipwreck or failure further down the line, from surprises your strategic approach didn’t consider, is cut exponentially.

To save you some hours in the library, the ten schools of strategy are the power school, the entrepreneurial, the cultural, the… well, find the others in the book. Meanwhile, consider instead Turner’s questions that represent each school. Turner’s ten strategic questions are:

⁃ What’s the situation?
⁃ What’s the big idea?
⁃ Do we dare?
⁃ Who is with us?
⁃ What are we good at?
⁃ What are we doing that’s different and how will we take people with us?
⁃ What actions do we need to take in what order?
⁃ How will we get better as we go?
⁃ How are things arranged?
⁃ How will this strategy change us?

I typed those out from memory, because The 10 Minute Strategist includes a handy 10-letter mnemonic — “STRATEGIST” — for remembering the 10 schools and the corresponding question. Situation, Thinking, Resolve, Allies, Tactics, Embedding, Gameplan, Improvement, Systems, Transformation.

This is a second notable feature of the book. The medical profession (Turner has been amongst other things an NHS trust director), uses mnemonics pervasively to memorize and recall key headings for hundreds of conditions on the spot. The 10 Minute Strategist does the same. For each question and its associated tool(s), you have some kind of mnemonic or memorisable plan for how to explore it, or to evaluate what you’ve got so far.

Expert thinkers are recognisable by their knowing, within their area, just the right questions to ask, and knowing what good answers looks like. So this approach, using questions plus a tool or framework for developing and evaluating candidate answers, strikes me as fundamentally correct. To be the person able to lead your team to find the right strategy, you want to have the right questions, and an idea of what good answers look like, all on the tip of your tongue.

After a discussion of how and why strategies fail, the meat of the book is then a walkthrough of how to use each of these questions, and what their associated viewpoints offer to you, the budding strategist.

Some strategic tools, such as SWOT, are well known. Turner offers critique and history (did you know that the consultancy that invented SWOT stopped using it?) and suggests for each school the tools or framework with which you can most effectively deploy it.

Throughout, Turner uses examples or guidelines at three timescales. One running example demands a strategy within 10 minutes, because lives are at immediate risk. The second is guidance on how to lead people through a two-day long strategy workshop. The third is how to extend that into strategy formation in the context of very large very complex organisations, with entrenched interests and fiefdoms.

The 10-minute timescale —strategy for a single day— may surprise you. Yet it is the key idea that can help you become a strategist! At very, very best you could get two chances in your lifetime to develop a large-scale strategy. That’s not even enough practice for you to get past the “newbie” level of mistakes. This is surely one reason why large strategies are more famous for their failures than their successes.

Turner’s proposition then, is that by determined practice in applying his ten strategic questions right now, on your present daily challenges, you can become, even early in life, the kind of thinker who when faced with the big challenges has already mastered the skills of how to find and develop winning strategies.

This is the heart of what the book offers. A guide for you personally to learn, to grow, and to become a successful, reliable, strategist.

Where to Buy

UK

Amazon (UK)

World of Books (UK)

USA

Amazon

Blazor Cascading Parameters don’t “just work” with lambdas or method callback

TL;DR: Blazor Cascading Parameters are matched by Type not necessarily by Name. The simplest solution is to declare the Parameter type as Delegate. If you need to distinguish more than one delegate cascading parameter, then declare a named delegate type (that's a one-liner in C#) and use that as the parameter type.

The problem

You want to pass a callback as a cascading parameter. You try passing a lambda, or possibly a method, and create a CascadingParameter property, with matching name, of type Action or Func<...> or similar, to receive it. But the cascading parameter is always set to null.

Cascading parameters are matched up by Type, not by name, and who knows what the compiled type of a lambda will be? The C# reference tells you that that lambdas can be converted to delegates or expression trees but 'can be converted to' isn't good enough for matching up by Type.

The quickest fix

Declare your parameter to be of type Delegate. Most callable things in C# are of type Delegate.

// Declaration in the child component
[CascadingParameter]public Delegate OnChange { get; set; }

// Use in the child component. The null is what DynamicInvoke requires for 'no parameters'
OnChange.DynamicInvoke(null);

# In the parent container
<CascadingValue Value="StateHasChanged" >

If that's not good enough

If you must distinguish between several Delegate parameters, or just want to better express intent in your code, you can define a named delegate:

public delegate void StateHasChangedHook();

and use that as the Type of your CascadingParameter:

// Declaration in the child component
[CascadingParameter]public StateHasChangedHook OnChange { get; set; }

// Use in the child component is slightly simpler
OnChange();

# In the parent container
<CascadingValue Value="(StateHasChangedHook)this.StateHasChanged" >

When you use named delegates, you can invoke them with onChange() syntax instead of .Invoke() or DynamicInvoke(null).

You can inspect what was set in the child parameter

log.LogDebug("OnChange was set {OnChange}.MethodInfo={MethodInfo}",OnChange,OnChange?.GetMethodInfo())

Recall that Action<> and Func<> are themselves named delegates, not types. They are declared in the System assembly as for instance: public delegate void Action<in T>(T obj)

What are the ARIA roles & accessible names for HTML Elements?

To work with HTML elements via their ARIA attributes, you must learn a minimum about two ARIA attributes:

  1. The ARIA role
  2. The ARIA accessible name, which can and should be a human-readable piece of text such as Your Name, not an html id like your-name.

But it is said that no ARIA is better than bad ARIA! So here is your bare-minimum ‘must-know’ to work successfully with aria role and aria accessible name.

An example: aria roles and names for a small form

testing-library pushes you to target elements in your tests by aria role and name, in the hope that you are then testing what your user interface actually presents to a user. Here's a testable example of the role and accessible names for a small form which you can run from an npm project with devDependencies @jest and @testing-library:

import '@jest/globals'
import '@testing-library/jest-dom'
import {screen, fireEvent} from '@testing-library/dom'

test('Example role and accessible names', ()=>{

      const div= document.createElement('div')
      div.innerHTML=`<form data-testid='form1'>
        <fieldset>
          <legend>Form Alpha</legend>
          <label>Search : <input type='search' value="something" /></label>
          <label><input type='checkbox' /> In Stock Only</label>
          <button>The Go Button</button>
        </fieldset>
      </form>`

      document.body.appendChild(div)

      const fieldSet= screen.getByRole('group',{name:"Form Alpha"})
      expect(fieldSet).toBeVisible()

      const searchBox=screen.getByRole('searchbox', {name:/Search/i})
      expect(searchBox).toHaveValue('something')

      const checkBox=screen.getByRole('checkbox', {name:/in stock only/i})
      expect(checkBox).not.toBeChecked()
      fireEvent.click(checkBox)
      expect(checkBox).toBeChecked()

      const form=screen.getByTestId('form1')
      expect(form).toBeVisible()
})

Now, some of these names and roles you could have guessed and some of it you couldn't. Let's take out the guesswork.

What Role and what Accessible Name do my HTML elements have?

HTML Element Roles

You can get a quick idea of roles just by looking at some of the defined ARIA roles:

  • article, banner, button, cell, checkbox, columnheader, combobox, command, comment, complementary, composite, contentinfo, definition, dialog, document, figure, form, generic, grid, gridcell, group, heading, img, input, landmark, link, list, listbox, listitem, log, main, mark, marquee, math, menu, menubar, menuitem, menuitemcheckbox, menuitemradio, meter, navigation, option, presentation, progressbar, radio, radiogroup, range, region, roletype, row, rowgroup, rowheader, scrollbar, search, searchbox, section, sectionhead, select, separator, slider, spinbutton, status, structure, suggestion, switch, tab, table, tablist, tabpanel, term, textbox, timer, toolbar, tooltip, tree, treegrid, treeitem, widget, window

Most of them split into document structure and landmark roles vs widget and composite widget roles and you can probably guess most of which html elements implicitly have which roles by default, but some you would guess wrong. The other categories of roles are Abstract, Live Region, and Window. Some of the roles form hierarchies, with sub-roles.

Here is a table of the implicit ARIA role given by default to some commonly used html elements, along with the permitted overrides.

Implicit ARIA Roles for some common HTML elements

HTML Element Implicit ARIA Role Permissible explicit Roles
nav navigation none
article article document, main, presentation &c
a href="..." link button,checkbox,menuitem &c
a without href none any
button button tab, checkbox, combobox, link, menuitem, &c
form form but only if it has an accessible name search, none or presentation
fieldset group radiogroup, presentation, none
img alt="..." img button, checkbox, link, menuitem, option, tab &c
img alt="" presentation presentation, none
input[type=button] button checkbox, combobox, link, &c
input[type=checkbox] checkbox button with aria-pressed, &c
input[type=image] button link, menuitem, radio, switch &c
input[type=number] spinbutton
input[type=radio] radio menuitemradio
input[type=range] slider
input[type=reset] button
input[type=submit] button
input[type=search] with no list attribute searchbox none
input[type=search] with list attribute combobox none
input[type=email] with no list attribute textbox none
input[type=email] with list attribute combobox none
input[type=tel] with no list attribute textbox none
input[type=tel] with list attribute combobox none
input[type=text] with no list attribute textbox combobox, searchbox, &c
input[type=text] with list attribute combobox none
input[type=url] with no list attribute textbox none
input[type=url] with list attribute combobox none
ul,ol list directory, group, listbox, menu, menubar, &c
label,legend,caption none none
main main none
menu list directory, group, listbox, menu, menubar, &c
optgroup group none
option option none
select with multiple attribute & no size greater than 1 combobox menu
select otherwise listbox none
textbox textbox none
table table any
td cell, if a descendant of a table any
th columnheader or rowheader any

You can see some patterns:

  • Many elements such as main, article, option, textbox have a fixed semantic meaning which is pretty much the same as their role. They can only have that fixed role and it can't be overridden.
  • Some elements have no implicit Aria role but can be given any explicit role. These elements include div,span,code,blockquote,most of text elements such as em,strong, &c. Only give them a role if they really will play that role! For instance if you use them as parts of a custom widget. Otherwise they are best without a role. Not everything should have a role.
  • Invisible elements such as style and script have no aria role and are not permitted an explicit role either.
  • Label, legend, caption are in a sense special elements whose aria job is to label some other element with an accessible name. They can't be given any other role.
  • Some element roles including a,img,select (and of course input) depend on how their attributes are set.
  • See the HTML element reference pages to find the full list of html elements and the full list of permitted explicit roles for those that aren't in the above table.

The table mentions what explicit roles can be given. An explicit role is given to an HTML element by giving it a role="rolename" attribute. But the advice is to only do this when you have to. Work with the native HTML roles.

HTML Element Accessible Names

An accessible name can and should be a human-readable piece of text such as 'Your Name', not an html id like your-name.

To understand what the accessible name of a component is, you must understand the accessible name computation. Here are, roughly, the first 3 steps of the accessible name computation for HTML. This is enough to get you off the ground and calculate most of your accessible names.

The Accessible Name Computation for HTML Elements

  1. The aria-labelledby property is used if present.
  2. If the name is still empty, the aria-label property is used if present.
  3. If the name is still empty, then the 3rd step depends on the element and is described in the w3.org Accessible Name Computation Section By HTML Element. Here is a summary table:
HTML Element Accessible Name Calculation if the element has no aria-label or aria-labelledby
<input type="text">, <input type="password">, <input type="number">, <input type="search">, <input type="tel">, <input type="email">, <input type="url"> and <textarea> Use the associated label element or elements accessible name(s) - if more than one label is associated; concatenate by DOM order, delimited by spaces.
If the accessible name is still empty, then: use the control's title attribute.
Use the control's placeholder value.
<input type="button">, <input type="submit"> and <input type="reset"> Accessible Name Computation Use the associated label element(s) accessible name(s) - if more than one label is associated; concatenate by DOM order, delimited by spaces.
Use the value attribute.
For input type=submit and type=reset: if the prior steps do not yield a usable text string, and the value attribute is unspecified use the implementation defined string respective to the input type.
Otherwise, if the control still has no accessible name use title attribute.
<input type="image"> Accessible Name Computation Use the associated label element(s) accessible name(s) - if more than one label is associated; concatenate by DOM order, delimited by spaces.
Use alt attribute if present and its value is not the empty string.
Use title attribute if present and its value is not the empty string.
Otherwise if the previous steps do not yield a usable text string, use the implementation defined string respective to the input type (an input in the image state represents a submit button). For instance, a localized string of the word "submit" or the words "Submit Query".
<button> Use the associated label element(s) accessible name(s) - if more than one label is associated; concatenate by DOM order, delimited by spaces.
Use the button element subtree.
Use title attribute.
<fieldset> If the accessible name is still empty, then: if the fieldset element has a child that is a legend element, then use the subtree of the first such element.
If the accessible name is still empty, then:, if the fieldset element has a title attribute, then use that attribute.
Otherwise, there is no accessible name.
<output> Use the associated label element or elements accessible name(s) - if more than one label is associated; concatenate by DOM order, delimited by spaces.
Use title attribute.
Other Form Elements Use label element.
Use title attribute.
<summary> If the first summary element, which is a direct child of the details element, has an aria-label or an aria-labelledby attribute the accessible name is to be calculated using the algorithm defined in Accessible Name and Description: Computation and API Mappings.
Use summary element subtree.
Use title attribute.
If there is no summary element as a direct child of the details element, the user agent should provide one with a subtree containing a localized string of the word "details".
If there is a summary element as a direct child of the details element, but none of the above yield a usable text string, there is no accessible name.
<figure> If the accessible name is still empty, then: if the figure element has a child that is a figcaption element, then use the subtree of the first such element.
If the accessible name is still empty, then: if the figure element has a title attribute, then use that attribute.
<img> Use alt attribute, even if its value is the empty string.
NOTE
An img with an alt attribute whose value is the empty string is mapped to the presentation role. It has no accessible name.
Otherwise, if there is no alt attribute use the title attribute.
<table> if the table element has a child that is a caption element, then use the subtree of the first such element.
if the table element has a title attribute, then use that attribute.
tr, td, th Use the title attribute.
<a> Use a element subtree.
Use the title attribute.
<area> Use area element's alt attribute.
Use the title attribute.
<iframe> Use the title attribute.
NOTE
The document referenced by the src of the iframe element gets its name from that document's title element, like any other document
Section and Grouping p, hr, pre, blockquote, ol, ul, li, dl, dt, dd, figure, figcaption, div, main and body, article, section, nav, aside, h1, h2, h3, h4, h5, h6, header, footer, address Use the title attribute.
Text-level Elements: abbr, b, bdi, bdo, br, cite, code, dfn, em, i, kbd, mark, q, rp, rt, ruby, s, samp, small, strong, sub and sup, time, u, var, wbr Use the title attribute.

If this step 3 seems a bit ad hoc, the underlying logic is ARIA's categorisation into roles (and therefore elements) that have

  • Name from Author, meaning that you as the content author use a <label> (or legend or caption or figcaption or alt= attribute, or similar as appropriate to the html element) to provide an explicit accessible name
  • Name from Content, meaning that the browser reads the text nodes of the element and uses that as that accessible name.
  • No name. After all, you don't want a name for every paragraph or span or div. That would be really unhelpful.

Note that multiple labels or multiple content sources are valid, and will be concatenated with spaces.

The 3 Cases of the 3rd Step of the Accessible Name Calculation:

If you learn

  • which html elements have name from content,
  • which rely on a label,
  • which should not be named

then you've got 95% of what you need. You can then choose the appropriate way to aria-name your element:

  • Naming with child content.
  • Naming form controls with the label element.
  • Naming fieldsets with the legend element.
  • Naming tables and figures with captions.
  • Naming with a string attribute via aria-label.
  • Naming by referencing content with aria-labelledby.

Overriding the default name and not using the fallback

Steps 1 and 2, using either an aria-label="This is my name" attribute, or an aria-labelledby="id-of-a-labelling-element-with-text-content" is the override mechanism.

The common fallback mechanism — which you can always avoid using— is the title attribute. Prefer using the explicit override rather than letting a title set your name.

Parting comments

  • See https://www.w3.org/WAI/ARIA/apg/practices/names-and-descriptions/ for an understanding of why you are naming things and how to do it well.

  • Returning to my original example, you can see that aria is opiniated. Many aria roles and naming rules are what you'd expect, but ARIA thinking is not identical to html thinking. The input elements get accessible names from their labels, but the form as a whole only gets an accessible name if you explicitly give it one, and it only gets the Aria role of form if it has an accessible name.

  • I have only discussed roles and names. ARIA also has descriptions and states and properties. For instance, you can use aria-busy=true on elements when they are loading or waiting to be populated with data.

  • See testing-library's intro example for more on using testing-library with vanilla html or major frameworks

Learning to do it well

A starting point for learning how to create good accessible sites is https://www.w3.org/WAI/ARIA/apg/