SleepeR Step One

Sleeper is a new set of Features for allowing the node text that is gathered by a team to be compared with a reading list, a small set of data and provide possible ways for the team of students, researchers, and team to consider new avenues of idea generation and ideation. The idea is to allow your words as a team to;

EXPLORE, REVEAL and EXPERIMENT with the CORPUS (reading list)

The original version of this idea came out of my PhD and the rough draft can be read on Manifold followed by the funded application too on Manifold. The pilot funding has been provided by the Web Science Institute (WSI) to support creating the SleepeR proof of concept. I then have to look to apply for further funding when I report back on the pilot’s outcome to the WSI in the summer of 2023.

So, I have assembled a small team of interested and useful individuals, Lesia Tkacz, Ash Ravi and Maddie Dwyter, who are helping to make and test this proof of concept.

Our roles are;


Adam Procter: Project Lead, this means I am responsible for the project and leading the ideas and also working directly with students/staff in

Lesia Tkacz: Product Lead, Lesia brings prior experience of Natural Language Processing (NLP) and “old school” Artificial Intelligence (AI) to the project and able to translate the ideas I have into words that the technical team can muse on.

Technical Team

Ash Ravi : NLP Research Engineer, Chief builder of backend python stuff. Ash is making the Sleeper features in python for us to experiment with the Corpus.

Maddie Dwyer : Human Interface Designer, Maddie will be working with Adam to imagine and code some interface elements to bring the python terminal stuff to life inside itself via extending the views to include new SleepeR views and interface elements.

The project team are using our internal Slack and not our discord for now as we are all in this tool more often daily, but the broader discussion and output will be published and made open via on thus blogs, the report document and likely some things into discord alongside my Obsidian notes on Gitlab.

The code is also all being published openly on GNU AFFERO GENERAL PUBLIC LICENSE Version 3 as are Obsidian notes that I am taking randomly as the project progresses. This is all in a newGitlab Group.

Part 1

In the first week, Lesia helped to extract the selected texts we had gathered to support the games design and art TOY project into the first mini reading list as readable txt files, we could use this as our initial CORPUS. We also agreed some internal terms to help organise ourselves.

CORPUS = texts, journals, and books from the “reading list”

DOCUMENT = the selected text from the CORPUS

KEYWORDS = words extracted from the JSON file from each team’s microcosm nodes

EXTRACT= span of text in the document that contains the keywords

For our first CORPUS we brought in was these initial set of texts

  • Excerpt from Roland Barthes from Mythologies on Toys
  • Reay, E. (2022) ‘Immateriality and Immortality: Digital Toys in Videogames’, Playful Materialities
  • Giddings, Seth (2019) ‘Toying with the singularity: AI, automata and imagination in play with robots and virtual pets’, in Giovanna Mascheroni & Donell Holloway (eds) The Internet of Toys: practices, affordances and the political economy of children’s smart play. Palgrave Macmillan.
  • Heljakka, K. (2017) ‘Toy fandom, adulthood, and the ludic age: creative material culture as play’, Fandom, Second Edition: Identities and Communities in a Mediated World, edited by Jonathan Gray, Cornel Sandvoss and C. Lee Harrington, New York, USA: New York University Press, 2017, pp. 91-106.
  • Blasdel, A. (Nov. 2022), ‘They want toys to get their children in to Harvard’: have we been getting playthings all wrong?’, The Guardian,

Lesia then used an existing programme called AntConc to test some ideas on how we might take keywords and do a compare with the CORPUS. The overall suggestion was to start simple and start with TF-IDF (term frequency-inverse document frequency) to compare keywords from microcosms with the CORPUS.

Part 2

Next, I was set to gather some real keyword data. So, in the game’s studio, I explained the overall concept of to year 1 Games Design & Art students and the concept around how the new SleepeR feature would recommend readings from the CORPUS. Each student was then placed into their teams after the field trip to Legoland. Each team was to work collectively on idea gathering, and would use and its Collect view to gather thoughts. I ran three sessions in that one day.

These exercises using included;

Exercise 1: create single nodes with keywords, as many keywords they could each think of per team specifically on the Legoland field trip.

Exercise 2: write together in nodes thoughts and ideas on the 5 emotions chosen for the thematic under pinning of TOY. Sadness, Joy, Anger, Fear, Expectation, Surprise, Acceptance, Disgust

Exercise 3: use to think out loud and gather general ideas and visuals related to Toys, Craft and Textiles, one member of the team had to visit the library and bring back physical items.

While this was underway, Ash was making the concept as outlined already into a small Python programme. The programme would take the keywords (JSON) from exercise 1 in the studios within, and use the CORPUS to do a TF-IDF lookup and provide each team with the “top” DOCUMENT they should read.

Here are the results from each team with the 5 keywords inside their microcosms, the scoring that was applied to each word and which was the top document they should read.

`                scores`
`storytelling  0.415010`
`combining     0.415010`
`land          0.207505`
`inside        0.207505`
`message       0.207505`
`toy10.json`  scores`
`welcome    0.367053`
`dreamer    0.367053`
`audience   0.367053`
`player     0.296136`
`education  0.296136`
`'Reay Digital Toys.txt'`
welcome    0.311668`
themed     0.311668`
curiosity  0.311668`
whimsical  0.311668`
dreamer    0.311668`
'Reay Digital Toys.txt'`
`           scores`
`welcome  0.562550`
`system   0.376746`
`created  0.376746`
`color    0.281275`
`creepy   0.281275`
shopping     0.368065`
welcome      0.368065`
realworld    0.368065`
educational  0.296953`
holiday      0.296953`

`              scores`
`stimulation  0.369146`
`welcome      0.369146`
`dragon       0.297824`
`build        0.297824`
`lego         0.247221`
`              scores`
`lego        0.596953`
`shop        0.297119`
`creativity  0.198984`
`park        0.148560`
`rest        0.148560`

After the teams had all had their top DOCUMENTS returned, we did a small survey and of all students who responded they said most had not read any of the DOCUMENTS in the CORPUS and that all were now more likely to read the “top” DOCUMENT now.

Part 3

Next we discussed what make this more useful, and to perhaps provide a view into the CORPUS maybe taking the “top” DOCUMENT and providing detail such as an EXTRACT.

We also tested added to our CORPUS two more DOCUMENTS from the broader reading list. To see what impacts that may have on the data.

  • Rules of play: game design fundamentals
  • The art of game design: a book of lenses

We didn’t have a chance to return this data response to the students, but it may also be worth the idea of using the same data from against competing CORPUS sets to push and pull project ideas between, Game Theory/practice and other external concepts from 2 CORPUS banks.

Key takeaways and next steps

Even with the simple recommendation of one text for each team to focus on, students suggested there were more likely to read the provided material. Which proved that they didn’t read the material even though it had been provided well in advance of the project starting, and this simple action activated the readings.

  • Pull out paragraph data and present that alongside top

Decentralised Data with CouchDB

My life through a lens bq31L0jQAjU unsplash
Photo by “My Life Through A Lens” on Unsplash

This is another post related to using CouchDB and PouchDB.

TLDR: PouchDB stores data in your browsers localstorage on your machine, you can then share said data that with others via CouchDB which can run as an application on another machine on your local network. Each device then gets a copy of said data and the updating in realtime and sync is handled by the CouchDB app. If you go offline you have all the data, its all copied to your machine, if you delete the data, then sync will remove it from all other devices. The data is on your machine, local first and you have complete ownership of how that is shared to other devices.

This extends an earlier post on Why PouchDB and CouchDB

Most systems be that single player or multiplayer need a way to synchronise data between machines.

The default way to undertake this is to create a server as the middle layer.

This is a centralised approached.

The issue with this is the cloud is at the centre point.

Many open source software providers that have this multi device option will allow you to self host the server infrastructure so you can maintain control of your data however this requires a server and often is quite complex to set up and maintain.

Which isn’t very delightful at all, also said server could be attacked meaning you also need to now manage security.

This is why people often outsource this part to a third party sync service or cloud service and open source projects will often offer a paid hosted version of this component as a way to generate revenue.

So if I want freedom to control my data across multiple devices or with other people I either have to become a sysadmin or pay a hosting provider, also making sure who I do pay is not going to sell my data down the river at a later point.

None of the which sounds like a great solution to me at all.

This is why I was always looking for a way that you can have local data that could sync with other machines directly, decentralised.

Something like a mesh network or peer to peer (P2P). I also knew this would need to happen in real-time.

I looked briefly at blockchain, P2P technology and decentralised apps (dApps) all of which was rather complex, or at least appeared to be.

I recall thinking and discussing this at Moz Fest 2017 and you can see my initial exploration explained a little in the blog post about prototypes back in Nov 2017.

At that time I had landed on deepstream an open source alternative to Google Firebase which I thought was a winner.

deepstream had a hosted version called hub and you could run your own self hosted version if needs be.

I was wrong as deepstream hub suddenly stopped and it turned out the deepstream server appeared to behind the hub in feature set and ease of use I just couldn’t get it to work with my current code which had worked perfectly with hub.

A conversation about this was then had with Matthew Parker a Perl developer about what I needed to do and the experiments I had undertaken.

Looking at my blog discursive search we must have had this conversation mid 2018, I suspect the first chat was over Signal app and with various phone and mac migrations the history is not located.

I just recall Matthew coming back to me at some point after that conversation and saying have you looked at CouchDB. I hadnt.

So why is this so powerful and why aren’t more people using it.

I don’t know.

What makes this set up so simple is this.

I have a Vue app that stores data in the vue store and then passes this into PouchDB, PouchDB is a browser based localstorage implementation of CouchDB, so the data is stored on you machine first. You can quit and restart your browser and your data is maintained.

You can then set a remote CouchDB for this data to copy to. You can also use replication to have CouchDB replicate to another CouchDB for resilience.

This remote or remotes of CouchDB can be either on a server type machine or just running locally as an app, both would be network accessible.

So if you only want to work with a close group of individuals you would ensure you are all on the same network, this could also be private / local.

You would then setting your remote to the address of the machine running the CouchDB app which would allow you to sync you data together, this data is then copied to the localstorage of each machine via PouchDB. If you decided to delete data this delete is sync’d across all machines.

CouchDB also has really good conflict resolution and keep tracks of changes, although I initially thought this could be a form of version control, the way couchDB does versioning is not designed to keep an infinite history, however in the case of offline editing of the same data from differing devices, you can easily resolve which one is the truth or even keep both versions.

What I found rather fun was at a similar time I had started reading the Ink and Switch research site which discussed offline first work. They had ruled CouchDB out for collaboration and yet as I was reading it I was literally running CouchDB as a real-time collaborative editor.April and May 2019 YouTube Clips.

This implementation is simple. If you also encrypt the data between localstorage PouchDB and the remote CouchDB, then even if you decided to use servers with replication the key to unlocking the actual data is done by the your machine, even if someone was to snapshot the couchDB data at that time there would be no way of knowing what the data was.

Anonymous !important

Alora griffiths 6XUKomqujZM unsplash 1
Photo by Alora Griffiths on Unsplash

When you assign yourself a name in you are not creating a log in or are you identifying yourself this name purely establishes a local relationship between the device and your nodes. This is what enables you to add and edit your own node.

The relationship is a between a local storage pouchdb and your assigned name also stored in local storage. Then when you join or create a microcosm you can add nodes there with this relationship intake, you can also keep the device name between microcosms

All the data in your pouchdb is synchronised to a couchdb instance which is what enables other people to join the same microcosm and work together in real time in the same digital space. The data from each person is copied to everyones devices and the pouchdb/couchbd sync manages the changes. The data is currently not encypted but there is no way you can find out whos data belongs to who, unless you hack th couchdb and know the microcosm that was being used and the device name you provide was something identifiable.

Ok that’s a basic introduction to the technology, the name you provide is never exposed to anyone else in the interface. This is very different to popular spatial tools such as Miro and Mural.

Screenshot 2020 11 06 at 12 05 21
Meetings and workshops

As you can see the people involved are shown by active cursors and their names. This has two issues, the first is the screen is so busy with cursors moving it can be very distracting, and second you can also identify who is moving what and who contributed what

In a workshop or session in which you ask a group to continue to a single space, the issue of being identified reduces participation and increases anxiety in what they contribute

During the building of we have used a number of services to co-create together, the tools that identified contributions, OneNote, Google Docs, Slack impacted on both contribution volume and also in conversation with students they were very selective in their approach to contributing, they didn’t want to look silly or not as good as others.

Yet when we ran feedback sessions using an etherpad in which students could create unidentifiable names (although exposed in the UI), the volume of participation increased and students felt freer to contribute, of course they had fun with the names and would eventually identify themselves normally. An example of this in actual system of hierarchy is is the idea of the HIPPO (Highest paid persons opinion), this can end up leading the direction of the idea generation, whether intentional or just by the fact you know they are the ‘boss’.

Article incomplete…

Main take aways

  • Being anonymous increases engagement.
  • Being anonymous reduces anxiety.

‘Living on’

Peter secan kKXBw9Exn30 unsplash

unsplash-logoPeter Secan

As progresses, I keep seeing flashes of how it would help to organise, or be used in, my own thinking practices, and so I occasionally get frustrated with the speed at which I’m able to advance its capabilities. Still, I have to remind myself that I’m not running a research lab, and that I can only devote so much time to the project in the part-time allocation I have.

Whenever I discuss a concept or an approach to interacting with the data I know its possible and could be fun yet I cant program as fast as I want, I have never professed to be a coder and whenever asked I always advise I’m not a coder I’m a hacker.1

50% of computer programming is trial and error, the other 50% is copy and paste. – Pawan Sharma

Testing of version 0.0.X with students has been excellent, and the next phase of 0.X.X is all about incorporating the ideas generated and feedback received from that version. So the jump in the semantic versioning as a minor update is in part due to the need to rewrite the code from scratch.

In order to take advantage of the realisation that I could–and should–build with proper semantic HTML in mind, as well as all of the Vue.js learning I’d personally undertaken coupled with a number of excellent conversations with Toby, I felt that a complete re-write was very necessary. This has instantly started bearing a lot of good fruit, as can be seen in these progress videos:

I know that the sooner I can start using for my own thinking, the more the project will advance with regard to the core principles of delight, whimsy and serendipity.

Of course, the goal is to test this within the design studio thinking process as soon as possible, although the COVID-19 lockdown will negate that to some degree for a while!

Thinking about testing, I was reminded of Ken Kocienda’s book Creative Selection. He was an engineer at Apple who worked on creating Safari for macOS and the touch keyboard for what would become the iPhone (the ‘Purple’ project). It was a revolutionary piece of touch design that could, if gone awry, derail the whole project, as the Apple Newton’s hand recognition software had. When describing working on ‘Purple’, Kocienda mentioned the idea of ‘living on’: the day-to-day routine of using in-progress software as if it were a real product.2

So, as part of our new weekly chats, Toby and I have set aside some drivers to get us ‘living on’ as soon as possible, which I hope will eventually lead to more people testing the alpha release. Regarding how we’re “living on”, I’m trying to keep the list of drivers as short as possible, as the intent is to release often and iterate. We don’t want to fail quickly, but this is a human-centred design process and thus the more humans involved, the better.

Keep an eye on the main site for the latest alpha alpha build, and please do give any thoughts or feedback any thoughts via the discourse below.

Main take aways

  • ‘living on’ asap is going to key to pushing forward delightful design choices.
  • Note that trusting software is also important, this needs to be considered.
  • Will people put data into an alpha app (see point 2)

  1. I also really like the term tinkering

  2. Other technology organisations have tended to use the terrible term ‘dogfooding’ for this concept.

Emoji Reactions

Bernard hermant bSpqe48INMg unsplash

unsplash-logoBernard Hermant

✌️Who doesn’t love emoji ❤️?

These funky Unicode characters were all but unknown until the last decade but long before European embraced the Japanese Emoji. Many of us used a serious a keyboard characters to add emotion to our text messages this was my preferred smile was a semi colon followed the right parentheses 🙂 (which is now auto converted on most systems to the emoji icon) but many used the longer version to include a nose :-). Pictograms have a long history themselves and this blog post would be amiss if I didn’t include some of the work of Otl Aicher.

Otl Aicher was a german Graphic Designer and co-founder of the Ulm Design School. His work on designing the 1972 summer Olympic design language via pictograms for representation and signage has gone on the influence design across the world. These pictograms provide short hand visual representations of more complex information.1

Pictograms provide a shorthand and emojis add in the elements of emotion, play and delight. The history of emoji is embedded in digital technology

We now see emoji reactions being added to numerous platforms as a button to encourage the use of them as a response, some of this is in response to the Like button being initially universally annoying when someone posted of a tragic situation and you did know what to say all you could do to show support was to like the post. So gradually services like Facebook added more options.

In previous testing using etherpad we would use emoji to up vote ideas and comments on presentations.


Article incomplete…

Main take aways

  • ITEM 1
  • ITEM 2

  1. I talk more about Data Visualisation in a previous article

Why PouchDB and CouchDB?

Inside weather ej3UoXYMaRI unsplash

Inside Weather

Once I was alerted to the fact that CouchDB existed I was really pleased with how it would fit into the tech stack. Firstly it is Apache Licensed.

It is web tech focussed with a focus on local data and although you can run it on a server, they also have a desktop application which means you can run the whole set up with local connections only, this connects to design principles of data ownership.

A group of makers / designers can just “spin up” and instance of and there is no need for a centralised source of the data, it is stored on all machines with one of the devices managing sync. The data structure is JSON which is a great structure and also human readable, along with being able to almost mirror Vue data structures.

I installed CouchDB on a centOS box very easily, the other thing that was great was the document model over tables structure model for the data meaning that you can in fact build the schema as you go, this meant that my first few attempts at data structure wouldn’t cause headaches as this could also iterate over time.

PouchDB is a javascript implementation to connect to a CouchDB and the structure mirrors CouchDB. I was also able to quickly use the docs to get a Vue application talking to CouchDB.

The main issue for me was simply understanding where and how to import the library within Vue, there was a bit of time spent on Stack overflow and googling the ways to import libraries, I had some experience with this previously in my other Vue experiments but having also moved to use Vue cli via Vue ui this was much easier to do with the web interface to find and add to project.

I made a little video about the basic set up of my Vue projects at YouTube.

PouchDB is an open-source JavaScript database inspired by Apache CouchDB that is designed to run well within the browser.

PouchDB was created to help web developers build applications that work as well offline as they do online.

It enables applications to store data locally while offline, then synchronise it with CouchDB and compatible servers when the application is back online, keeping the user’s data in sync no matter where they next login.

Main take aways

    Keyboard shortcuts

    Juan gomez kt wA0GDFq8 unsplash

    unsplash-logoJuan Gomez

    I knew keyboard shortcuts would always be a really important feature for, I am a big fan of keyboard shortcuts, maybe that’s due to my macOS usage which always seemed to have a good focus on shortcuts and productivity, much more than Windows ever did. For me the main issue to consider with getting ideas out of your head and into any system is reducing cognitive loads.1.

    Let’s take the post it note as the often default starting point for a design thinking process and as it becomes clearer to me that is a co-creation2 tool, this mode of quick input followed by then arranging, its becomes more evident the starting mode of rapid entry will benefit from shortcuts the most.3

    Some steps of process – post its

    • Get the system out of the way, Great ideas really fly when in ‘flow’ state.
      Post it notes are a good example to follow.
    • The barrier to use is as low as possible.
      • Post its have an inbuilt character limit4
      • They start as a collection tool.
      • And then can become a spatial tool.

    Keyboard shortcuts would help address this process. However picking the right ones is not as easy as it seems.

    The process is never that linear when making something like I am just chipping away at little bits of core functionality and I initially saw the needful keyboard shortcuts to allow quick connection and connection delete mode.

    I was mainly thinking about the fact that after one connection was made this mode was turned off, so this would allow 2 handed control of the spatial view using the keyboard and mouse together to rapidly connect nodes and it would help me learn the necessary code for implementing keyboard shortcuts in Vue and Javascript. It was after this that the idea for quick creation would help with the cognitive load concerns I had when testing the initial input mode where students would open one node and just type only into this, the act of finishing and creating via buttons was way to slow and distracting.

    So a purely practical starting point, I decided a good rule of thumb would be to follow the path a person is already familiar with so this would be to use well known shortcuts. On macOS these use the Cmd key followed by a letter so for example Cmd + n would mean new and this is what all macOS apps follow as convention, however to create these and it turns out that the Cmd key is apparently not considered a modifier key or at least it seems now that it is the Meta key which maps to cmd (macOS) and the windows key (Windows). But as runs in a browser, I would need to disable any default behaviour of the shortcuts, this would be wrong, taking over these commands just because a person is at that specific URL would not be delightful.

    So I proceeded to map to the Ctrl Key, I thought initially that I would use the keys c and v although usually used for Copy and Paste I felt that it might map to faster human interactions,
    this worked well initially in terms of muscle memory, aka my hands where often use to these two commands. A bug then appearing at this stage where I would end up editing the previous data entry, it took me a while to realise what was causing this, I had set the editor text entry to get focus on opening so you could start typing straight away however now the keyboard shortcut was so fast that the editor “heard” the shortcut and started editing the previous entry as the new entry was not yet ready, clicking the button and typing was fine but the shortcut messed this up, so what I did was add a slight delay on the focus so the system was ready for input at the right time, it was a nice distraction and fun hack to deploy.

    Of course I went to test on Windows and stupidly realised that the default key for Windows is Ctrl and so on windows these shortcuts would be conflicting. I next decided to move to the Shift key, why I did this before option or alt I am not sure now. I also decided to stick to c and v and that people would grow accustomed to this and then added z and x as Create and Close, next to c and v as Connections and Delete Connections. Of course I hadn’t considered what would happen when you typed a Capital in the note editor panel, so we did a bit of testing with the rule to not use capitals, if you did use a capital the system would try to perform said shortcuts which would usually close the editor. I also tried a new approach as I wanted to have a universal approach with a modifier key and swapped to Ctrl + 1 /2/3/4 again not considering on Windows this switches tabs in a browser. I then moved to the Option or Alt key. Adding Option plus and minus to zoom in was rather satisfying as it helped resolved the boundaries issue where you could drag something off the edge and quickly added the infinite canvas function I wanted, small win which I hadn’t even considered, this involved a little SVG canvas research.

    I might revisit META + Enter to close the window however I would need to work out how to target windows with another shortcut and this would mean moving between OS would have different actions where as in fact sticking to a universal action Option + Return could make this more useful not only for the people using but also in explaining how to use

    Main take aways

    • Sometimes things you think are simple take time.
    • Keep up on the blog (more than you think) !
    • Try and keep notes on even small changes as recalling exact details was hard
    • Git versioning in gitlab can show progress (obviously) maybe something to visualise for PhD write up too.

    1. TO REVIEW: Kalyuga, S. (2015) Instructional guidance: A cognitive load perspective. Charlotte, NC: IAP Information Age Publishing. Available at: (Accessed: 25 December 2019).

    2. designers and developers will need to learn to co-create cooperatively. This is not the same as collaboration, where small or large teams work on a certain product or outcome. Cooperative work involves multiple individuals and groups working within a common environment or infrastructure, and helping support that network or infrastructure for mutual benefit, while working on different objectives or outcomes.

      Downes, S. (2019). A look at the future of open educational resources. International Journal of Open Educational Resources, Vol. (2).

    3. A new bucket mode joins the spatial mode as shown in version 0.0.27d, still to be tested and tweaked.

    4. Depending on your hand writing size

    Microcast – Thought Shrapnel

    Austin distel VCFxt2yT1eQ unsplash
    unsplash-logoAustin Distel

    This morning I was fortunate for Doug Belshaw to give me some time on his microcast thought shrapnel to discuss and talk about the latest iteration of and the practice based PhD it sits within. Please do take a listen and of course feedback welcome.

    Main take aways

    • Always good to explain what you are doing.
    • Want to do more podcasts talking about project in 2020
    • Found some more bugs