Sleeper is a new set of Features for nodenogg.in 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;

Leads

Adam Procter: Project Lead, this means I am responsible for the project and leading the ideas and also working directly with students/staff in nodenogg.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 nodenogg.in itself via extending the nodenogg.in 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, https://www.theguardian.com/lifeandstyle/2022/nov/24/have-toys-got-too-brainy-how-playthings-became-teaching-aids-young-children
  

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 nodenogg.in 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 nodenogg.in 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 nodenogg.in and its Collect view to gather thoughts. I ran three sessions in that one day.

These exercises using nodenogg.in 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 nodenogg.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 nodenogg.in 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 nodenogg.in, 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.

toy9.json
`                scores`
`storytelling  0.415010`
`combining     0.415010`
`land          0.207505`
`inside        0.207505`
`message       0.207505`
`'guardian_article_they_want_toys_to_get_their_children_into_harvard.txt'`

`toy10.json`  scores`
`welcome    0.367053`
`dreamer    0.367053`
`audience   0.367053`
`player     0.296136`
`education  0.296136`
`'Reay Digital Toys.txt'`

toy11.json`
             scores`
welcome    0.311668`
themed     0.311668`
curiosity  0.311668`
whimsical  0.311668`
dreamer    0.311668`
'Reay Digital Toys.txt'`

`toy12.json`
`           scores`
`welcome  0.562550`
`system   0.376746`
`created  0.376746`
`color    0.281275`
`creepy   0.281275`
`'giddings_Toying-with-the-Singularity.txt'`

toy13.json`
               scores`
shopping     0.368065`
welcome      0.368065`
realworld    0.368065`
educational  0.296953`
holiday      0.296953`
'guardian_article_they_want_toys_to_get_their_children_into_harvard.txt'`

toy15.json`
`              scores`
`stimulation  0.369146`
`welcome      0.369146`
`dragon       0.297824`
`build        0.297824`
`lego         0.247221`
`'giddings_Toying-with-the-Singularity.txt'`

`              scores`
`lego        0.596953`
`shop        0.297119`
`creativity  0.198984`
`park        0.148560`
`rest        0.148560`
`'guardian_article_they_want_toys_to_get_their_children_into_harvard.txt'`

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 nodenogg.in 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

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.

Photo by Bekky Bekks on Unsplash

Why are we seeing such a rise in spatial tools?

Article incomplete…

Main take aways

• ITEM 1
• ITEM 2

When you assign yourself a name in nodenogg.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.

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 nodenogg.in 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.

Peter Secan

As nodenogg.in 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 nodenogg.in 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.[footnote]I also really like the term tinkering[/footnote]

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

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:

• 0.1.0 YouTube
• 0.1.9 YouTube
• 0.1.10 YouTube

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.[footnote]Other technology organisations have tended to use the terrible term ‘dogfooding’ for this concept. [/footnote]

So, as part of our new weekly chats, Toby and I have set aside some drivers to get us ‘living on’ nodenogg.in 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' nodenogg.in 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)

Bernard 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.[footnote]I talk more about Data Visualisation in a previous article[/footnote]

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.

IMAGE

Article incomplete…

Main take aways

• ITEM 1
• ITEM 2

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 nodenogg.in 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

Edu Grande

Mini Browsers are everywhere. This 24ways article goes into much more detail on what they are and how to create them so I wont cover that ground.

Article incomplete

Main take aways

• Providing web app expriences that delight involves a lot.
• I think there is a need for an updated html boilerplate.

Juan Gomez

I knew keyboard shortcuts would always be a really important feature for nodenogg.in, 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.[footnote]TO REVIEW: Kalyuga, S. (2015) Instructional guidance: A cognitive load perspective. Charlotte, NC: IAP Information Age Publishing. Available at: search.ebscohost.com/login.asp… (Accessed: 25 December 2019).[/footnote].

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 nodenogg.in is a co-creation[footnote]

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.

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 limit[footnote]Depending on your hand writing size[/footnote]
• They start as a collection tool.
• And then can become a spatial tool.

The process is never that linear when making something like nodenogg.in 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 nodenogg.in 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.

keycode.info

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 nodenogg.in but also in explaining how to use nodenogg.in

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.

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 nodenogg.in 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

Kaleidico

There are plenty of tools that are designed for collaboration and remote work. However this is not the same as co-creation.

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).[www.ijoer.org/a-look-at...](https://www.ijoer.org/a-look-at-the-future-of-open-educational-resources/)

Main take aways

• Item1
• Item2

nodenogg.in allows you to create and edit notes and attachments with a group of designers / makers in a shared digital space, these notes and attachments can be placed visually in a spatial arrangement and connections draw between them to provide cluster and connected relevance to a problem or research theme you are trying to investigate.

nodenogg.in is not an online collaborative tool but is being designed to augment the physical design studio and should be used together allowing you to capture collectively the teams thought and research process. The tool is design to support co-creation of resources and thoughts using a design thinking approach. The main initial application is to support project based learning, within a design school enviroment.

All notes and attachments sync to all devices, so once the design session is completed all parties have local copies of the distributed data.

youtu.be/Y1k_F0g6j…

nodenogg.in was created with design education in mind. If you would like to get involved is using and even contributing visit https://discourse.adamprocter.co.uk to join the discussions and find out more.

Photo by Kelly Sikkema

I am fortunate to be a member of the Digital Education Working Group (DEWG) at the University of Southampton, although I wont go into too much detail, its worth sketching out the group a little, we are hoping to become a committee one day.

The group comprises of individuals from across the University in Academic, Research and Professional service roles who have a keen interest and background in technology and learning. I tend to be there to lean on the Humanities side and get us to think about the people using the technology and how we leverage and delight the people in our organisation to better deliver world class education. We as a group try (very hard) not to get sidelined by what technology we should use or deploy but consider the overarching aims of empowerment through technology and how to better support our staff and ultimately our students as they enter a constantly networked and digitally connected world, no matter their core discipline of study. So I tend to be talking about digital literacies and the pitfalls of navigating our information society.

We meet once a month and initially our work has been quiet reactionary, with thoughts and reflections on the roll out of services like Office 365 and one larger piece of work was providing recommendations to the University Education Committee on what they must be doing to meet the new web accessibility laws as they come into effect for public organisations within the UK.

However our main task has been to discuss and create a vision for Digital Education at the University of Southampton which would connect to and inform the Universities Education Strategy, we have debated a lot about the word digital as we think everything is digital and this type of thinking should just be inside the Education Strategy however that is something that may take a while to change. For now we need a vision and some factors around what makes a great educator at the University of Southampton.

So at the last meeting after an update on some of the accessibility work being carried out internally to make our Blackboard Inc. installation more inclusive we where tasked to use either post it notes or a Padlet in groups of 3 to revisit the vision and connected topic, our group was assigned the topic educator.

It dawned on me why use Padlet when we could use nodenogg.in instead, this would also test my theory around being able to “spin up” an instance easily and to instantly work on an idea in a group. I managed to persuade the group quickly to not use Padlet and test nodenogg.in. Within less than a minute we where all hooked up to a new instance, by following my simple guidance. We started working on co-creating some thoughts on the task at hand. The only blip was Microsoft Edge on a Dell XPS (with touch screen) seemed to have some issues creating or joining an instance, but quickly switching to Chrome seemed to resolve this. Also the Dell machine seemed to have issues with the double clicking to edit as well, which didn’t really matter for the task at hand but was odd. The other member of the group seemed to instantly understand how to use nodenogg.in and very little guidance was needed. I also later made a special direct link to this instance and shared it with the whole digital education working group. We shall see whether anyone else adds to or creates more connections remotely. One of the questions was why use that when we have a Padlet, my initial answer was because nodenogg.in is Free Open Source Software (FOSS), which quickly resolved the argument.

As an aside I noting afterwards Padlet’s privacy policy which we would be agreeing to just by using it. Here is a quick peak at some high level points it makes, some designed to improve the service but most ultimately connected to adverts. [footnote]

• track behaviour on Padlet
• show third-party ads
• we collect your IP address
• we may also obtain information, including personal information, from third-party sources

• collect device-specific information such as:
• device brand, version, and type
• operating system and version
• browser type and version
• screen size and resolution
• battery and signal strength
• show ads about Padlet outside of the Service (e.g. on LinkedIn)

[/footnote]

So by choosing nodenogg.in we kept all the data to ourselves and this was all stored locally on the laptops in the room, this got some approved nodding in the group and we didn’t inadvertently share any of our device details, IP address or provide data for 3rd party advertisers. A small win for nodenogg.in I would say.

Main take aways

• Being able to quick create a shared (private) digital space was as easy asa I hoped
• Shared digital space inclusive by design, you didnt need an account or must use 'twitter'
• Very little explanation was needed, can I / do I need to make thiz zero
• Edge browser needs checking
• Edit mode needs checking

Photo from Eaters Collective

I have recently found myself sharing again a link from Nov 2017 about some of the prototypes back then, so it become apparent I need to provide an update on the tech stack being used now within my project, without the need to dive into the code itself.

The stack is now Vue.js with Vuex connected to CouchDB via PouchDB. The resulting information is rendered in html using a number of components and standard SVG elements to create interactive views. The use of additional plug ins has been removed unless necessary, this helps keep the project inline with the GNU Licence.

The biggest change is to move to CouchDB and PouchDB this has replaced my previous use of deepstreamHub which initially looked like a great open source alternative to Google’s Firebase however the deepstreamHub which was a cloud instance of deepstream stopped working and hasn’t been updated in a long time. I made a number of attempts to run my own deepstream, which was one of the reasons for picking the platform, the open source server tech, but trying to get this running in the same way the hub version worked proved to be fruitless.

It become very apparent this was a major block in the project. I reached out to a developer friend of mine to see what else he could also locate out there, we chatted over the general project aims, realtime nature, the vue.js json style structure and had been useful within firebase, we also discussed the ownership of the data so he went off to think about what could provide the underpinning structure I wanted.

He came back with the suggestion of CouchDB and subsequently PouchDB which would also answer my need for local storage and offline capabilities. After making the changes to the project to use PouchDB and CouchDB I also was pointed towards an interesting article from ink and switch looking at the development of local first software and the concept of owning your data, in spite of the cloud, which chimed very much with my research [footnote]They have very recently released PUSHPIN which is a collaborative spatial interface tool.[/footnote] and although they seemed to rule out CouchDB, due to some concerns over conflict resolution and its ability to do realtime, I have not hit those kinds of issue and have realtime collaborative capabilities working.

A little gif showcasing nodenogg.in’s use of realtime collaboration.

Main take aways

David Pennington

This testing session was carried out with year 3 Games Design & Art. This test was using nodenogg.in version 0.0.24d (YouTube explainer). The students were presenting a series of potential game ideas to each other, some of them in teams. The format for each was a 12 minute presentation of their 3 game ideas with accompanying slidedeck. The other students used a nodenogg.in instance to comment as the presentation was happening and afterwards for a few brief moments. The one main question I posed to each team to outline that could be answered collectivly via nodenogg.in was what is there biggest struggle issue? For example choosing which game idea to go forward or another aspect that the “crowd” could help on. In reflection from this session I think a more focussed use of nodenogg.in on the question at the end could have worked better as I noticed that contributing live specifically with the spatial view only on show was much harder, the cognative load was high, to listen type and see spatially. This was in part to removing the list view, this again gives rise to the idea of a series of views that work better for different types of sessions for using nodenogg.in. Although some of the connections and such started to be draw as seen in this screenshot, even with the shortcuts, the crowd couldn’t think that fast.

Also I felt much more this time as I was involved in thiking and responding during this session as well I think I miss some of the issues students hit with nodenogg.in. In future I need to either be recording the session in a way that is useful for my own reflection or get another staff member to use the tool in a perscibed way with students while I just observe the use. We have a big session set for the end of January which I need to prepare the use case / cases so I can gain the most useful feedback from this as much as possible. This will likely include blocking in some time to get students to write feedback into discourse. May need to use Microsoft Forms as discourse is public and students need to join to complete, which is a barrier for sure

This testing has shown that the spatial view is a slower thinking space, which needs to be coupled with a quicker throw thoughts into a bin exercise.

For this work we first need a bucket collect mode. Then we move into a spatial view where these are first neatly arranged[footnote]Some type of initial auto placement. based on entry time perhaps?[/footnote] and then facilitate a spatial process on the ideas, discarding some, clustering some, connecting some and making new informed and more details inputs into the spatial view.

The spatial view does needs to trim up the text, but there has to still be the ability to glance at the information and arrange as having to keep opening a reader view may be too slow even in the spatial mode.

For now I’ll call these two actions modes, Bucket mode and Consideration mode.

Main take aways

• Bucket mode to be turned on.
• Reader view needs some work.
• Gathering more feedback in sessions is really important.

I was keen to eliminate the need for any type of log in, as storing usernames and passwords would be problematic, this is due in part to one of the privacy design principles for nodenogg.in in that the system must only store data it needs to know and then any said data should be encrypted and decrypted to the owner of that contribution. Also this would require the process of signing up, which would drastically slow down the ability to just point a group of designers/makers to a URL and start working together, this would also rub up against one of the other principles of delightful design, signing up and saving passwords even with 1Password is not really delightful.

nodenogg.in does however need a way to identify contributions and so it uses the value attached to the device name (client id), this is decided by the contributor when they arrive at the initial URL for the first time, this is then used as the name of each document[footnote]CouchDB’s data structure uses documents instead of tables and is formatted as Javascript Object Notation (JSON) which also easily matches vue.js’s data structure.[/footnote]. When you decide on a device name this creates the new document which is the data structure for contributions. Clustering contributions into documents to a device enables differences in read / write access to said data and enables the contributor to easily remove, export and single out their own contributions. Other data such as positions and connections are stored as separate documents to simplify the way to create and manage shared views.

I had specifically been looking at the process that was used within micro.blog and I had used to some degree before back in my PHP coding days, that of using a URL with a token appended, this URL is then emailed to you example.com. This would negate the need to store usernames or passwords but would require a way to email said URLs from the server, which I was not keen on, although Sendy[footnote]Sendy is a self hosted email newsletter application that lets you send emails via Amazon Simple Email Service (SES).[/footnote] could have possibly done this and has many options to not track, however this felt overly complicated for what I required.

During some of this researching I was reading around using Javascript Object Notation (JSON) Web Tokens (JWT), which led me to web storage. I soon realised that I could use web storage to store the device name within localStorage [footnote]localStorage is a persistent storage kept in browsers until the user chooses to remove it[/footnote] so that after the initial ‘log in’ vue.js could check on any arrival if this storage was in place and redirect the visitor straight to making contributions on said instance, thus “logging” them in.

When you first visit the URL you are requested to input a “device name” this is then stored on your browsers local storage and enables you to “log in” without the need for a username and password. When you next load the page this token is looked for and if found connects you to the correct document store. Deleting the local storage would require that you enter a device name again, however specifying the same device name would basically connect you to the same document store.

Photo by Thomas Galler

I plan to post more updates to researchnot.es going forward with some more details on the project milestones as we ramp towards the end game, the schedule and thoughts. Although I highly recommend following my micro.blog discursive and specifically the PhD category, you could use NetNewsWire to do this as I document ongoing thoughts and things related to this project in much more casual and regular basis. Here the posts will be milestone documentation. The Official research documents will be on manifold.soton.ac.uk. All feedback welcome at discourse, each post here will have a specific option to pull in comments as well. Also I started using MarsEdit to post to the blog so that should make things much easier.

After using nodenogg.in with the final year students a number of times with a reasonable success. I realised that the session I had planned with our first year students was a week before their very first presentations and that it could be another way to test my hypotheses from the very first test that nodenogg.in could be used to calm the nerves of students as deadlines approach. By making the students anonymously come to the realisation that everyone felt very similar and had the same types of concerns. For this session I also removed the list view from within nodenogg.in and presented just the spatial view on its own, and removed the ability to see device names increasing the level of anonymous interactions.

We posed a question to respond to inside nodenogg.in. What are you worried or concerned about for Friday’s Presentation? As the students started to add comments you could feel the tension lowering in the room as it dawned on them that they all had similar issues, the fact it was anonymous was also again popular. One student also without prompting started to organise and cluster the nodes together spatially as similar thoughts appeared, this may have been prompted by me suggesting this, I am not sure, however interestingly as one student had taken the lead on this task and others didn’t mess around with this student being the designated organiser, although we didn’t know who it was until I was walking around the room looking at students use the platform. I tried to elicit feedback afterwards on discourse but that didn’t work! I will allow time for this feedback to be gathered in the future.

Again I had my mac plugged into the main screen projecting the activity in nodenogg.in, which reminded me of a view mode toggle that would be good as a present mode.

Main take aways

• Clearly working to help support end of project concerns, realising your not the only one.
• I was able to help by talking about the collective concerns.
• Could you have an option lock down spatial arranging to one person.
• The concept of big screen viewing mode would help.
• Reflective use prior to deadline.
• Allocate time for discourse feedback (make students do it).

This test was where I introduced the spatial mode and the list mode together for the first time. Students also started to use the different types of nodes including the link node and attachment node. However viewing the attachments and linking out was not possible.

Students started automatically moving around the objects in the spatial view, which was good to see, this seemed to be more on ability to view them rather then to order them to start, I also think the number of students contributing dropped. I think the main reasons that links and attachments where added this time versus the last was there was a view of the types now, in the spatial view but also I specifically asked for students to think of links and attachments and pointed out how to edit the Create type and that they could use Add to add(upload) files and images from there own devices.

Main take aways

• Need quicker way to detect and add links
• Attachments could do with drag and drop
• If link pasted in is to image it should somehow upload as an attachment

Even with the simplest additions to nodenogg.in testing with people is crucial, I know this is obvious but with a tool that has multiuser capabilities testing on your own is impossible, which means you cant fall to often into the trap of assuming things will be used in a specific way. After the previous testing I wanted to get the ability to make connections up and running as fast as possible in nodenogg.in. So I focused on adding this ability. I then added a number of buttons and keyboard shortcuts to also speed up the process of moving in-between interactions, create, finish, connect and zooming. I took the updated version to a team of 4 to see how create nodes and create connections I could see that they did some unexpected things. Firstly I had mapped the controls to CTRL but these conflicted with the browsers default, I had been using macOS, 3 of them had Windows. So I quickly changed that to Shift, which of course introduced an issue with Capital letters triggering the shortcut by mistake, also CMD is not considered a modifier key so I couldn’t have macOS style shortcuts. I am not sure on the best way to solve this yet.

Once I had the shortcuts working what I was not expecting was when a person went into connection mode they might then start dragging nodes around again, I was expecting them to be just interested in connecting nodes. This was easily fixed by turning off connection mode if someone started dragging icons.

Main take aways

• Popping into the studio to quickly test a small function is very useful
• Providing specific tasks can help direct testing
• Need to do more ad-hoc testing

The next test of nodenogg.in was with the returning Year 3 Games Design & Art students we had a slighly updated version of nodenogg.in however I disabled the spatial view as this had connection and arrangement issues and so I just displayed the shared text list view. In this first test of the new academic year I replaced my previous use of an etherpad with nodenogg.in which is also why I was happy with testing just the list text view.

Students where presenting three themes they had been researching in a 8minute presentation while all the other students where encouraged to connect to nodenogg.in and respond live with text commentary to the presentation. Students had to select one theme to take forward and deep dive into. So other students were also encouraged to vote.

Students appreciated this approach as they tried to help each other with ideas to follow up the theme and which theme to select. We could have just as easily used etherpad or word online, but these don’t offer the simple anonymous approach and wouldn’t test nodenogg.in to see what works and what was still causing usability issues. In this version after each presentation I had to copy and paste the responses into a text document as the system only had the capability to connect to a hardcoded instance.

Main take aways

• unlike etherpad students couldn't all write together as list view showed each student as a block
• students didn't like to create more that one thing they just typed
• no styling or use of line breaks which was not good
• there was not easy was to vote against current text again due list view being blocks
• spatial view and connections may resolve the above

After reviewing some of my explanation videos I realised that I needed to keep a more accurate record of what where the updates to nodenogg.in and when they actually occurred. This would help mr to use the clips as reference material to any testing that takes place, so I can see which version was used within testing but also it would enable me ton look back at the project and review and record why changes had been made. My previous Youtube Video’s had been a little haphazard in this regard and I needed a more logical system.

I was listening to Accidental tech podcast and they mentioned the semantic versioning system to better describe updates, so I applied this to my versioning system. I also found some of the built in features within Open Broadcast Studio to stamp on screen the date and time. I am still using the same process to stream the recording live to Twitch and afterwards download the video to be upload to my YouTube channel, there is a seven day window to download from Twitch, which I do need to be aware of. Brent Simmons developer of NetNewsWire whose contribution notes I have taken great inspiration from also mentioned adding a letter to the build to signify its state of play as well, so all versions currently end with the letter d for development. For now the alpha build however is also a mirror of the dev build.

These small changes I hope will help provide a usable level of the documentation of the thoughts and ideas from each version and I expect the explainer videos to get shorter as I just cover updates and why those choices have been made.

URLs

• development is at [dev.nodenogg.in](https://dev.nodenogg.in)
• alpha is at [alpha.nodenogg.in](https://alpha.nodenogg.in)
• beta is at [beta.nodenogg.in](https://beta.nodenogg.in)
• release will be at [nodenogg.in](https://nodenogg.in)

Main take aways

• Need to automate build process to each URL asap
• Need to work on safe guarding data in beta and alpha
• Being organised is important !
• Need to be consistent (as much as possible)

Science in HD

In June nodenogg.in was first tested within a design studio setting specifically with a group of final year BA (Hons) Games Design & Art students. The basic parts of the system where in place with the realtime sync between Vuex, PouchDB and CouchDB working as I had planned.

The main workflow is to enter an instance, there was a pre-made instance[footnote]instance is the term used to denote independence, so groups can work on their own instance of data within nodenogg.in[/footnote] for this testing session. To join and contribute to this instance the students had to specify a device name, this can be any name you like, students used this as a chance to create fun names and to some degree instantly make their contributions anonymous.

In previous work using Etherpad[footnote]Etherpad is an open source, web-based collaborative real-time editor, allowing authors to simultaneously edit a text document, and see all of the participants' edits in real-time, with the ability to display each author’s text in their own color.[/footnote]to do a simular process, I had found students really liked the ability to contribute with pseudo-names, they felt freer to comment and less conscious on being ‘judged’ on their contributions.

So students visited the alpha URL, typed in a “device name” and where asked to basically comment on concerns they had around there the final week. At this stage the only view of the realtime data was a single column text view updating as people typed. Most students didn’t create new notes for each idea they created longer notes and made there own bullet lists or spacing, which was interesting to see, there was no formatting options avalible to them either.

I had my Macbook plugged into the presentation screen as well. Students looked at there device for typing and tended to refer to my screen to see all the data appearing live. This suggests a present view could be really useful.

As students saw people typing up concerns the pace of contributions speed up as everyone become more confident, there was also moments of realisation as students released everyone in the room, teams or not had the same types of concerns and the feedback was this made them feel much more confident heading towards hand in and less “bad” about where they where at with the project. I was able to unpack some of the comments with the group aswell.

Main takeaways

• Realtime was appreciated
• Big Screen view mode could be added
• Anonymous input
• Supported cohort concerns (made students feel better)

This document is also on my Manifold instance here

Research Problem

Despite the widespread application of digital technologies in higher education there is scant evidence to suggest that these have had a significant impact on student learning. (Bainbridge, 2014, p1)

These technologies often have sharing features added as a ‘bolt-on’ to core functionality, rather than being built for project-based learning. They are designed to be separate from, rather than integrated within, learning spaces.

Sharing is probably the most basic characteristic of education: education is sharing knowledge, insights and information with others, upon which new knowledge, skills, ideas and understanding can be built. (Open Education Consortium, [www.oeconsortium.org/about-oec...](https://www.oeconsortium.org/about-oec/))

Design education is, in particular, a very visual field with a requirement for spatial manipulation. Current learning technologies on offer do not augment the physical studio experience, and push educators and students towards commercial, more generic offerings without a pedagogical underpinning.

Students are used to a more ‘delightful’ experience with this kind of software, as evidenced by the quotations below:

Slack is useful for quick & easy non-distractive communication. It is simple to navigate and provides a direct platform in which to contact peers and lecturers, creating channels and direct messaging groups is ideal for a more tactile approach to a discussion. (link)

Onenote is great as everyone can have their own section to put their own information/images on it when working together.

Etherpad definitely proved helpful as everyone put down questions, films, books and other information that has now given me more starting points to research.

Research Proposition

There is a dichotomy between tools that are personally owned and single-user by default, and Learning Management Systems provided by educational institutions. The latter offer top-down static file repository functionality and fixed courses, rather than features that support project-based learning.

As a result, this research will begin by examining the fundamental concepts of spatial design, including mind-mapping and concept mapping. It will consider the influence of the design paradigms provided by Xerox’s PARC institute and investigate the legacy of Human-Computer Interaction (HCI) pioneers such as JCR Linklider, Ivan Sutherland, Ted Nelson, Douglas Englebert, Seymour Papert and Alan Kay.

Some information must be presented simultaneously to all the men, preferably on a common grid, to coordinate their actions.” (Licklider, 1960, p9)

A spatial interface allows users to take advantage of their visual memory and pattern recognition.” (Shippman F M, Marshall C, 1999)

Research Question

Scope

The entire project process will be captured as it progresses in an open and free software approach and documented at the locations below. The systematic packaging of this process and the application of Design thinking and human centered design will also reveal tool building processes and culminate in a manifesto to design these types of new design led digital tools for enhancing project-based design education.

Current output locations

• BLOG https://researchnot.es
• CODE https://gitlab.adamprocter.co.uk/adamprocter/nodenoggin
• Microcast https://fragmentum.adamprocter.co.uk
• DISCUSSIONS - https://discourse.adamprocter.co.uk
• FORMAL WRITINGS - https://manifold.soton.ac.uk
• FOLLOW - https://discursive.adamprocter.co.uk

Schedule

• Feb - April - BuildingMVP
• April - May - TESTING with Year 2/3
• May - June - ITERATE
• June - Sept - REFINE
• Sept - Oct - Testing with Year 2/3
• Oct - Nov - ITERATE
• Nov - Dec - REFINE

2020

• Jan - Feb - REFINE
• Feb 2020 - Use with specific board project year 1 Games Design Students
• Feb - March - EVALUATE Testing
• March - June - ITERATE
• June - Sept - REFINE
• Sept - Oct - Testing with Year 2/3
• Oct - Nov - ITERATE
• Nov - Dec - REFINE

2021

• Jan - Feb - Use again with board project year 1 Games Design Students
• March - July - WRITEUP
• August - Oct - HAND IN

References

Licklider, J.C.R. (1960). Man-Computer Symbiosis. IRE Transactions on Human Factors in Electronics HFE-1, pp.4–11.

Open Education Consortium, About Page, [Online], Available at: www.oeconsortium.org/about-oec… , [Accessed December 15, 2018].

Shippman F M, Marshall C. (1999), Spatial Hypertext: An Alternative to Navigational and Semantic Links , [Online], Available at: cs.brown.edu/memex/ACM… , [Accessed December 15, 2018].

My proposal for eLearn 2019 was accepted and I was able to present to a good number of academics and students from across the UK. The conference took place at the University of Southampton, Avenue Campus so it was not far for me to go and I made a number of great contacts within Humanities and staff from other Universities that gave positive comment on the presentation.

You can watch the video of my short talk about my PhD work in progress from eLearn 19 here

The full slide deck can also be reviewed below.[footnote]Note the link at the start of the deck https://dctr.pro/elearn19 was for an etherpad that people could use to comment on during the session. My self hosted etherpad install is sometimes offline[/footnote]