Jon Corbett's languages Cree# and Ancestral Code allow programming in Cree keywords using Cree concepts and metaphors. In addition to this language, Corbett's PhD research has led to his Indigenous Coding Framework, a work-in-progress that will help other Indigenous communities bring to computation not only their languages but their cultural logic and values as well. Corbett describes the challenges of this work, from the danger of accidentally including colonial understandings in such a system, to working with technologies that assume programming languages have Roman-character keywords.

» First, for people who are not yet familiar with Cree#, can you describe the how you expect it to be used?

My desired output for this language is graphical based. I originally envisioned it as a kind of “Processing for Indigenous Languages”. Where the output is generative and graphic. The generative aspect is crucial in the representation of the Indigenous worldview, because when the program ends whatever display was generated is destroyed (comes to end of life). And subsequent running of the program – though they may produce similar results will never be graphically identical to any previous execution. This mimics the “real” world equivalent of listening to a story from a storyteller – who might change it slightly each time, so the same story is never the same twice.

Additionally, many Indigenous peoples use their arts and crafts as knowledge and story histories. So being able to create a graphic from story ties the language to a visual archive, and moves the creative process into a digital practice that has the same result.

» Is it entirely built around story-telling (both in the code itself and in its execution)?

Yes. The programmatic input is provided in story form using nehiyawewin syllabics. Which means existing stories can be used for input, though they may require some formatting adjustments, but the input is thought of as being story-based.

The output is also story-based, as it portrays a visual representation of what the story is in text form. However, the output is also dependant on the collection of visual data the programmer has. For example, I currently have a library of “raven” animations, so I can tell a story of “Raven”. But if told a story with “Bear” and “Raven”, it would only show “Raven” until I introduce at least one image to represent “Bear”. These visual collections are necessary at the moment, but I do hope to include modules with instructions for these kinds of characters that then become fully constructed by the program itself. (But that is a future vision idea and I’m not there yet).

» Can it be used for mundane computing tasks as well?

Probably, but depends on your definition of mundane… For example if I wanted to say render a functional calculator, then yes I think I could do that. But if I wanted to write a read-parse method/function for an XML document – then probably not.

» And how does the language function?

It was (and still is) in a radical flux status – I took my code line editor concept and started adding in some of the comments and suggestions from my prospectus presentation. I am now bringing in a bunch of visual coding ideas that won’t interrupt the “story stream”. But as a quick run through:

  • Starts with a “smudge” command to prep the program
    Displays a visual smoke stream to the user to simulate the smudge
  • Executes the code
    • Now the code is a whole story. Whether it is written by the programmer, or transcribed into the programming interface, this is the base from which the programing is applied.
      The interface I am currently building is combination of other interfaces, but has an almost cinematic editing structure, where the programmer adds or inserts “verbs” at relevant points and further applies “nouns” or parameters if needed.
    • Additionally, the command line coding interface can be brought up for these insertion points to provide direct coding if/when necessary.
    • Because code can run very quickly, there is a “speed/time” control that is ever present that the programmer can use to control when events trigger.
  • Here is a current list of the coding tokens I have thus far, just so you have an idea of what aspects are in the language itself:
    1. Keywords
      • miyâhkasike, tisamân, smudge – the smudge command
      • âcimowin, âtayôhkan – indicators for identifying/protecting story elements
      • mînisiwat, maskihkîwiwat – variable declarations
      • pipon, pipona, pipohki, awasipipon, mêsakwanipipon – winter(s) (loops)
      • tahtwâw – each time
      • awa, ôma – this and that
      • sîpiy – river (if)
      • kikway – what (if)
      • kîsipayiw – end/terminate
      • pîkiskwêw – say/talk (print/output text)
    2. Operators (verbs)
      • asiwahew – populate [as in a variable]
      • pîhciyihk – inside/contents
      • akihtam – count something
      • takwastâw – add
      • mistahi- (as a prefix morpheme) – makes something bigger, increase by 1
      • kâwôtinikêwin – subtract
      • –osis or –si (as suffix) – makes something smaller reduces something by 1
      • tâpiskôc – make something equal or same as something
      • -wa and -wak – suffixes that pluralize a noun (making it an array)
      • x – ends a statement (this is not a lowercase x it is a syllabic that looks like a lowercase x and is used as a full stop)
    3. Actors (common entities that are in stories and cannot be used as generic “noun” variable assignments)
      • wîsahkecâhk – (Raven, trickster, a legendary spirit)
      • maskwa – bear
      • cihcipistikwân– a legendary spirit
      • cahkâpes – a legendary spirit
      • wîhtikôw – windigo
      • môswa – moose
      • mahihkan – wolf
      • amisk – beaver
    4. Numbers
      • The actual words for each number are reserved (there are 104)
      • makikway – null/zero, literally “not something”
      • mihcecis; mihcet; mihcetinwa – fairly many; many; numerous
      • misi- - a prefix for describing a massive amount of something
      • akihtâson – literally means “a number”; used in conjunction with syllabic numerals to separate text syllabics from numbers such as:
        • newinwa napewak ([there are] four men)
        • ᐊᑭᐦᑖᓱᐣ lᐅ ᓇᐯᐘᐠ ([they] number 4 men)
        • This is changing in my new ui, where you can highlight/tag the numbers instead of specifying that the next “word” is a numeric value as in the (b) example above
      • In terms of using the non-numeric numbers like “mihcecis” I have it structured to use these as randoms for numbers 100 to 1K, 1K to 100K, and 100K to 1M. Because of the generative nature of the outputs I want to create, I wanted these representations to be arbitrary and not-controllable, thereby reflecting the aspects of nature we can’t control. I still feel the system needs a little of this autonomy and that the programmer cannot always have full control.

» Cree# (like Cree) is a morphemic language. Could you explain a bit about how word construction works?

Though I use Cree# (primarily for English speakers). There are actually 3 different iterations of the programming concepts I have been working on:

  1. Cree# is my language that includes Western punctuation and notation methods and mimics coding languages like C# and Java.
  2. Ancestral Code is my attempt to remove these notations and stick to a more “story-based” NPL-style language that I am more focused on developing now.
  3. And wisakecak (sounds kind of like “whiskeyjack” in English) is the Cree word for “Raven, the trickster” who is the “god” character of learning and knowledge in Cree mythology. This iteration of the language is a kind of hybrid of the two (I touch on it briefly in question 10).
  4. But these assignments aside, my Cree# version is where I invested a fair bit of time in just figuring out how to write a programming language, and all of the questions and answers here are from this perspective.

So in terms of construction – here is just a regular language example: the English word horse in Cree is “mistatim” which is a compound of “mista” and “atim” which translates literally to English as “make big” and “a dog” (based on context, if you were on a farm mistatim is unmistakably a horse, and at the pet store you might actually be talking about a large dog). But you can also add a diminutive to “atim” as in “atimosis” (dog made small), and then a combination of all three “mistatimosis” which (again based on context) is either a “small horse/ or a pony” or the “puppy of a large dog”. This kind of construction allows you to alter a word to make it change meaning, and is necessary because there are no adjectives or adverbs in Cree only nouns and verbs. So a “puppy” as a noun is a compound of the noun “dog” and a verb “to make small”.

At the moment I use these ideas in image scaling functions. Using “mista” as a prefix to a noun to indicate it is larger and a suffix “osis” or “is” to indicate that it is smaller. So for example using “Raven” (kahkakiw): to display the Raven in a larger size I use mistakahkakiw and to make it smaller it becomes kahkakis (the “is ending” version).

We can use another morphemic piece called a re-duplicate to apply a kind of “repeat until” or “loop”. This usually is a “ma” or “pa” or a repeat of the first syllable. For example the word “pimohte” is the word for “to walk/step”, “papimohte” is walking (but not continuous), and “papapimohte” is “keep walking all the time (i.e. continuously without break)”.

I also use the “kan/ihkan” suffix for variables, this suffix just indicates the noun is artificial. So one could write “kahkakiw kahkakiwihkan” which loosely translates as “Raven is an artificial Raven” or in more traditional equivalent notation:

var Raven = TheRavenCharacter


» How you represent variables, numbers, etc in Cree#?

  1. As above the kan/ihkan suffix is used to identify variables. Without a preceding word the variable is actually self-assigning because otherwise it is semantically redundant. So using just kahkakiwihkan with nothing preceding the noun of “kahkakiw” becomes the variable and is equivalent to saying:
    kahkakiwihkan = kahkakiw
    (the variable “artificial raven” is equal to the actual raven (library))

    Or for a more traditional anglicized code notation
    var RavenVariable = load(raven.library); 
  2. Numbers and Arithmetic operators are represented by Cree syllabics but are usually visually smaller. Though Cree Numeracy is no longer widely practiced and we have for the most part adopted Arabic Numerals there are still Cree speakers who know this numeric framework.
  3. The basic numeric syllabic chart (1 to 100) looks like this:


























































































    • Single numbers “ones” and “twos” are represented by vertical lines “l” or “sticks”
    • when you have three sticks they combine to the “ᐅ” character for 3
    • the combination of “ᐅᐊ” for 6 can also be read as “almost seven”
    • an interesting note. The written word for 9 in Cree is “kika-mitataht” which literally translates as “almost 10”, yet the Cree numeral is “ᐊll” or 7+2
    • Zero is an 8 pointed star and the “✷” glyph (Unicode 2737) or “✴” (Unicode 2734) are the closest symbols available in Unicode, but the actual star should have the points oriented vertical, horizontal, and at each 45 degree interval, not in the rectilinear fashion. The pinwheel 8 pointed star “✵” is the right idea, but shouldn’t be decorative in appearance.
    • Once I have the opportunity to go back to community, I will see if I can get feedback from users if any of the existing available 8 point glyphs “❂✸✷✵✴⁕” are going to work or if a new glyph will be needed and added to the syllabic orthographic library.
    • The mathematic symbols are also represented by syllabics, for example “” for Multiplication which is the syllabic “ka” but is often a leading syllabic in many Cree words.
    • Numerals in this context then, must be rendered in different color fonts and different sizes in the interface. I am now working on a separate font specifically for these so they become visually different from the rest of the code parts because these symbols also represent numbers as well as syllables; confusion in the code when using numbers at the moment is a challenge especially with parsing. So knowing that these symbols represent numerics and are different from the other code-text will help.
    • And an example of a simple calculation like 3*2 would be written:
      ᑖᓂᓯ ᐅᑲᐊ ᒭᐢᑕᐢ
      And not as:
      ᑖᓂᓯ ᐅᑲᐊ ᒭᐢᑕᐢ

» In addition to Cree# itself, you're designing an Indigenous Computing Framework; could you explain the needs it addresses? and communities you hope it will serve?

Modern computing frameworks (not just programming, but computing technologies in general) are often focused on efficiencies, logics, and choices that are typically not as valued in Indigenous cultures. Similarly, activities the computer does have evolved from notions of time and behaviors that don’t always reflect Indigenous concepts of “natural” orders. So an Indigenous computing framework puts into practice Indigenous concepts and knowledge. It may not necessarily change or alter the way the computer handles instructions, but it changes the philosophies used in construction and development of software and hardware such as my Cree programming language; and a syllabic keyboard that does not conform to the horizontal rowed keyboards that are ubiquitous to modern computing practices.

Additionally, this framework introduces axiological (i.e. ethical and spiritual) considerations into the computer’s systemic process, something that does not exist (as far as I know) in the traditional development of computing materials. There does exist some research on “spirituality AND technology” but nothing to my knowledge that treats technology as an integral component of a human’s spiritual being or existence. (Science fiction and cyborgism dabble in these kinds of things, but what I propose is kind of different? I think? lol)

So for example: A smudge is a small/personal ceremonial practice where a medicinal herb (usually sweetgrass or sage) is burnt. A person then passes their hands and/or objects to be “blessed” through the resulting smoke trails. In a normal smudge you use your hands to draw the smoke towards you – “anointing” your head, ears, eyes, mouth, heart, and body. And then, you “bless” anything else you wish to be “cleansed” of any negative energies such as food, tobacco, eye glasses, and apparently even your laptop. Essentially anything that is responsible for/or can affect your physical or mental well-being can (and many Elders say should) be smudged before use. I have heard from a number of Cree and Métis Elders now that they have physically smudged their laptop “to purify it” before Googling.

Using the Indigenous Computing Framework – digital representations of this can be encoded, even if just symbolic. But a functional example is the smudge routine I use to start an “acimo” (tell a story) the term I use that is like the term “sketch” used by other programming environments. This smudge routine in the Cree# language resets the screen canvas and prepares any system variables before the program actually starts its run.

Therefore, this kind of reformatting or rethinking of a computing framework becomes a cultural extension of meaning making from a user standpoint (assuming they are invested in an Indigenous cultural experience). It goes beyond relating the requirements of the system, but defines the relationships within the system as cultural practices that occur outside the system making it easier to relate to in terms of the human-computer relationship.

Obviously my primary target communities here are Cree communities that are looking for new (and exciting) ways to encourage students (especially in the K-12 grades) to use their heritage language as much as possible, and resist using English as their primary language. Well, when it comes to computing, if there are no resources in their heritage language they are forced to adopt Western practices and English in order to engage with computing and computer programming. In Canada there are close to 600K Métis people (who may or may not speak their heritage language), and another 100K people who are Cree language speakers, and of those there are about 180K who are school-aged. So there is a great opportunity to be able to provide computing education starting at a very young age, without needing to introduce too many logical (i.e. Western) constructs, and without needing to dilute their own cultural practices to accommodate Western theory in order to engage with computers.

Right now I work with people at the Blue Quills University in St. Paul Alberta, and Little Red River Cree Nation in High Level, Alberta and am targeting adult learners first, but my goal is to be able to introduce this programming language and framework to the primary and secondary school curriculum on a much larger scale

» In your talk, you mentioned the danger of accidentally including colonial understandings; could you talk a bit about that challenge and how you decide to include or exclude specific features in the language or framework?

There are a number of concepts that as a programmer I have come to just accept. Things like “data types, “variables”, “looping”, “conditionals”, and “linear/sequential instructions”. Simply translating these into Cree is not that simple because some of these concepts don’t necessarily exist. Take for example English as a collection of 26 letters that form an alphabet, and is often taught as “ABC’s”. We are taught to read and learn these letters in a left to right sequential fashion, and is very much an algorithmic methodology. But Cree is often taught in a very heuristic and organic way, and is difficult to describe in an “alphabetic ordering”, this system of organization won’t always work.

So Cree is more of a lateral/parallel thinking form of language (as opposed to serial/sequential per se), so creating a language that relies on a linear (ie line by line process) is one of those “accidentals”. In designing a programming language for Cree, my challenge is to figure out answers to:

  1. Is this process necessary? i.e. Must it exist in a linear system? Do I actually need “lines of code”?
  2. Can lines of code be grouped and collected and executed in any order and still produce similar results to a strictly linear process?
  3. The Cree Star Chart of syllabics is a 2D representation of the language, so can the new programming language also be represented in a 2D format? And how would that work? Is a visual object language better suited?
  4. Many [English] programming languages rely on extended symbols and punctuation like quotation marks, semi-colons, braces/brackets, etc.. to mark code for function – in Cree written language there is no punctuation except a period. So is introducing punctuation and symbols that are not part of the language acceptable for purposes of “programming” or is it a form of colonial homogenization?

Taking on other items like “variables” – if I try to describe it in an anglo perspective, it is an abstract item that can represent anything and change from one thing to another, there is no real equivalent in my understanding of Cree, except maybe a Rougarou, which is a Métis/Cree “shapeshifter”. So maybe I can call variables artificial “Rougarous”? But In terms of function, I might describe a variable as a container (like a basket), and that basket can be filled with anything, emptied, and refilled with something else. So declaring a variable I envision in two ways – either it is a changing object, or an object whose contents can be changed. Now which one makes more sense to a Cree language user? This is another step and I haven’t received any feedback on that yet.

For “data types”, these are separate definitions of entities like numbers or strings – again there is no differentiation in the Cree language for concepts like these. Categorization as a concept is a very fluid I’m still working on this concept, so right now all variables are not type-designated.

“Conditionals”, I currently adopted the idea of “river” from the Alelo “Hawaiian” C# coding group project, so instead of writing “if a = b then” you write “The river flows into smaller rivers when a =b, b=c, c=d, etc…” which is more of a “Select/Case” statement. But it carries with it a sense of the cultural understanding.

Finally, in my hardware design, my Cree Keyboard is based on the Cree Star Chart. In anglo-orientations, cartographic directions are almost situated so that N always points to the top of the page. But in the Cree Star Chart (as I recently discovered), N is the bottom [of the page]. So my PCB design has had to be altered (and I moved the microprocessor to the left side of the board which corresponds as E). This is a perfect example of my Western assumption that the directions are universal. The orientation of the microprocessor to the East is important because it represents the opening to the sun – and is based on knowledge sharing and transmission which is what the keyboard facilitates. So in other words, the Cree Star Chart situates E on the left side of the page not the right. So saying to someone using the keyboard to select the first syllabic character on the East-side of the keyboard, actually means the key that is closest to the center on the left side of the board (ie. reading from inside to outside, and on the left, because North is oriented facing down). These are concepts that are often overlooked and programming in the conventions of left-right, top to bottom, or W-E and N-S don’t fit with Cree epistemologies, and introducing these accidentally because of Western practices is a huge challenge that even I get caught in.

Jon Corbett's design for a keyboard built on the star chart

» In terms of working with a high-number Unicode character set, what technical challenges did you face working with existing technologies?

The first was just getting the interface to accept the required Unicode characters as allowable characters. I use Processing quite a bit as a way to visualize or prototype, and you can can’t use syllabics like “ᑳᐦᑳᑭᐤ” as code, but they are acceptable as strings even though the coding windows show as “☒” characters, unless you use the UTF hex codes. It was a learning curve for sure to get it so I could just cut and paste and save text in syllabics. Notepad++ comes in handy here when things go awry because it retains the syllabics and I can use it to “undo” symbols that get lost or corrupted when running and saving coded stories.

Of course I think one of the largest hurdles is I am not a fluent Cree speaker so language identification when I am in full Cree mode (i.e. All code AND errors are written back in the interface as syllabics), it can be (and often is) a very slow coding process. Even switching it to a Roman Orthography mode (Cree written in a phonetic English form) doesn’t help at times, and I am resisting the temptation to make these elements “English” readable. So a syntax error is one of the few errors I get that I know something happened. Other errors, that I haven’t translated yet, just get logged, but are rarely meaningful. Making sure sufficient error trapping and controls are in place and feedback to the user of problems is a huge undertaking that I think will be in development for a while.

» How did you end up working with both C# and Go for development, and was one easier to work with in terms of these issues?

I originally went with Go, solely based on the great tutorials and book that Thorsten Ball wrote. And I can write code in C# pretty quick, so being new to Go was (and still is) a huge learning curve, but being able to program the GUI and interface in C# helps with the feelings that things are moving along at a pace I am happy with. Since my PhD prospectus I have been thinking a lot about some of the comments and am now looking at making it a hybrid system that uses visual object controls (like Scratch or MaxMSP) in conjunction with textual editing. Because the code is still story-based, the story as code is integral, but I think adding in graphic objects that can be linked to the written story might be useful to speed things up. Especially when using the graphic libraries and animation sequences. Again, this is a new idea that might be worth investing the time now to integrate before I get further along in introducing more complex programming components.

The biggest hurdles I have are trying to visualize the language I want to make. And the limitations in Processing also carried over in to C#. Which is primarily problematic with just making sure the Unicode de/encoding classes in C# are accurate, this part was actually not that bad – but was tricky to flip my thinking back and forth between actually using the syllabic glyphs I want to use and the hex representation of them I need in the code. I think it is way easier in Go where I am actually able to define my “runes” as Unicode chars, so Unicode wasn’t really a problem per se in Go.

The next tricky area was converting/translating the instructions (the lexing/parsing process). I’m fairly new to programming language construction, and this part is/was the biggest challenge because of how am trying to keep the cultural aspects of the Cree language present even at that level. The morphemic construction I think is the hardest part. Where in “typical” or “classic” code syntax you can have fairly reliable and distinctive tokens, the challenge with Cree is the relationship of semantic and syntactic construction of morphemes that can be contradictory in an English equivalent but valid in Cree.

So in allowing a user to code with morphemes introduces a bit of a challenge with understanding how to break a particular word into its individual parts and then derive a programmatic meaning from them. And this is one aspect that I am trying to limit so that functionally it is easy to code with a simple understanding of these word forms – the trick is to make sure the allowed morpheme word combining translates to appropriate tokens and does not result in gibberish, so though it might be syntactically correct and can be executable without error, does it also remain semantically correct? I have yet to see.

Corbett's Ancestral Code IDE, annotated

» More of an observation, but I'm struck by how your work shows that all programming languages are multicoding: even languages designed to make computer operations clear do so through a metaphor -- you've stated that culture must be a part of that underlying system, that it is always culturally determined. Was this observation what led to you creating these systems initially?

I think this observation actually came about through my “doing” process. Though my original thoughts on using culture in coding came early on, I definitely viewed “culture” as a series of properties (i.e. static properties) of the coding language that I wanted to build, and not a series of characteristics (dynamic properties). The more I progressed in identifying Cree cultural concepts and theorizing their coded representations (and vice versa – identifying coding practices and concepts and attempting to relate them to Cree epistemologies and ontologies) the differences between existing coding paradigms and Cree cultural perspectives that I thought was going to be straight-forward, actually ended up revealing just how deep an individual’s cultural perspective is reflected in the code and the system (regardless of what coding language you use). That was when I started to see how the living and dynamic characteristics of culture can be represented as digital structures on which to build my programmatic language; and is also one of the reasons I needed to define an “Indigenous Computing Framework”. I needed to be able to describe the system in organic terms with respect to the cultural awareness of the programming platform, so things like language sensitivities, cultural practices, digital object behaviours, etc… could be presented with this kind of “meta-language” that carries the cultural metaphoric representations and relationships to the system and extended programmatic functions.

» Who in the larger community has been helpful to you in this work? You mentioned the group working on Alelo -- are there others whose scholarship have been influential (inside or outside of academia)?

With respect to its overall construction the Alelo team is definitely one – and perhaps the most helpful, just because they encountered a lot of the same issues I had with how to represent programmatic structures with cultural reflection. Quite a bit of what I have built (am still building) is built from a spiritualistic/philosophical point of view. As such, it is very difficult to describe some of the inner workings without explaining a bunch of “the why” that it sits on. One of my greatest sources of “inspiration” comes from Margaret Noori (in particular her poetic description of the computer in the opening poem/paragraph of her article “Praying through a Wired Window”). Other inspirations come from Indigenous academics that have just recently started these crossovers of Indigenous cultural into digital representations. So the late Ahasiw Maskegon-Iskwew’s 2005 essay “Drumbeats to Drumbytes” is one of those first written works that struck me as significant. And more recently, Jennifer Wemigwans’ “A Digital Bundle” (her book, not her thesis) – She does a good job of identifying some of those areas of online and digital cultures that affect Indigenous ways of life, especially with how the Indigenous voice can be represented in digital technologies (without being utterly consumed and lost in the digital wastelands of the machine or cloud that our lives so heavily rely on these days).

Besides those, both Outi Laiti’s and Beth LePansee’s work(s) with Indigenous game programming have also had a significant impact on the work I am involved with. Whether you are programming for a gaming community or for artistic/creative design, the underlying cultural perspectives must be described and exposed to the underlying system. So it is not the product or type of programming you do, but how you use the tools to do it. So, Outi is more focused on the Sami language and how to use it in programming, and Beth always seem to be more in tune with the program’s output, and how to decolonize the system so the resulting product changes the narrative of whatever it is that is being critiqued or (re)presented back to the user or audience.
Of course, I also cannot exclude the Elders and fluent language speakers that I engage with either. But their guidance is never in relation to the machine, but with respect to the community and cultural teachings, which in a weird way these conversations have found their way into the structures I am building – the teachings and language are so heavily intertwined to our being that they have no other choice but to also be woven into how we interface with our machines.

I lastly, in the past year, really enjoyed Ian Arawjo’s “To Write Code: The Cultural Fabrication of Programming Notation and Practice”, some of it is relevant to what I am working on and was actually a good way to define exactly what programming is. I’m also interested in his “Race as Cultural Algorithm, and Racecraft in HCI” article which I have not yet been able to track down (in other words the HCI Proceedings it is listed as being in weren’t available the last time I checked.)

» And as you work on the Indigenous Toolkit, is this lateral / parallel form of computation helpful to other Indigenous groups who are working in this space?

That, I am not sure about. I like to think it is? Part of the challenge in answering that question, is that even those people I talk to that are technologically savvy and are decently aware of cultural and/or cultural studies – can’t wrap their head around some of the philosophies that I am pursuing (yet!). But I do know that I have had “some” influence on STEM curriculum development for Indigenous youth – based on the 3 different Key Note speeches I gave last year. The teachers and educational organizations that have requested me to speak, approached me because they are struggling with the development of computing courses and programs for computer programming, aimed specifically at Indigenous youth. The best comment I heard after one of my talks was, “I can’t believe we’ve been approaching this all wrong” LMAO. The biggest hurdle I see for others (even other Indigenous groups) is just how entrenched we all are in Western culture, so putting aside what we/they already know within a Western context is so hard to do sometimes, we often feel we have no choice in the decisions a computer makes – and that assumption is something I am absolutely trying to change.

» In the CCSWG2020 thread, you mentioned the way larger numbers (sometimes over 100) are represented idiomatically and sometimes not given a specific value. Is this something which you could expand on a bit? As you develop Ancestral Code, do you see it perhaps handling numbers in this way? (as someone who has myself made a language with restricted numbering for very different reasons [Entropy], I'm curious about how you're handling this).

Numbers are a fun and fascinating topic for me. In Cree, the “max” written number is 1000 or lᑭᒋ (note the 1 or | character at the front), and 1001 starts the numbering over (lᑭᒋl). But a million, which is 1000 x 1000 becomes lᑭᒋᑭᒋ (here note the l only appears at the front of the number group this is because “ᑭᒋ” literally translates as “thousands”) so in this case it is literally read as one thousand thousands. So all the backend math is done by grouping or breaking the numbers down in these groups of a thousands. It is very similar to Roman Numerals, but there are a number of differences that make it complex to program for. For example, my current algorithm still has issues correctly calculating numbers in the 100K – 1M range. It’s weird and might be related to the fact that in my backend I am converting these 1000 groupings into int16s... Still haven’t needed numbers higher than 100 so I am not too concerned about that part right now. But I will be sure to let you know if/when I figure it out. ;)

Because my original idea for Ancestral Code was to be portable to other cultures, the numeral/symbol representation was an important component I wanted to make sure I could support if the target language and culture were limited in their numeracy, I didn’t want the system to be limiting in that respect. As a way to incorporate those “other numbers” I am working on a special font set that includes ideograms for symbolic or special numbers, such as a circle = 0 (not much of a change there I know, but the number itself is “makikway” which literally means “not something”), ⨁ or ⨂ = 4, ✋= 5, ⛭= 8, person = 20, 🦌 = 100. These are the “special” representations I know I want to include, and I will be basing the designs for 20 and 100 on Cree petroglyphs. So even though (5, llᐅ,✋) would all be acceptable and systemically valid for the number 5, the user has a choice, and depending on the context of the story might opt to use ✋ over llᐅ for example if they were referring to people specifically. It is intended to provide yet another connection to underlying culture, indicating that the number being referred to is special or culturally significant in some way, and not just a symbol that the system requires for computation.

Another extension of this are symbols for “many” and “a lot” which I currently have as meaning: “many” = any number between 101 to 1000, and “a lot” = any number between 1K and 1M. The ideograms I haven’t figured out yet, but I envision them being predefined “randoms” for those numeric ranges. And I am still/always looking for more ways to use and/or represent numbers with symbolic glyphs.

Finally, if you go back to that CCSG2020 thread, one of responses in that discussion was Jeremy’ (Douglass) comment about using emojis/emoticons for programming so ᐃ=🦆 would be valid. I really like that idea, and I think extending the number-symbols idea to culturally significant symbols in general is another avenue of cultural representation that I think would be a great to explore. So not limiting that discussion just to numbers but to the other programmatic language structures as well which I am looking at now and is one of the biggest changes I am trying to bring in to evolution of the Ancestral Code environment.

Corbett's programmatically-generated beadwork: Lucas, 2015 (left) and Nohkom (detail), 2015 (right)

» I'd love to hear your thoughts about representing Indigenous understandings in a lexical, top-level symbolism (having the programmer describe choice using a river instead of if/then) and having it embodied in the logic of the language. It is perhaps easier I would think with a more story-oriented language that isn't required to support mundane computer operation

Funny you mention that. That is kind of how I am leaning now. I am still very much working through it GUI-wise, but I am moving towards adding in more visual elements, and am experimenting now with a kind of timeline and mark-up model (I’ll send along a screen shot if I can make it look like how I want it). Essentially, the interface that contains the story exists on a timeline that the programmer then applies program objects at the points in the story they want to render to the stage. And, (you touch on this a bit in the next question) but the first statement being “smudge” is one of those lexical items. Another is “kikway awas” as a SelectCase/Switch which in Cree literally means “What else?”

» When we tell the computer to "smudge," is it an act of automating this symbolic action, or is it an action that now is part of the act of writing code: the programmer visualizing this activity as they begin the act of writing a program?

This is an intriguing question. From a personal perspective I actually do visualize the smudge in a physical sense, and I also imagine the computer understands the importance as it performs its own tasks in getting everything prepared. There was a great thesis written by Michael Travers back in late 80s (ooh, add this to my list of influences too LOL). His MSc Thesis “Agar: An Animal Construction Kit” and specifically his programming language called Agar (Agents as Gated Rules) both guided me in how to approach the construction of my own language based on Cree. At a very high level, Travers talks about animacy in computing systems and much of his philosophy is in understanding animal behaviors in order to digitally simulate them which is very similar to what I am doing. Only in my case I’m swapping animals for culture – so I’m kind of looking at an environment of computational culturology as opposed to the computational ethology.

I do believe there is a very symbolic interchange between the programmer and the computer, so every programmatic command is part of the storytelling but is also a conversation. I do envision my own programming in Ancestral Code as a conversation with the computer and in creating those symbolic actions there are a number of considerations I have taken – especially in my view of the four main attributes that I have encountered in most programming languages that I am familiar with: “data types, “variables”, “looping”, “conditionals” (as I mention in the last round of questions).

Data Types: Right now, I have two data types – that are loosely just described as nouns and verbs, and each has to have an indication of animate or inanimate. These are actually Western words and understandings, Cree never developed terms that describe words as noun/verb or male/female. But in English, noun and verb are acceptable terms and animate/inanimate is a binary that is equivalent to gender and is acceptable as well.

Variables: come in 2 types - “mînisiwat” which is a berry bag, and “maskihkîwiwat” which is a medicine bag. The difference between the two is in the symbolism attached to each. So if I am declaring a counter (i.e int x = 1) this would be a minisiwat, it is just a basic container for a mundane or everyday items (and can be animate or inanimate at the moment). But if I need to refer to something that contains sacred meaning or special cultural significance I would use “maskihkîwiwat”. Systemically there is really no difference, but in practice (at the moment) adding or marking a section of the story with maskihkîwiwat will not reveal any new imagery to the stage; I guess it kind of acts as a comment in the code, but there are times when aspects of a variable may need to be revealed so this can be overridden.

Loops: are “pipona” (pipona is the plural of pipon). Literally, translates as “winters”, there are also extensions or related looping lexical elements like “pipohki” = next winter; “awasipipon” = last winter; “mêsakwanipipon” = every winter (this is my version of a foreach loop). The significance of winter is an old personal identity word and refers to one’s age. So I am currently 49 winters old, for example. And the reason it is “winter” and not another season is because back in the days before “housing”, if you survived winter it signified your resilience and survival of the most extreme of elements the Earth Mother has, and is a highly respected personal accomplishment. This was a fun one to figure out for me. And when I heard the story of “winter” it just naturally felt like a loop.

Conditionals: so far I have a select case/switch called “kikway awa” or translated as “what else or what is this”, and other than that, I used the Alelo group’s concept of river (or “sîpiy” in Cree). So sîpiy is/was the start of an if statement block. I have a pseudocode-mock up in SRO that looks like this:

asiwahew iyinimin mînisiwat 
sîpiy kikway pîhciyihk mînisiwat
awa iyinimin
asiwahêw ayôskan mînisiwat
awa ayôskan
asiwahêw iyinimin mînisiwat
sîpiy kîsipayiw

It literally says:

put the blueberries in the berry bag
[start] a river, what is [in] this bag?
It is blueberries [so]
put a single raspberry in the berry bag
It is a raspberry [so]
put the blueberries in the berry bag
the river ends

This is one of those ideas that I don’t think I have come across the right Cree reference for, but I like the metaphor used in Hawaiian so I went with that for now. And I need a “return to the river” which is missing in my list of things I need to include, because right now I have no way to “break” out of the processing if the condition gets satisfied. Always a work in progress.

» Is the smudge visible in the final story that is produced?

For the “smudge” (“tisamân” or “miyâhkasike”) both commands are acceptable. There is actually an animation I have created for the opening of a “sketch”, where I used a perlin noise filter in Processing to create a rising smoke cloud, so there is a visual that the audience does get to see, and it is the last of the instructions from the smudge call. Right now it is a recorded animation that runs about 10 seconds and is constructed from about 300 transparent .png’s that I merged together in Adobe Premier to make an mp4. So it is just a static item for now. But I am hoping to write this as its own library so the “smoke” is generative and is different each time.

I have yet to come across a suitable closing though (i.e. to end a sketch). It would be nice to have a closing animation, but I am not aware of anything that I can visually simulate as a closing. The closing instruction I am using is “nipâw” which means to sleep; I originally used “awa nipiw” which means “this died” or “this came to an end” but in truth it is not the end of life for the story, so I “put it to sleep” instead. Once the code is created it becomes “living” and its existence means it lives on, but when not in use it is sleeping. This is also in line with linguistic ideas behind language extinction and revitalization, where languages that are dying due to non-use, are often described as “sleeping” and not extinct per se because as long as records of the language exist (in theory anyway) someone might be able to come along and revive it and bring it back in to use. (Much like Manx and Cornish in England).

» One issue you raised in your PhD presentation is the question of how to keep sacred cultural knowledge from going global. Could you expand on what is at stake and how you're thinking about this as you develop these languages?

My primary concern here is protecting sacred or protected Indigenous Knowledge that is primarily limited to community members. The topic of Indigenous Knowledge and Intellectual Property is a huge concern in academia today. The concern is that Western/European cultures (especially in today’s age) are very much about sharing information – think about open source coding for example… the intent is that it is usually free to use, modify, and (re)distribute. This all good and fine, but there is no responsibility attached to it – open source doesn’t say “you have a responsibility to ensure this code is not altered to do something bad”. As Westerners we are always hungry for information and knowledge, but the biggest issues that arise from our Western activities are those of appropriation, ownership, and commodification of almost everything – right down to water and air as purchasable resources. These human behaviours are generally frowned upon in most Indigenous communities, as these knowledges and resources technically do not belong to us and are not ours to give, sell, or profit from. They are given to us by the natural forces and being of the Earth, and especially knowledges that are land based are heavily guarded so they cannot be exploited. As a result, you will often come across knowledge keepers these days that talk about protocol, and most stories are shared in a reciprocity framework.

So storytelling is usually received in an honoured reciprocity, for example an Elder who is asked to share the “creation story” with a group (which is a fairly common story) is usually offered a gift of tobacco and/or sacred herbs and medicines first (this is “the protocol”). This is something that can’t happen in a recorded session, in a digital archive, or without the Elder present. The elder ALWAYS has a choice to share or not share – an archive does not have that option. Another issue is that Elders are usually specialists in certain knowledges, so even though they may share stories, sometimes they only have part of a full story, and you actually need another story from another storyteller to complete a story, in cases like this you are only getting a part of a story, which means you usually cannot pass on the story until you have the other piece. These are less common, but with digital archives, it becomes an easier task – which leads me to the last issue, that of “work”. From an Indigenous perspective, you need to “do work” which means being a part of the community, participating in ceremonies, and building yourself as representative of that community. Whereas Western cultures are heavily involved in the “me” and immediate personal satisfaction – and might just use Google and Wikipedia to satisfy certain quests for knowledge. In this case there is no work needed, you can be a lazy member of society and still benefit from all the knowledge that is available thanks to Google.

Now, that all said, when you have the privilege of listening to Elders tell stories they always remind you that there are aspects of the stories that are not told. These are protected and only passed on at their discretion. But in most cases there is not much that can’t be shared, but there are sacred stories that are delivered only in special cases, or at certain times (like in relation to world events – like COVID) but regardless of the story the audience is always expected to be respectful and only pass on those parts of the story that the teller identifies as being ok – in fact the teller will usually say something along the lines of “you now have the responsibility to pass on this [part of] story”. But with our Elder population diminishing, a lot of these sacred stories are probably going to disappear eventually, which means we need proper systems in place to archive this knowledge so the Elders in a community can have a record of these stories so they are not lost forever. And so I see this digital storytelling apparatus that I am building in to Ancestral Code as shouldering a lot of that responsibility – being able to capture even the most sacred of stories - in writing - but still retain and provide the controls over what is shared with the audience. As longs as someone can read the Indigenous language, then reading the code will obviously reveal the whole story, but from an output perspective, if the audience only sees an interpreted visual output they may not actually see the “sacred” aspects of a story as it was recorded. So this is a way of protecting those sensitive stories while at the same time archiving the whole story, and still allowing a larger community (i.e. globe) to be able to experience the story in some way (even if it is edited) and without fear of it revealing teachings and knowledges that are reserved for those with the experience and respect to (re)tell it to future generations.

» What have we not touched on that you want people to understand about your work?

Hmmmmm. Good question! What haven’t we touched on? I think, what I most frequently talk about often overlaps considerably with things that are not typically involved with programming: like belief systems and the axiological concerns of programming as an activity. This introduces a greater emphasis on the “value” that programming has, and not just its function. In an Indigenous context this “value” extends beyond the concept of “making the computer do something” to “making the computer an integrated member of the community” and personifying to an extent that it is imbued with all those traits that a community member has. I think it was in Travers’ thesis (that I mentioned earlier) that mentions our natural human inclination to refer to computers and our interfaces in a very human way – how often have you heard things like “my mouse is being finicky”, “my computer died”, or “my computer just decided to do {something} on its own”, and we can also put our computer “to sleep” or “hibernate”, and “wake it up”. Therefore, as humans, we have already established this human-computer relationship that is in some way viewed more as human-human. So in constructing my language(s) for the computer, I am very conscious about this dynamic.

The only other thing I’m not sure to what extent we have discussed is the wholism of programming. Though English uses wholism and holism synonymously, Indigenous perspectives often use wholism as a form of learning that interconnects all aspects of being, in Cree this includes the four spirits or bodies of being: mind, body, emotion, and spirit (wholism); and is not merely referring to the “whole” as being a sum of (physical) parts (holism). So when in constructing my language(s) and interfaces I am always trying to be mindful of these 4 things and ensuring that any cultural rules or protocol within each one of these segments is not negatively impacting on another. For example differentiating between “âcimowin” and “âtayôhkan” (regular story vs. sacred story). Furthermore, because Indigenous people view learning and storytelling as medicinal, the digital environments I create have to facilitate that understanding as coding is medicine (In a Western perspective, this is kind of like saying coding is therapeutic AND intrinsic to my identity and wellbeing). So I do anticipate coding in Ancestral Code to become a ceremony of types, that involves physical ceremony and practice that extends beyond just typing characters into the machine. There is a true symbiotic relationship that is going to grow from it and the “tool” that is the computer, is going to become a (an honoured) member of the family and/or community.

As a quick anecdote, the most recent word for a cell phone or digital device in Cree has become “owîcimosiw” (lover; or girl/boyfriend). Of course this has to be used in context, but if you say something like “What is Jane doing?”, and the answer is “She is with (or is talking to) her lover”, it means she is texting or is on her phone/device. This is because these devices have become so intimately tied to us that they are often viewed as being closer us than even our own family or loved ones. Though this is often used in a somewhat sardonic way, it none-the-less is being used a lot more frequently – so “when you leave home to go out – don’t forget to take your lover with you” is becoming more and more common.


Press / Social Media on this post: