Reflection on the latest user testing for Capstone Project, Kevin Ni, bn628

As always, this round of user testing is conducted on a group of my father’s colleagues, who fit perfectly into the target audience of this project, in the sense that they have some basic experience with computer uses, but none whatsoever regarding programming. They are also around the age 50 and have little relevant experience similar to programming or instructing machines to operate by given commands in specific syntax. What is different about this round of user testing, though, is that it is conducted as an A/B test in the hope that it can help evaluate the effect of recently added “explanation in proper computer science term” column. In short, this is a column that sit in parallel with the “instruction in human readable terms” column that is specifically designed to make it easier for the target audience to relate the unfamiliar concepts to real-life instances. The code indicator that points out to which step the program has reached are synchronised between the two columns, in the hope to establish a connection between the two representation and suggest the mind that they are homogeneous and are merely two shapes for one being. Apart from this, auxiliary labels are also added on top of the sections reading “循環” loop and “參數” parameter, so as to avoid the situation where people got too much used to the beginner vocabulary and is unable to apply or apprehend those used in the real development, which would contradict and invalid the purpose of this project. The means should not counterfeit the ends.

A total of 13 subjects agreed to join the test. 6 of them were categorised as the control group where they were presented the user interface without the “computer science term column”. The rest were categorised as the test group where they were presented the user interface with the “computer science term column”. The categorising is blind to the subjects but are transparent to the host. All subjects are presented with one piece of program which, through one Mutzian “麻將” game, introduced the concept of loop as “do something”, “stop and check some condition”, “continue to do the same thing if the condition satisfies”, “otherwise stop”. They were presented with the interface for 10 minutes and are free to click and interact with the interface. After 10 minutes, they were required to answer the question if they were confident that they had properly learnt the concept of loop. They were also required to finish two simple tests. In the first test, subjects were required to rearrange a piece of disarranged program written in human readable terms so that it produces a valid loop. In the second test, subjects were required to associate the steps of a Mautzian program to their corresponding computer science term.

The result are as follows. For the first question, one reported lack of confidence of the apprehension of the concerned programming concept and one from the test group as well. For the first test, 2 got the order wrong in the control group and 1 in the test group. For the second test, 3 got at least one association wrong in the control group and 1 in the test group.

The analysis, if disregarding the clearly too small sample size, and the lack of double blind test, points to no evident difference in confidence level between two settings, but a moderately increase in test performance with the “computer science term column”. This is probably due to the fact that those have been exposed to computer science terms feel more comfortable working with it again. Nevertheless, the improvement is not evident enough statistically speaking, hence should not be the definitive proof that the “computer science term column” would serve the project goal better. That being said, I have decided to leave it as an optional element and users can choose whichever way that he or she would feel comfortable with.

In conclusion, this round of user testing does not offer any novel insight on the design or the form of presentation of the project. However, it managed to offer a more solid basis of the design choice, and should be considered successful for that evidence does rule.

Midterm progress report for the Capstone Project, Kevin Ni

This documentation provides a brief of the effort that has been made towards the capstone project.

User testing
A boot-up user testing has been done with paper prototype of this project where the process and apparatus are presented in the form of a series of storyboards. Subjects are carefully selected from Shanghai Fashion Store under the requirement of as little prior experience with computer programming as possible. Subjects are presented with the paper prototype with all text translated to Mandarin Chinese. No additional instruction was given, other than that they should browse the prototype as they wish. Subjects are given as long as they need for the test. After subjects actively concluded their interaction with the prototype, a series of questions were asked to evaluate their response to the proposed design. Questions are as follow.

  • Do you feel confident that you have fully, or at least adequately understood the principles this project operates on?
  • Do you feel confident that you can continue exploring this project with more code pieces like you have done now?
  • Do you feel confident that you can figure out the next step without much effort?

A total of 7 subjects were recruited. 6 valid response was received. One subject expressed much concern for the goal of the project and would rather have a in-depth discussion instead of answering the survey questions. This demand was satisfied, but not included for the analysis. Among the 6 valid response, 5 answered yes to the first question, 4 answered yes to the second question and 3 answered yes to the last question. During the non-compulsory post-survey interview, 4 expressed that they were not able to grasp what should be done next and had to guess.

The result revealed that the ideal of this project had been well delivered. However, the proposed graphic design had left the users too much to wonder. This could lead to unwanted overwhelming of the users and consequently the reluctance of their interaction. This result has called for further continuous user testing regarding the graphic tutorial design later through the production phase.

Production and Progress
The major part of this project consists of implementing such a framework that is capable of loading in an external definition of code pieces and presenting the output of the code pieces to the users real-time. This has been done functionally. This documentation will, however, not discuss the technical detail regarding the design and structuring of the software. What is important is that the framework is now ready to provide a fully-functioning process for interaction, and is able to adapt to devices of different input devices and sizes of screen. It is safe to say that the first milestone of this project has been properly achieved.

As mentioned above, the implementation is only a functional piece. The design of a welcoming visual style has not been engaged in the production so far, hence the graphic interface is, to an extent, intimidating for the unknown. Given the important role visual representation plays in relieving the stress when facing unknown matter, such incompetence may entail serious problems in subsequent user testing, leading to inaccurate response and hence unreliable conclusion from analysis.

For the next milestone, this project seeks to implement a welcoming and inviting if possible, visual style. This has been proven by many research to help with the transition to strange rules and systems. User testing may continue before this milestone is reached, but the subjects will need to be notified of the incompleteness of the visual style and will be instructed to focus on the functionality as the top interest.

For detailed information about the technologies used so far, video or live demonstration, please contact the author directly. They are considered not relevant enough for this documentation and are not included as of now.

Final Project: The Silent Universe, NOC, Kevin

This is the documentation for the final project for the course Nature of Code taught by Professor Moon.

What
For my mid-term, I made a particle system simulator that was able to calculate the movement of a set of particles. It is built upon the real gravity formula, which in tern, is rather simple (like most other fundamental formulas): G = g * (m1 * m2) / d ^ 2. Several interesting patterns were found during experimental with different settings of gravity and environmental parameters, including the “tide” which is closely related to the actual tides as a result of the gravity of the moon, and the dancing stripes that twist and turn under the influence of surrounding centre of mass.

Now for the final, I intended to make something more “cosmic”, or, in simpler terms, more astronomical phenomenon. The original list included solar wind, galaxies, supernovas and gravitational lens. Unfortunately, I was not able to finish them all and in fact only managed to finish the first one. Senior year has been much more intense that I expected.

Basic Idea
The basic idea is simple, that the solar wind consists of numerous particles with electric charges. These particles are thus under the influence of the electromagnetic field of the Earth. The principle formula for electromagnetic forces is: F = kE * (c1 * c2) / d ^ 2.

What I got
Refer to this link: https://drive.google.com/open?id=13M942jp1VK8DawWYsbWNMMwh-quU9Djr.

Code and all other things
Please allow for some time while I clean my code and upload them.

Reflection on the Stack, Contemporary Media Theory

This is the written reflection to The Stack for the course Contemporary Media Theory.

This reflection focuses mainly on P2P networks and how they manage to continue operating even if all six layers in Bratton’s model were controlled by some sovereignty.

I would first like to clarify what the term “P2P network” actually means. Usually, it refers to file sharing programs such as eMule and BitTorrent. In this reflection, this term is used in reference to the algorithm on which these applications are built, and the network layered upon clients communicating through these algorithms. For example, BitTorrent is built upon DHT (Distributed Hash Table) and eMule is built upon KAD (Kademelia). Other instances include I2P and Tor, both of which providing anonymous network access to everyone (or every user, in Bratton’s term).

Now we can begin to look into the apparatuses of P2P networks and how, at every layer of Bratton’s model, they could circumvent the ubiquitous surveillance agents of the sovereignty, beginning from User. In his elaboration of this section, Bratton particularly maintained that the identification of a user should not rely on the physical presence of an intelligent form, whose only known agent being human, but on the ability to initiate columns in the Stack. P2P networks approach in a similar way to the goal of hiding the actual identities of their users, by mimicking the behaviour of automated bots. More specifically, they randomize their behaviour so that they do not feature common characteristics of human involvement. This drastically increases the cost of the sovereignty to interfere with their operation based on behavioural patterns, for that the sovereignty itself also relies heavily on automated surveillance agents and computational units, whose observable behaviour indistinguishable from the P2P networks and whose mission too important to abort. The same reasoning applies to Interface as well. By providing a minimalistic interface that accepts nothing but essential commands, P2P networks gives no chance that additional information is gathered during the interaction. Whether it is human A, human B or Wiki-bot C or even monkey D, there is no way to tell, not even the P2P networks per se.

Continuing to Adress. This is where P2P networks bear the least resemblance to traditional networks. In the book, Bratton quotes that “whatever that can be addressed can be ruled”. In the same way, we can say that “whatever that cannot be ruled must not be addressable”. Being able to address and access the concerned entities is one fundamental premise of a sovereignty’s authorisation over it, either electronically or geographically. P2P networks, on the contrary, have no such entity that could be addressed and approached. Put in a plainer term, there’s no one complete entity that corresponds to an end user. Each functional unit is sliced, duplicated and distributed across multiple, usually hundreds of end users. This strategy takes advantage of the fact that millions of millions of addressing takes place at a very low level in terms of the position on the network hierarchy. Such tremendous amount makes impossible the surveilling of each and single one of them. Again, similar approach on City level. P2P networks respond to regimes where thorough and constant inspection is employed, by slicing, duplicating and adhering small pieces of itself onto “clean” contents so that the inspection would not yield any fruit.

Now to Cloud and Earth. Imagine a world where Cloud have essentially been Earth, that is, where various Cloud platforms have penetrated the entirity of non-paper world. It’s either one or another, with no choice of none of the above. These platforms have access to all of the traffic and interaction and the ability to compute across time, for that they archive everything ever happened. The solution to this is to dive deeper down into Earth, where millions of physical elements now engage in the computation as well. By again dividing themselves into pieces and modules which, when alone, are just arbitrary and meaningless data, whereas when properly combined, could turn into functional units. Data and information are no longer the target, but the order and structure they are positioned, which turns out to be incalculable given the total number of computing agents involved in Earth level, let alone their geographical sparsity.

To some extent, all these solutions are the same, or at least similar in essence. They all exploit the inborn incapability of the soverignty that even though it could exercise power wherever it wants and in whatever way it wishes, it could not do this to all units on all scales simultaneously. In fact, no sovereignty would do this were there any sense left. This gives the chance for P2P networks to hide by making sure that their units would never aggregate either geographically or temporally, leaving no chance for the sovereignty to acknowledge the whole picture, let alone to control them.

Some one-week prototype of the Final Project, PDS

What it looks like

What I have done
For map generating:
Read a predefined sequence of roads and generate a map-like tree
Make sure that the roads don’t get too crowded by setting certain constraints for how the roads can expand

For silhouette:
Read an image and use contrast level to identify the edge of the building in the image
Add some ridiculous pixel manipulation to make it funny

What I still need to do
For map generating:
Keep trying various strategies so that they look like real roads, or perhaps introduce more predefined main roads
Have multiple beginning sequence for various regions

For silhouette:
Better edge identifying and strengthening
A GUI for use to pick their own image
Make the bl***y transparent work in Processing

For the poster:
Pick proper colour, storke weight and other parameters to make the poster look nice
Perhaps add some extra decoration

NOC, Assignment 8, Oscillation

Oscillation is a Latin-originated word, from oscillum, ultimately from os, meaning “mouth”.

So we’ve created oscillation and spring based on their periodical behaviour, and now maybe it’s time for oscillation based on real physical simulation, which, in other words, oscillation that springs naturally from certain initial settings.

Check the video below:

And the code below:

Some code reinterpretation of Yayoi Kusama’s pumpkin

So I’m working on Yayoi Kusama’s avant-garde (even til this day) pumpkins.

To begin with, these are her pumpkins:

And these are my pumpkins:

Essentially I created a strip that mimics the texture of the pumpkins. Curves are sine waves. Size of the dots are randomised. Their relative position to the base lines are Perlin noised. Colour patterns are directly picked from photos of Yayoi Kusama’s pumpkins. See code here.

If it were not for art, I would have killed myself a long time ago.

Week 5, Force, NOC, Kevin

In the end I missed one documentation.

So this assignment is about force, and instead of doing gravity, I did repelling forces that simulates the behaviour of particles being blown away by winds. This is done through the reversion of the direction vector (in simpler terms, swapping two points when subtracting them). To make things funnier, I also added different regions that have different friction factor, so you can see how particles are sort of trapped in some areas and are very celerated in other places. By refreshing the background less frequently and with a certain opaque index, the trace of the particles are also retained, creating an effect of bullet hitting gels and then got trapped in it until it eventually stops.

Link to the assignment.