Interview with Jon Corbett

Article Information

  • Author(s): Mark Marino
  • Affiliation(s): University of Southern California
  • Publication Date: July 2021
  • Issue: 8
  • Citation: Mark Marino. “Interview with Jon Corbett.” Computational Culture 8 (July 2021).


Mark Marino interviews artist programmer Jon Corbett


Jon Corbett is an artist programmer of Métis (Cree+Saulteaux+English) heritage who has taken on the challenge of adapting and expressing elements of his cultural heritage and indigenous Cree language in computer code. Exploring what he and others have called “indigenous programming” practices (Corbett, Laiti, Lewis, and Temkin 2020),1 Corbett has been developing software in two particular tracks of interest: representing Métis cultural practices in code and creating a Cree programming language. Both branches of his work have allowed him to reflect on the potential for and limitations of encoding indigenous culture, from the point of view of the software artist member of that culture.

In one part of his exploration, he attempts to create implementations of indigenous cultural practice in computer source code. One such practice is the creation of beaded portraits. Modeling this practice, Corbett has created a program in Processing that beads portraits of four generations of his family, his first featured work was in an exhibition at the Smithsonian’s National Museum of the American Indian in New York City, and The Biennale d’art contemporain autochtone (BACA) / Contemporary Native Art Biennial in Montreal Quebec. Not only has Corbett attempted to create a software remediation of this cultural practice, but he has attempted to do so within the worldview of the Métis people, basing the algorithms on conceptualizations true to pre-colonial Indigenous epistemology.

When he was encoding the practice of beaded portraiture, Corbett found himself confronted with a key problem. He was implementing a cultural practice in a programming language that had been based on another culture’s knowledge paradigms. That realization awakened him to a second branch of research to develop a language built on Cree language and Métis culture. Corbett has been working on Cree# an Indigenous programming language to be used in a storytelling program, building it out of the Cree language and discourse conventions. In our interview, we discuss these projects and how Corbett’s version of Indigenous programming fits into his artistic work, his cultural identity, and more broadly in what Outi Laiti calls “ethnoprogramming.”2

I came across Corbett’s work when writing the book Critical Code Studies.3 Corbett led a discussion of these ideas and his work in the 2020 Critical Code Studies Working Group. In this interview, which I conducted after first discovering his work, we discuss the origins, development, and future prospects of Corbett’s work in this area of Indigenous programming.

Marino: Jon, your work is fascinating. How did you get involved in this? And what is the advantage of programming in a native tongue?

Corbett: I have a piece in the Smithsonian, a generative piece, that creates digitally beaded portraits of my heritage…. And I’m passing it on to my son, by having it bead each generation from my grandmother, to my father, myself, and then my son. I created a piece that beads a portrait in a sequence ensuring each bead is connected to the previous, once a portrait completes it begins to unbead and starts beading the next generation thereby symbolizing the transmission of knowledge and heritage from one generation to the next.

Figure 1. “nohkom” (2015), Computer-generated beaded still image of Jon Corbett’s grandmother.

Marino: How did you begin your programming work?

Corbett: I started programming basic on Apple and Commodore machines when I was 10 — first programming simple text based adventure games and eventually started incorporating images when I got to junior high school and progressing to C/C++ with a little Cobol, some assembly, and Oracle and Alpha DBs. I grew up teaching myself programming — and during my undergrad degree I got a job at UPS and that turned into a 26-year career. I would eventually be lead developer in UPS.

At the start of my career I started out in Visual Basic in the beginning, although I was working with Delphi [IDE] (around ’98-’99). UPS was slowly getting to doing things online.

In 2001, I built an online shipping portal using classic ASP with VB Script and JavaScript, that I now have migrated to mostly in C#. I leveraged jQuery and JavaScript, wrote a bunch of Java to get thermal labels printers to work, and serial based weigh scales. Due to the security problems in these older technologies especially classic ASP and Java, getting those to work in customer sites, which were not working is a challenge. So we (at UPS) went the Microsoft C# route primarily because UPS already has a group of developers in the U.S., and finding developers with C# skills is fairly easy. I also did ColdFusion for a while, but UPS is slowly phasing out ColdFusion.

Marino: How did you start on this project?

Corbett: It came out of my MFA. I was dealing with these issues of indigeneity that were suppressed in my family. My grandmother homogenized herself to the Canadian ideal. I was disappointed because there were all these explorations I could have done, like beading, if she had shared it. I wanted to tie in my fine art background. For my MFA I was hand-beading portraits of my kids. I was making a lot of decisions, what color bead to choose, where do I put it? I didn’t want to do so much thinking, so I wrote a program that made those decisions and beading patterns on my behalf. It also gave me the opportunity to visualize what the portrait looked like if complete. So I could run it again and again. Through each iteration a single bead could be one of 100 different colors from an underlying 10 × 10 grid. Some finished works looked better than others. I originally wrote the program to make my life easier, but my advisor saw the potential of this computational system as a work on its own.

It turned out that people were way more interested in the digital work. And the Smithsonian wrote to me out of nowhere. I thought it was a joke at first. While I was doing that process in Processing because it helped with visualization, I was also researching Indigenous methodologies and Indigenous artistic praxis and incorporating those practices that had been lost to the family. Now, I go to the Blue Quills University in St. Paul, AB, where I’m learning Cree. My grandmother spoke Cree but nobody knew what it was, because she wouldn’t tell anybody.

So I thought at the time I was writing the program (for my MFA), I have this physical process of beading where the thread does not break. It continues in a loop, not end to the end. So I rewrote the program to reflect the cultural practice to make sure that all the beads are connected to one another — a metaphor for connection. The logic of the computer is not a reflection of my physical experience and I felt it should be. Why shouldn’t the program also be reflective of the action? (This relates to the anecdote I told you about trying to write a program that represented my life and daily routines when I was kid, I always look at coding as a reflection of life and vice versa.)

The loop doesn’t start over at the beginning but does a serpentine if it’s at the end of the row. (You can download my MFA thesis from here).

But essentially I changed this:

for (int x = 1; x <= NumberOfRows; x++) {
    placeBeadAt(x, currentColumn);

Into this:

for (int x = 1; x <= NumberOfRows; x++) {
    switch (x % 2) {
        case 0:
            for (currentColumn = NumberOfColumns; currentColumn > 0; currentColumn--) {
                placeBeadAt(x, currentColumn);
            for (currentColumn = 1; currentColumn <= NumberOfColumns; currentColumn++) {
                placeBeadAt(x, currentColumn);

So odd rows go left to right, and even rows go right to left.

I was also looking at breaking up the colonial viewpoint of the squared off, square chunks (i.e. pixels), opting for using round beads elements, and eventually moving to a spiral output and not the grid layout. The Indigenous perspective doesn’t really utilize the grid system in the same way colonial-settler culture does, it’s not part of our (Indigenous peoples) perspectives, the structured and regimented borders of the image space don’t really reflect the organic interconnectedness of things.

When I decided to set the electronic beading on a spiral, that set up a different problem because of the unique perspective of Indigenous mathematics. Using the center point as the eye I had to figure out where to put the second bead and the third bead. How do you make a spiral that doesn’t use a radial calculation? In physical practice that decision is much more of a feeling or an aesthetical choice, I don’t use mathematical formulas to determine the next bead placement, it is based much more on a trajectory and proximity decision. So in code I do use an equation to get the path the pattern is following and then do a series of xy nudges until the previous bead’s location plus it’s radius isn’t touching the placement of the current bead. Each iteration gets a little shaky because the xy starting point of the second bead is never the same. When there’s 8000 beads on a screen, you don’t notice it — it isn’t until you get a hundred completed images you can compare side by side that you see how dramatically different each design is.

The only thing that would’ve made this better would be if I could write this in Cree – bringing my ancestral language into use. This is important to me because in Indigenous worldviews language IS our knowledge keeper, and so truly, writing the program in an Indigenous language makes the work a story, a cultural product, and a digital reflection of Indigenous being — not merely a set of computational instructions that makes pretty pictures.

In Indigenous research, there’s a number of challenges and part of that is access to intellectual property. For example Indigenous perspectives, like the Inuit, where they have well over 30 words for snow, each word carrying with it specific cultural knowledge about the snow, the weather, the temperature, the wind, etc.… it’s not just snow, it is connected to other things. Likewise, in Cree there are no adjectives, most Native American languages don’t have any adjectives, for example in Cree a dog is atim. If you want a puppy it’s acimosis. Putting the two nouns together atim (a dog), and osis which means “something that is small.” Because adjectives modify nouns, Native language typically assumes that it is “something or someone” that is being referred to.

If I was able to write my program in an Indigenous language it would tie in culture. I am creating an Indigenous project and I would like to do that with Indigenous tools. I have always believed you find the right programming language to do the job. Just to elaborate what I mean is I wouldn’t write my program in Brainf*** for example, any more than I would hire a plumber to fix my car — or use a flathead screwdriver to unscrew a Phillips screw. The job can be done, but if there is a better tool then use it, or make one that works better.

Nearly all North American languages are oral based. Creating an orthography and writing them down was out of necessity to better communicate with the European settlers. Indigenous perspectives have had a need to adopt Western systems of knowledge in order to engage with the Western way of doing things. This is very evident in mathematics, and the use of Arabic numerals and abstracted concepts inherent in numeric understandings. In many cases, Western numeracy doesn’t exist within the Indigenous language or understandings. Therefore, being able to encode what you are doing so the community has it and it is not available to just anyone is a huge challenge for Indigenous people. (Intellectual property)

Using the language rather than logic and constructs, programming from the perspective of the language and culture rather than what the machine requires limits what the functions are called, what the variables do and reinforces the language, extending it into a project of language revitalization. For example, the Okanagan or Tglingit languages only have a few hundred native speakers left, but if you could program with those languages, the younger generations would be able to hold on to this aspect of their culture and continue to use their language if they had a computing platform that understood their perspective.

My projects reflect the Canadian government’s support for preserving our First Nation languages.

I received a Joseph Armand Bombardier Scholarship from our Social Sciences and Humanities Research Council, it was a grant for 105K, and was based on the potential of my project to appeal to the younger generation, where they can practice their language and practice programming in their language. I see a huge gap in Indigenous knowledge and western understandings, this is partially related to the cultural upbringing, where the perspectives and worldviews are different and are kept separated. Indigenous youth today don’t necessarily understand (western) math or physics because these are western science or logic based practices that are typically learned outside of the Native communities.

Figure 2. The Ancestral Code Developer Environment (in syllabics). The text in the left window is a transcribed story that is “marked up” with “coding feathers” that link to the right window where the code is written that is executed at that point in the story.
Figure 3. Annotated Ancestral Code Developer Environment

Marino: So what are some of the formal features that are different?

Corbett: One of the first things I built in was the concept of ceremony. At Blue Quills, in the beginning of each class, we do a smudge, lighting sweet grass or sage (or another medicinal herb) which you “wash” over yourself. Using your hands, you draw the smoke trails over your head, eyes, ears, mouth, heart, and body. This is a cleansing ritual used to clear your mind, clear your eyes, open your ears, clear your voice to speak truthfully, open the heart to receive knowledge, and finally the body just to ensure your full spirit is properly prepared.

I do this in programming all the time, zeroing out variables, cleaning out an array, erasing the screen elements, etc.… so in my programming language the very first function you call is smudge as a function. The concept of what it does is a cultural practice, a digitally encoded version of that cultural practice of smudging. And it performs in a digital sense all of that same preparation – clears the mind (as in the arrays, variables, empties buffers, memory), the eyes (in this case any visual objects that might still be on screen), and spirit/body (which I internally visualize as a blank screen with a blinking cursor waiting for input).

Some of the other features I am working through is I want it to be more of a natural language processing language, like Inform 7, for storytelling. I was taking a carving class with an Haida elder who would tell stories as we carved. He related old stories passed down to him through Haida oral traditions showing us the proper method for carving while storytelling – providing valuable teachings about our knives, about the beings that provided us humans our ways of life, and how we in turn respect those teachings. This one story he told us, he got three-quarters of the way through, and said it would be easier to see it — and he brought up a carved paddle (featherboard) and it illustrated the story he was trying to say. I thought that was brilliant to have an artifact “be” the story. If I could take the story and type it into my computer as a program, that in turn produces a picture that represents that story — that is what I ultimately envision my project as.

There’s a lot of challenges with doing that.

You just want to tell the story, using the story as programmatic input, and have the computer understand that story and “retell” it with a visual output. A lot of the drawing components will probably need pre-defined libraries that already know how to render story characters or objects. So if you’re using the characters of Raven or Wolf, you can use the appropriate library, and allow the story to model the behaviours of those characters.

It is important from an Indigenous perspective. There is a growing concern in Native American communities of sacred stories being captured, interpreted, and shared with the greater world public by people who have not been granted the cultural permissions to do so. This computer programming project reinforces this protection, maintaining the importance of the story and image in the cultural that it originates, keeping the knowledge from the oral tradition connected to its digital representation, but because the story is actually code the computational visual output can be publicly shared, the story however remains concealed and protected. This ensures the sacred cultural components and knowledge don’t violate any cultural practices of the community, you can put the visual works on display without revealing the code (the story).

Marino: Is it based on a particular, existing language?

Corbett: Not really. Aside from structural frameworks like Inform 7, and instructional operations I utilize as a programmer that I believe are essential to the operation of the language, my new framework is unique. I’m going to write the first edition of it concurrently in Go and C#. It’s fast tracking me to where I need to be. Go seems like the fastest most efficient way to go there, though there might be a better way, it is what I have experience with.

Figure 4. The Ancestral Code Developer Environment (in Standard Roman Orthography). The text in the left window is a transcribed story that is “marked up” with “coding feathers” that link to the right window where the code is written that is executed at that point in the story.
Figure 5. The Ancestral Code Developer Environment (in syllabics), detail of the right side coding window. Line 1 is the smudge instruction, followed by the initialization of variable assignments used in the program.

I am looking to make it a suite of tools that should be transferable to any First Nations language. Cree is unique in that it has a syllabic orthography. So you could write it in SRO (Standard Romanization Orthography) but also in syllabics. I’ve created some keymaps for keyboards, am working on three custom mechanical keyboards based on Cree language learning models, and also developing a couple working fonts for the computing environment. I think the biggest hurdle is actually developing an Indigenous Computing Framework. Because I see big differences in the intent and function of western computing practices what I think are important to Indigenous computing explorations. For example time and efficiency: where western computing might favour concise, terse, coding paradigms like if(a=b){c} an Indigenous version of this would be much more verbose maybe something like c is what you get when a is the same b. It is more descriptive and does not use the question and comparative operator. That is rudimentary example, but the idea is that the computation is language-based and doesn’t rely on symbols like braces “()” or “{}” and computational symbols like “+” and “-“.

Marino: What about the low level?

Corbett: Binary is an inherent understanding in Indigenous worldviews. A large majority of Indigenous languages around the world exist in a binary of animacy (animate/inanimate). Though there is also a heavy unary understanding of the universe because everything is interconnected and therefore singular. We may separate animate and inanimate but I don’t believe they are mutually exclusive. The idea of everything being either one thing or another is incompatible, however, animacy is translatable as a Western binary, and I think a good way of looking at it for the purpose of programming. This is a unique perspective on the binary of the machine because understanding animacy in an Indigenous sense allows you to view code in an open “alive” form and closed “inanimate” form, I have adopted the glyphs of the pipe/vertical bar “|” and circle “” to represent the one and zero of binary respectively. Remembering that Western numeracy has its own glyphs 1 and 0, but the Indigenous relationship to shape primitives is stronger and I feel it is a good compromise because they are so visually similar it can be understood by anyone. I have this high level understanding established for the most part, but as I get to the mathematics, I know I will encounter challenges. For example, how do I handle decimals? Or how do I represent numbers that don’t exist? Take for instance 9. In Cree the concept of something that is 9 doesn’t really exist, we refer to it as “almost ten.” So though, in a modern context we would use the Arabic numeral 9, in Cree we do not really have an abstract representation for that other than it is almost 10. Some of the underlying processes are going to need a lot of thinking in order to best represent an Indigenous perspective AND be able to output a useful artifact.

Marino: What’s the response been so far?

Corbett: Incredible. I wrote a version as a poster at the ACM Programming 2018 conference in Nice, France, and presented it at the 2018 General Assembly of the American Indigenous Research Association in Montana, and the 6th International Conference on Language Documentation & Conservation (ICLDC) in Honolulu in February 2019. Among a number of others. What I have experienced is a lot of interest from a wide range of disciplines. I never thought of some of the possibilities that a Native American programming language would offer, nor did I fully realize the gaps that my work can fill in reconciling computer theory with Indigenous worldviews.

Marino: Does Cree offer anything that other languages do not?

Corbett: I was drawing on the concept of Ethnoprogrammming by Outi Laiti. What Cree offers is an opportunity to change programming perspectives. Using language and culture as considerations in the programming process, and not trying to accommodate an existing language because “that’s what the machine wants.” Outi’s work is aimed at how to teach Indigenous peoples programming if the current tools don’t support the language. For example, writing C++ in Chinese can be done because there are interfaces that can use Unicode characters, but support is limited for lesser used or obscure languages or languages that that have very few remaining knowledge keepers or native speakers left.

Figure 6. The Ancestral Code Developer Environment (in Standard Roman Orthography), detail of the right side coding window. Line 1 is the smudge instruction, followed by the initialization of variable assignments used in the program.
Figure 7. The Ancestral Code Developer Environment (in Standard Roman Orthography), detail of the right side coding window. Line 1 is the smudge instruction, followed by the initialization of variable assignments used in the program.

Marino: What does this language offer?

Corbett: For me especially, the logical thought process is different because of the way the language is constructed. It’s built upon itself. Being able to use and reuse language components to represent the same thing in different contexts is important. For example, in Cree, their exposure to a hippopotamus did not exist, so based on their experience, they just describe it. So they say “big tooth, big butt, thick skinned, pig that swims underwater.” But I could also represent a hippopotamus as a “big butt swimming pig with big teeth and thick skin.” In Cree — as long as all these components exist — then it is a hippo I am referring to and it is understood.

In a programmatic context — a simple for-next loop really has only one way to do it (unless I consider a do-until as an alternative). But my language has the flexibility to let them put those together in different ways and still have the ability to achieve the same result. Sure the start of the “if” loop and “end” need to be defined, but the inner contents can be in any order as long as the underlying story describes it as such — like say I wanted to write a loop to show a crow flying, and it is currently perched — logically I would first check if it was already in flight before starting the routine to make it fly. But in a story if I said ” the crow flew east, far far away, from where he was perched.” This might translate in code to:

{start} the crow is flying, move right, from stationary {end} 


{start} move right, from stationary, the crow is flying {end} 

This is a rudimentary mock up but I could rearrange the internal statements in any order and still retain the same operation I want to see happen on screen.

Similar to Hopper in COBOL and FLOW-MATIC, I share similar perspectives, that might seem a little naive, but I believe that you should be able to program in a language that can be understood by an “average” person and have that converted into code that can be understood by the machine.

Marino: But Inform 7 and other languages can be brittle…

Corbett: There are going to be certain structural formats that will need to be introduced to keep the language from being that brittle.

Ultimately a computer system is still in that logical construct — but I’d like to give a way for programmers to abstract out of that.

I really like the language Piet. People making Mondrian paintings out of Piet. You could rewrite it ten different ways and still get the same output. In that case you are not dealing with text but dealing with a graphical object.

I did look at the Shakespearean programming language as well.

For me, I’ve self-imposed the limitations for my own sanity. Love to develop it beyond the scope of what’s described. Probably extend it once it’s in place.

Marino: How would you imagine intervening at the level of hardware?

Figure 8. Model of Cree keyboard designed by Jon Corbett.

Corbett: There are a number of intersections I’d love to see happen, but of the ones I have control over, the input is a good example. The keyboard is one of those objects I don’t think we as users have realized is actually problematic. From an Indigenous (Cree) perspective, our syllabic orthography is often taught in a star chart format. There is symbology and sacred meanings attached to representing the language in this form. Based on a square with 8 directions (4 sides and 4 points) using the cardinal directions to represent the vowels and consonants follows Cree knowledge understandings, this can also be viewed in a Medicine Wheel structure – the formats are very similar. The syllabics have consonant based parents that depending on how they are oriented represent the vowels with the consonant parent. For example, ᑲ, ᑫ, ᑭ, ᑯ represent ka, ke, ki, ko. The virtual keyboards nowadays just map the primary symbols onto the keyboard in a vertical structure. So ka, ke, ki, ko would be applied to the keyboard as the characters “2”, “w”, “s”, “x” (second vertical column on the left). However, I developed a program to analyze a Cree dictionary and thousands of pages of text documents performing a monosyllabic and syllabic co-occurrence analysis. Comparing that result and applied those results to English equivalent keyboard mappings for Dvorak, Qwerty, and Colemak keyboard layouts. I am currently working on creating mechanical keyboards for each of these layouts. Because Cree language is so verbose, typing I feel, should minimize finger distance travel, and because most Cree language learners/users will not have developed mental keyboard maps for syllabics, switching or choosing their preferred layout should be easier to adopt. But, building a star-based keyboard is also on my planned construction list. The star chart is a sacred piece of Cree language development and though a physical keyboard in this star format might not be as ergonomic or efficient as a traditional horizontal keyboard, but the importance of the orientation to the culture is significant and therefore important to the users. That’s how I am navigating some of the hardware. Cree speakers familiar with the sounds and how they map together should be able to use any of the keyboards I have imagined and I hope my keyboard designs make life a little easier for syllabic entry when it comes to programming.

Another hardware intervention, I’d love to come up with another input device that would capture that. For example, have voice capture. It would need some post massaging, but it would then include a direct relationship between the oral presentation and the end of the work. Potentially you could have the same story told by multiple storytellers each using their own finesse, and the digital outputs would be similar but not the same.


Jon Corbett’s website is at


  1. Corbett, J. M. R., Laiti, O., Lewis, J. E., & Temkin, D. (2020, January 27). Week 2: Indigenous Programming (Main thread) (Online Forum). CCS Working Group 2020.
  2. Laiti, O. (2016). Ethnoprogramming: An indigenous approach to computer programming : a case study in Ohcejohka area comprehensive schools.
  3. Marino, M. C. (2020). Critical code studies. MIT Press.