initial social shell notes made in 2014 with Anne Laforet

NOTES

+(The machine stops)
+
+* We (Anne + I) need to propose an alternative network.
+** File collection of different kinds of materials
+** Shared Keywording system
+** Recipes reusable
+
+* Can the architecture allow speculative / experimental 
+
+Speculative / Parody / Space
+
+Nourrir
+
+Provide
+
+Our project provides documentation service
+
+
+In the end, we want a working documentation...
+Ideally, we want a document written
+
+Systeem as writing spac
+1984 Surveillance => 2014 Render service
+We propose a "service" oriented system with all the problematics of Web 2.0
+* Central,
+* Truth, Authenticity...
+* We watch, we make reports, 
+* We share the surveillance
+* We invite users to hack the system
+* Do we hide power relations, made explicit
+(Specialist, Technical decisions, )
+Hackable system
+* Hot spot software ?
+Surveillance systems
+* Usage facebook
+<!> Collect my HRO story 
+<!> Learn about setting up hot spot
+CF: Eleanor Greenhalgh
+* Milgram Experiment
+* Kate Rich interview FSS
+
+* Find the tone : We need to actually offer a service
+
+
+NOTES FROM MEETING WITH ANNE
+============================
+
+Imaginative Cartography of the Shell
+The Shell as a Fiction
+Avoid Single Image Pipeline 
+Efficiency vs. Multiplicity
+
+In both cases: sharing, serendipity, ... good things... but in what context and to what consequence
+
+Frictionless Sharing:
+* Hierarchical (Designed by designers, programmed by programmers, used by users, paid by advertisers)
+* Automatic
+* Consent out of context (one-time / pre-use consent through EULA / TOS)
+* Shortest path, optimum solutions
+
+vs.
+
+Promiscuous Pipeline:
+* Mixed roles (user becomes developer...)
+* Hands on control
+* Editability through interrogable
+* Variability, multiplicity
+
+Variability / Multiplicity:
+    like make can produce many versions / formats of output, an ideal promiscuous makefile would support a vast variety of possibilities
+
+Granularity:
+    what's the smallest unit of "raw" material... 
+
+Recomposability:
+    How can the raw "units" be recombined / bound in new documents / frames / compilations
+
+Examples:
+    Image + Caption
+    Q + A
+    Commit Message
+
+
+==================================================
+18 April 2014, Variable
+==================================================
+Parameters of time / space
+instead of login.
+(IP address, Authentication via password/email / OAUTH)
+
+Imagine a network tagging time,
+Location,
+All activity is stored as a kind of relative map of nodes
+
+REPORT
+Playful: Make connections between people... introduce people to each other?
+
+Return to the idea of sensing each others presence when working.
+
+How do you give glimpses of others at work / encourage collaboration / spirit of working together in a digital enrivonment without devolving into full surveillance (watching every detail, etc).
+
+RESPONSE TO THE "DATA NUDISM"
+How to avoid the situation that providing a full report of logged activities, even when intended to warn, in fact comes very close to existing practices of "data nudism" -- ie providing self-surveillance as a service.
+
+Stronger position is to propose alternative ways of working and active writing spaces (as opposed to passive logging) for people to explore collaboration and shift tracking to something explicit.
+
+* Making the logs visible
+
+Example: Typing a space in the terminal to prevent a message entering the history
+
+
+[?] Core question: do we take a position of parody
+KEY to actually propose a viable alternative
+
+
+Scenario: People arrive for summer school, are handed a network pod...
+immediately contrasts to tradition hotspot are apparent...
+
+Etherpad + Anonymous contribution, time based //
+
+(Nameless !== Anonymous)
+
+Nameless, linking
+
+Social File System // 
+alt git / distribute
+Different set of handles for organizing & correlating data.
+Proposing relations based on:
+* Algorithmic (images with similar amounts of red)
+* 
+
+Granularity
+Recombination Modules
+
+
+Examples
+* Apple's Time Machine (based on the individual hard drive)
+** non-collaboriative
+* Internet archive wayback
+** Based on the identity of the URL, )
+** Limited by the parameters of the spider (ignoring some types of media, privileges a client-side view of the data)
+** Follows nobot = noarchive
+
+* Git
+** Hash based identity (files are their content, not their name)
+** Name + email
+* Torrents
+** Magnet link identity -- Distributed
+
+Where the Social Network proposes relations based:
+** Rejection of traditional authentication
+** 
+** Algorithmic connections
+
+* Share Canvas
+
+
+Across different collaboration / file management tools:
+* Identity (of people, of files, of digital content)
+* Time
+* Core stuctures for organizing / indexing
+* Interface
+
+Network / Access / Tactics of engagement (with existing...)
+* Proxy, means of accessing existing systems (example of using github with other kinds of identity)
+* Scroogle: Example of using a single account
+* Publicizing one's login information
+* Question of publishing
+
+Relationality
+* Setting in stone vs. Ad hoc relations
+* Web ring, adding a link /// PYRING!
+
+M commits an image
+A commits a text
+The commiters are sitting next to each other at the time & there's less than 5 seconds in time.
+
+* SVG layers work
+* http://www.yourworldoftext.com/
+
+git + etherpad = shared canvas
+a distributed space for files and ad hoc relationship
+* Location
+* Time
+*
+
+Multidimension space
+* Relative timelines (not calendar / absolute)
+* How to avoid the "sync-kill" (example of cinema)
+* Shared index of files...
+
+
+* Pre Summer School
+* Summer School
+* Post Summer School
+
+
+Three temporalities of writing
+* Prospective / Planning
+* Real time / Happening Now
+* Retrospective / Editing
+
+Location, similary can be relevant / and can be not.
+
+Ideally an interface for editing where one can "check in / check out" -- choose to detach.
+
+
+* Timelines
+* Spaces
+* Tags
+
+
+* yourworldoftext
+* second life
+* gray editor (julien maire)
+
+* social/situated/cyberspace
+IRC
+
+Object as a clock / The chess clock
+
+
+
+Example for prototyping futures:
+* Using timelines to place / relate elements such as 
+* IRC as a protocol allows for distribution -- how does this work?
+
+
+
+
+
+==================================================
+
+
+

index.html

+<!DOCTYPE html>
+<html>
+   <head>
+      <title>socialshell</title>
+      <meta charset="utf-8" />
+      <script src="/lib/jquery-1.10.2.min.js"></script>
+      <link rel="stylesheet" type="text/css" href="styles.css">
+      <script type="text/javascript" src="script.js"></script>
+   </head>
+   <body>
+      <div>
+         $<input id="cmd" type="text" value="" />
+<!--          <button id="start">start</button>
+         <button id="stop">stop</button>
+         <button id="manbutton">man</button>
+         <button id="cookbookbutton">cookbook</button>
+ -->      </div>
+      <div class="bash" id="shell" style="width: 640px; float: left"></div>
+      <div id="man" class="bash" style="display: none;"></div>
+   </body>
+</html>

script.js

+$(document).ready(function () {
+
+   /*
+
+   system as cookbook writing environment
+   hooks into repository manager for shared cookbook writing the (social)
+   + hooks for realtime (chat?!)
+
+   Common problems:
+   Finally have got a working command, just want to save it
+   it's just awkward enough that you don't do it
+   (the effort of cut/paste, swapping to editor, naming and placing the file)
+   Instead: one-click "bookmarking", added to personal history list
+
+   Terminal is binary-averse (image, audio, visual material is "alienated" to external display)
+   HTML is "collage"-able means of mixing media
+
+   !! Pipeline editor / debugger with media-specific previews
+
+   * Bookmark (this command)
+   * Add to Recipe/Script
+   * Smart Tab completions
+   * Link to cookbook (examples)
+
+   separate stderr / stdout
+   script panes (editable!?)
+
+   man pages as postscript / pdf / savable?!
+   annotations in man pages <!>
+
+   mime type sniffing of output & appropriate browser-based display ( image / audio / video / text+html )
+
+   Missing features
+   * live programs / keyboard control (mplayer, top, etc...)
+
+   */
+
+   $("#cmd")
+      .on("keypress", function (evt) {
+         console.log(evt);
+         if (evt.keyCode == 13) {
+            go();
+
+         } else if (evt.keyCode == 9) {
+            // tab
+            return false;
+
+         } else if (evt.charCode == 32) {
+            man();
+
+         } else if (evt.keyCode == 8) {
+            // Backspace
+
+         } else if (evt.keyCode == 38) {
+            // UP
+
+         } else if (evt.keyCode == 40) {
+            // DOWN
+
+         } else if (evt.keyCode == 37) {
+            // LEFT
+
+         } else if (evt.keyCode == 39) {
+            // RIGHT
+
+         } else if (evt.charCode == 92) {
+            // PIPE !
+         }
+      })
+      .focus();
+
+function _sock (wsuri, opts) {
+   // to do add support for stderr, stdin & buffer data to ensure line-based processing callbacks for the two
+   // also set a flag for CR ?!
+   // might want to ensure closed before reopening a new one ?!
+   var that = {
+      sock: new WebSocket(wsuri)
+   },
+      curline = '';
+
+   that.close = function () {
+      that.sock.close();
+   }
+   that.sock.onopen = function(e) {
+      console.log("connected to " + wsuri);
+      if (opts.open) {
+         opts.open.call(that, e)
+      }
+   }
+   that.sock.onmessage = function (e) {
+      var lines = e.data.split(/([\n\r])/),
+         i,
+         len = lines.length;
+      if (len == 1) { // extend current line...
+         curline += lines[0];
+      } else {
+         for (i=0; i<len; i+=2) {
+            if (lines[i] == "") { continue; }
+            curline += lines[i];
+            opts.stdin.call(that, curline+lines[i+1]);
+            curline = "";
+         }
+      }
+   };
+   that.sock.onclose = function(e) {
+      console.log("connection closed (" + e.code + ")");
+      if (opts.close) { opts.close.call(that, e) };
+   }
+   return that;
+}
+
+   var sock = null,
+      wsuri = "ws://localhost:9000",
+      lastline,
+      curline = '';
+
+   var shell = $("#shell").get(0);
+
+   function go () {
+      $(shell).text("");
+      sock = _sock(wsuri, {
+         open: function (e) { this.sock.send($("#cmd").val()); },
+         stdin: function (text) {
+            // console.log("message received: " + e.data);
+            var cr = text.match(/\r$/);
+            if (!cr || !lastline) {
+               lastline = $("<div></div>").appendTo(shell);
+            }
+            lastline.text(text)
+         },
+         close: function () {
+            console.log("closed");
+         }
+      });
+   }
+   function man() {
+      $("#man").addClass("loading").show();
+      var cmd = $("#cmd").val().split(/\s/)[0],
+         src = '';
+      console.log("cmd", cmd, "*");
+      $("#man").text("");
+      sock = _sock(wsuri, {
+         open: function (e) { this.sock.send("man -Thtml "+cmd); },
+         /* TODO: Hyperlink See Alsos !!! */
+         stdin: function (text) {
+            src += text;
+            // console.log("man");
+         },
+         close: function () {
+            console.log("man closed");
+            $("#man").html(src);
+            $("#man").removeClass("loading");
+         }
+      });
+   }
+   $("#stop").click(function () {
+      if (sock) {
+         sock.close();
+         sock = null;
+      }
+   })
+
+});

serve.py

+#!/usr/bin/env python
+
+import argparse, socket, os
+import twisted
+from time import sleep
+from twisted.internet import reactor, protocol
+from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol, listenWS
+from twisted.web.server import Site
+from twisted.web.resource import Resource
+from twisted.web.static import File
+from twisted.web.twcgi import CGIDirectory
+
+
+class AAWebSocketProtocol(WebSocketServerProtocol):
+    def __init__(self):
+        # WebSocketServerProtocol.__init__(self) # apparently there isn't one
+        self.process = None
+ 
+    def onMessage(self, msg, binary):
+        if (self.process == None):
+            self.process = AAProcessProtocol(self)
+            parts = msg.strip().split()
+            reactor.spawnProcess(self.process, parts[0], parts, {})
+            # self.sendMessage("Starting {0}...\n", False)
+
+    def onClose (self, wasclean, code, reason):
+        # web socket has closed, kill the process
+        print "web socket onClose", wasclean, code, reason
+        if (self.process != None):
+            self.process.kill()
+            self.process = None
+
+    def ended (self, code):
+        # process has ended (normally), close ourself
+        if (self.process != None):
+            # close outself
+            self.transport.loseConnection()
+
+class AAProcessProtocol(protocol.ProcessProtocol):
+
+    def __init__(self, ws):
+        # self.output = ""
+        self.ws = ws
+
+    def connectionMade(self):
+        print "connectionMade"
+        self.transport.closeStdin() # no input to mplayer
+
+    def outReceived(self, data):
+        # print "outReceived, with %d bytes!" % len(data)
+        # self.output += data
+        self.ws.sendMessage(data, False)
+
+    def errReceived(self, data):
+        print "errReceived, with %d bytes!" % len(data)
+        print "<ERR>", data,
+
+    def inConnectionLost(self):
+        print "inConnectionLost, stdin is closed! (we probably did it)"
+
+    def outConnectionLost(self):
+        print "outConnectionLost! The child closed their stdout!"
+        # evt here code to (trigger) a processing of the output
+
+    def errConnectionLost(self):
+        print "errConnectionLost! The child closed their stderr."
+
+    def processExited(self, reason):
+        print "processExited, status %d" % (reason.value.exitCode,)
+
+    def processEnded(self, reason):
+        print "processEnded, status %d" % (reason.value.exitCode,)
+        self.ws.ended(reason.value.exitCode)
+
+    def kill (self):
+        # NOTES
+        # Here's the trace of a kill (when triggered by websocket.onClose)
+        # web socket onClose True None None
+        # errConnectionLost! The child closed their stderr.
+        # outConnectionLost! The child closed their stdout!
+        # processExited, status 1
+        # processEnded, status 1
+
+        # self.transport supports methods: write, closeStdin, closeStdout, closeStderr, loseConnection (close all 3)
+        # kill seems to cause errors while loseConnection closes things gracefully
+        # self.transport.signalProcess("KILL")
+
+        self.transport.loseConnection()
+
+def main (args):
+    parser = argparse.ArgumentParser(description='Happy to serve you')
+    parser.add_argument('--port', type=int, default=8000, help='http port number')
+    parser.add_argument('--wsport', type=int, default=9000, help='websocket port number')
+    parser.add_argument('-t', '--notryports', default=True, action="store_false", help='if a port is busy, automatically try other ones')
+    parser.add_argument('--share', default=False, action="store_true", help='Run as server accessible via your local network')
+    args = parser.parse_args(args)
+
+
+    tryports = args.notryports
+    port = args.port
+    ipaddr = None
+
+    if args.share:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("wikipedia.org",80))
+        ipaddr = s.getsockname()[0]
+        interface = ipaddr # None would listen to all
+        s.close()
+    else:
+        interface = "localhost"
+
+    # HTTP
+    resource = File(".") # Resource()
+    # resource.putChild("f", File(cwd))
+    # resource.putChild("lib", File(activearchives.getDataPath("htdocs")))
+    # resource.putChild("cgi-bin", CGIDirectory(activearchives.getDataPath("cgi-bin")))
+    # resource.putChild("", File(activearchives.getDataPath("root/index.html")))
+    # resource.putChild("", File("."))
+    factory = Site(resource)
+
+    # WebSocket
+    wsfactory = WebSocketServerFactory("ws://localhost:{0}".format(args.wsport))
+    wsfactory.protocol = AAWebSocketProtocol
+    listenWS(wsfactory)
+    # reactor.run()
+
+    while True:
+        try:
+            if ipaddr:
+                server_address = (ipaddr, port)
+                servername = ipaddr
+            else:
+                server_address = ("", port)
+                servername = "localhost"
+
+            reactor.listenTCP(port, factory, interface=interface)
+            print "(Twisted) Archiving starts now --> http://{0}:{1}".format(servername, port)
+            reactor.run()
+
+        except twisted.internet.error.CannotListenError:
+            if tryports:
+                if port < 2000:
+                    port = 2000
+                else:
+                    port += 1
+                sleep(.01)
+            else:
+                print """
+====================================
+Error: port ({0}) is already in use
+====================================
+
+You can pick another port number
+(for example 9999) with:
+
+    sosh --port 9999
+""".format(port)
+                break
+        else:
+            raise(e)
+
+if __name__ == "__main__":
+    import sys
+    main(sys.argv[1:])
+
+ 
+

start

+#!/bin/bash
+source venv/bin/activate
+python serve.py

styles.css

+body, input {
+    margin: 10px;
+    font-family: monospace;
+    font-size: 16px;
+    background: #000;
+    color: white;
+}
+.bash {
+   font-family: monospace;
+   font-size: 12px;
+   height: 24em;
+   overflow: auto;
+   resize: both;
+   border: 1px dotted black;
+}
+#shell {
+   white-space: pre-wrap;
+}
+#cmd {
+   border: 1px solid black;
+   width: 640px;
+}
+.loading {
+   background: #AAA;
+}
+input#cmd {
+    border: none;
+
+}
+#man {
+    background: white;
+    padding: 10px;
+    color: black;
+    width: 400px;
+    float: left;
+}
+#man a {
+    color: purple;
+    text-decoration: none;
+}
\ No newline at end of file