The prompt was simple: create an open-source data set and publish it to GitHub.
In an effort to make the world a less serious place the dataset that I’ve tried to create is an entirely useless one: it is a dataset of the people who have viewed the dataset.
That was the intention, at least. In it’s current state it’s barely a proof-of-concept, although I think I have carved most of the foundations for the project out at this stage.
This project is a total experiment in the workings of git, GitHub, and servers. I’m running a node server on Heroku, which uses a GitHub repo of your server files to build your server.
The server is also running a node-based wrapper for git, so it sees itself as a git repo, a branch of the original. The server fetches data from the GitHub repo that it is built off (the original) and updates its local files based on that, while on the client side the raw.txt data is rendered on screen.
Finally, once a user navigates to the site, the server makes a change to its local raw.txt based on user information, commits it to its local branch, and pushes that to the remote branch (main branch/origin/master?). I have hidden my credentials in the environment variables of the server to allow for authorised pushing.
The problem is it doesn’t really work that well. Partly because the way I’m updating files is a bit slow, and there seem to be chunks of data missing out, but mostly because I think something is going wrong with Heroku, node.js, git, and their interactions. The process works fine when I run it locally, but once I push to Heroku, although I receive no errors or crashes, the GitHub files do not update.
I’ve learned a lot about navigating git in the command line, so I don’t consider this a complete failure, but I’m a little disappointed that the final step in the process was the one that broke everything…
New York is a spectrum of signage, from aesthetic, informative, and concise information delivery systems to the most confusing array of seemingly random assortments of words and icons (the NYC street parking signs come into mind).
A short walk around the Village garners a number of examples from across this spectrum.
From within our own walls at ITP comes my first example; an advertisement for a class. I have blurred out names and the QR code for privacy.
The most striking aspect of this poster in its current state is how crumpled it is. Of course, once you release your poster into the ‘wild’ there’s not much you can do to protect it from such cruel acts of vandalism (intentional or otherwise), but I do think that it is important to consider the physical space(s) your poster will be, not just the content of the poster itself.
In this case, the poster is pasted haphazardly in a corridor that many people walk through, and on an electrical box that may require access. The placement itself is questionable as the poster may be subject to people brushing by in a rush, or people moving it to access the electrical box.
In addition, the untidy, ripped electrical tape that has been used to secure the poster does no favours. Perhaps this is a stretch, but there’s a concept in social behaviour known as the Broken Window Theory. Distilled down to its usefulness in this case, the theory suggests that visible minor problems encourage, or at least don’t discourage, more serious problems. I propose that in the case of the above poster the haphazard and untidy placement of the poster made it seem less of a problem once the poster was accidentally (or intentionally) crumpled.
In essence: the unintentional crumpled paper fits the aesthetic of the original ripped tape. Perhaps if the poster was more neatly placed, a passer-by would have more incentive to ‘fix’ the placement if they walk by and accidentally displace it.
The environment of the poster is not the only concern that I have with it. The design itself is, undiplomatically speaking, boring. Three paragraphs of black text on blue paper. There are no graphic elements to catch attention, there is no information hierarchy save the top-down nature of prose, and frankly if the poster were not so crumpled I probably would have passed it by completely oblivious.
The only design element that I can vaguely comment positively on is the choice of yellow tape with blue paper. The hint of yellow does complement the blue background. That said, with such little thought put into the rest of the design I would not be surprised if this was nothing more than a happy accident.
Venturing outside we soon come upon another example of ‘bad’ design, or rather design that does not do well in capturing attention and conveying information clearly.
I do not yet have much experience with the NYC bus system. This bus stop signage is certainly not beginner-friendly. Perhaps there is some logic to this system that makes sense to transit veterans, but it is obscure to me.
What is clear to me, to be fair, is that the M101, M102, and M103 busses stop here. What is less clear is why “East Village” and “City Hall” are labelled with different colour codes. I assume they are the end point of each bus line, but that is not explicit.
What is far less clear is the sign on the top. There is an arrow pointing towards the street, perhaps indicating the boarding side (which seems redundant given the placement of the sign), an accessibility icon on the other side of the bus (does that mean the accessible entrance is on the left?), and a large red banner indicating “No Standing“. Does that mean no standing at the bus stop? That seems confusing since it’s a bus stop. Perhaps the message is for cars? That is not made clear.
A design that I take a little more kindly to, even if I think the message is off-putting, is this no cycling/skateboarding sign.
It is simple and conveys its message. It understands its environmental context – that it must quickly convey clear instructions to many rushing people. Perhaps the text is a little redundant given the icons, but the case could be made that the icons are there to catch the attention of passers-by, and the text clarifies the message.
Certainly the aesthetics could use some work; there seem to be three different typeface-spacings on such a short sign. But at the very least this sign conveys its message clearly.
Finally, I came across this instructional sign on the ubiquitous Citibike. I have never used Citibike, but I found these instructions far more clear and beginner-friendly compared to the bus sign I mentioned above.
There are clear, concise instructions central on the dock, with extra information supported by consistent icons to the sides.
On the bike itself is one key piece of information, supported by an easy to understand graphic.
The Joreen piece speaks of the responsibility of a movement or group to structure itself in a manner most beneficial to the movement itself, not just the elite within the movement.
The Turner interview spans many varieties of responsibility, from the responsibility of engineers to consider the ethics inherent in the tools they design, through the responsibility of society to recognise tech institutions such as Facebook as potentially huge threats to political power distribution, to the responsibility of art and artists to provide a cultural compass in times of political turmoil, and many more examples.
The Choi article covers the short term responsibilities of creator communities to consider the networks and institutions they build, as well as the longer term responsibilities of the same to act as “cultural stewards” for future generations.
In contrast to the vast sweeping nature of the other articles, the Kulkarni guide lays out the specific responsibilities of submitting code to a project.
That’s a lot of responsibility to put on one person. How can one individual both consider what specific emoji to use that will convey polite dissent, as well as contemplate how their pull request will be interpreted by an Ethics of 21st Century Code high school class in year 2318.
The answer is that they can’t, really. All these pieces, even the relatively straightforward code submission guide, read to me in the spirit of ‘best intention.’ There’s no one way to build ethical institutions, there’s no one way rage against the evil machine. It’s as if they collectively say “at least give it a shot, with humanity’s best intentions in mind, and you’ll be on the right track.”
Of course each author has a different way to go about this ‘best intention’; a different contribution so to speak. By publishing their considered thoughts on accessible media, they are each contributing to a growing resource on responsible use of technology.
I see these four vastly different articles as submissions to an Open Source Responsibility project. By no means are these the only submissions; I’m sure we could find many more different considered opinions on the ethical use of technology. Perhaps this project in its current state would be considered unstructured by Joreen. Or, perhaps Choi might say the project has a very organic distribution. That is not the point.
The point is, however indefinite the bounds, there seems to be a call across the open source world to truly reflect on how the ideology and practice of open source can and will change current institutions, and shape future ones.
What will your contribution be?
Cool head, warm heart? Today is a further exploration into Blender’s particle system.
Find project files here.
Playing around with the particle system in Blender. Trying to emulate a sort of flocking behaviour
I have chosen to review the first in a series of covers designed by Olly Moss for the release of digital Harry Potter books.
The single typeface used seems to be a custom font that emulates a neat paintbrush, sans serif, with regular lines.
The colour palette consists of 3 main colours; orange, yellow, and blue – which are complimentary colours. The shades of each colour vary a bit, but I have displayed the 5 most consistent shades in the top left of the image above. I find it interesting that the image is for the release of digital book versions, but the colour tones and brushed style are so reminiscent of physical paper.
The cover has clear margins, with a little paintbrush spill that ties in to the overall style of the image and adds a bit of a dynamic feel, as if the image is spilling out of its bounds, perhaps into the real world.
Although there is not a clearly delineated grid, the image seems to have four distinct rectangular layers, each containing a single important feature of the image. Further explanation is embedded in the image above.
The image has clearly been designed with the rule of thirds at least in mind. When a ‘grid of thirds’ is laid over the image, three important key features are revealed:
Firstly, the imposing castle in the image is situated along the top right point of interest, immediately catching the viewer’s eye.
Secondly, the characters central to both the cover and the story are placed along the horizontal lower third.
Thirdly, almost as a bonus, the mountain peak in the background could be lost in obscurity, but its placement on the top left point of interest draws it back into the image, creating a little bit of extra detail right where it needs to be.
In addition to all of the above, the artist makes very astute use of diagonal lines, drawing the viewer’s eye from one feature to the next in such a way that their eye never needs to skip over empty or dull parts of the image.
Two striking parallel lines (indicated in bold above) slash across the image, replacing the need for a grid by separating the three key features: the castle, the characters, and the copy.
Almost perpendicular to those lines is a central diagonal line. This line connects the castle in the top right to the central characters near the bottom, demarcated by a well detailed and exquisitely shaded cliff.
Additional diagonals are revealed in the details; the line of boats heading towards the bridge, the orthographic structure of the castle.
All of these large and small diagonal lines serve to draw the viewer’s eye across the image, telling an entire story in a single frame.
I am historically a user of open source software far more than a contributor. While I hope that this will change over the coming semester, this reflection is written with that in mind.
This is not so much a trend as it is an obvious core component of open source software. The idea of open access for me, however, extends beyond merely being freely distributable. It’s an ethos rather than a (lack of) price tag, an ethos that facilitates building community and education. More on that below.
By this I do not mean that open source projects are easy to get the hang of, or easy to learn. Rather, the ‘cost’ of experimentation and play is far less than on closed source software.
For example, Blender is a software that is entirely free, because of its open source nature. An aspiring artist merely needs to put in the time and effort to start learning 3D creation on Blender, though that journey may be long and difficult.
In the case of proprietary software, however, the artist must consider whether the thousands of dollars to simply start learning is worth the potential future rewards (a job, artistic fulfilment, etc). Even if the software comes with an educational license, those are usually restrictive in functionality, in what the resulting work can be used for (e.g. non-commercial licenses), or both.
Open source software, from the potential user’s point of view, and especially when compared to proprietary software, fosters an environment conducive to low-cost, low-barrier experimentation, learning, and play. This is very important in engaging users of many different backgrounds who, for whatever reasons, cannot pay to simply learn to use a tool.
From my little experience in the open source communities of Blender, Processing, p5, and the like, there seems to be far less user gatekeeping than the average software user community.
What I mean by this is the communities are more open to complete beginners, both in the sense of how people interact, as well as inherent structures within the institutions.
The user communities of the projects I’ve mentioned above do not look down beginners, they do not dismiss a lack of qualifications, they do not (generally) brush aside questions as obvious or trivial. This is in contrast to the communities of some similar proprietary software (here’s looking at you, Maya). This type of openness definitely also contributes to the sense of low barriers to entry I described above.
In addition to generally open and friendly user communities, all three projects I mentioned above have very clear ‘getting started’ docs, FAQs, and resources for beginners. Perhaps it is because proprietary software expects certain qualifications, or proprietary software is generally built by people who assume an already-extant user base, but my experience as a user of closed source artistic software is far less beginner friendly, and the communities can be a little more snooty. The open source projects I have experience with inherently foster friendly, accessible user communities, which then leads to a much friendlier and more supportive user environment in general.
These three trends of my open source experience are by no means all-encapsulating, and of course I am sure there are open source projects that are less beginner friendly or have different barriers to entry. I consider these idealistic tenets, things to keep in mind as I begin my own contribution journey, guidelines to bring into my own open source projects, contributions, and interactions.
Today I learned that an LED can be used to both transmit light (the intended purpose) and also to receive light. A little bit of electricity is sent back along the anode when enough light is received by the LED.
With some clever manipulation, this effect can be used to turn an LED into a transceiver; a device to both transmit and receive data.
Here I use PJON, a free network protocol, to send (very simple) data between two arduinos using two LEDs. This is currently just a proof of concept and not much more than the example code supplied.