From: Lucian Mogosanu Date: Sun, 10 Nov 2013 09:41:16 +0000 (+0200) Subject: posts: 012 X-Git-Tag: v0.3~8 X-Git-Url: https://git.mogosanu.ro/?a=commitdiff_plain;h=d20bdaa3b40b3af9efcfbc365f3b087614fe6222;p=thetarpit.git posts: 012 --- diff --git a/posts/y00/012-on-context-awareness-in-computing.markdown b/posts/y00/012-on-context-awareness-in-computing.markdown new file mode 100644 index 0000000..bb0d5b8 --- /dev/null +++ b/posts/y00/012-on-context-awareness-in-computing.markdown @@ -0,0 +1,154 @@ +--- +postid: 012 +title: On context awareness in computing +excerpt: An analogy between natural language and computing. +author: Lucian Mogoșanu +date: November 10, 2013 +tags: cogitatio, tech +--- + +The term "context awareness" relates mainly to linguistics, i.e. the quality of +a language of being context-(in)dependent, although it can be described in more +generic terms. + +For example, let $S$ be a topological structure. We don't much care about how +the structure looks; it could be a free monoid; since I'm into category theory, +it might as well be a category $\mathcal{C}$ with objects and arrows; maybe +you're more into physics, so it could be a phase space or a probability space; +whatever. + +## Context awareness, context dependence + +If we define a "location" as an arbitrary point $p \in S$, then the "context" +of $p$ is its [neighbourhood][1]. We need not think of the particulars of the +neighbourhood, since, as we said, we don't really care about the particulars of +$S$. This context we speak of must therefore, in addition to its mathematical +meaning, have some use to us, which, as far as I can tell, is obvious: if we +set $p$ as a reference point (like, for example, we set an origin in a +Cartesian system), then we can describe its neighborhood in respect, or +relative, to $p$, rather than devising an absolute description using $S$. While +this approach might not give us any advantages from a mathematical point of +view, it certainly has practical advantages. + +For example, let's say I'm in a house that has two rooms, $r_0$ and $r_1$. Each +room has a bag of pretzels, and since I'm, let's say, in $r_0$, I'm eating +pretzels from the bag in that particular room. At some point in time, I say to +you, the reader, also situated in $r_0$, that "these pretzels are making me +thirsty". To understand my utterance, your mind automagically comes with the +following model. + +Since there are two rooms in the house, its simplest abstraction is the set $R += \{r_0, r_1\}$. Also, since there is a flow of time in our universe, there +exists a set $T$ expressing time. Also, since you are paying attention to +someone at some point, you can come up with a set $P$ of people. We shall +denote with $\Pi$ the cartesian product of the aforementioned sets, thus $\Pi = +R \times T \times P$. Note that this is only enough to describe the context, +not the entire "space of action". + +At one point $\pi \in \Pi$ I tell you that "these pretzels are making me +thirsty". Now, since you're using $\pi$ as a reference, you can infer that I am +referring to the pretzels in $r_0$, rather than the ones in the neighbouring +room. This is essential to human interaction, since it relieves us of the +burden of explaining *the entire* context, by using it as an implicit +construct[^1]. Thus humans are context-aware machines, and it would be +impossible for a human society to exist without the individuals' ability to +generate and comprehend context-dependent language. ▪ + +Thus we define "context awareness" as the ability to be intrinsically aware of +context, context dependence and/or anything equivalent to that. + +## Context awareness in computing + +Context awareness is given a lot of attention in the context of (semantic or +otherwise) web applications. For example, Google is aware of your location when +it suggests a particular restaurant, and of the time of day and day of week +when it tells you the fastest route to work; Facebook displays context-aware +suggestions and posts depending on the things you liked at a given point in +time; and so on. This is, however, sugar, or icing on the cake, call it +whatever you like. There are more fundamental uses of context awareness. + +The [GHC][2] Haskell interpreter is one such example. While Haskell is a purely +functional language, and by default models stateless programs, monads can serve +as a vehicle for state, and GHCi uses the `Prelude` monad to do its stuff. For +example we can write: + +~~~~ {.haskell} +Prelude> take 10 $ iterate id "bla" +["bla","bla","bla","bla","bla","bla","bla","bla","bla","bla"] +~~~~ + +which is an arbitrary Haskell expression. The `Prelude` monad allows us to use +the previous result in the current computation, via `it`: + +~~~~ {.haskell} +Prelude> take 2 $ map (++ " foo") it +["bla foo","bla foo"] +~~~~ + +Another, more notable, example, is the language Perl, which has a special +variable, `$_`, defined implicitly in some contexts such as loops. Let's take +the following example[^2]: + +~~~~ {.perl} +#!/usr/bin/env perl +use v5.10; +while(<>) { + next if /^#/; + last if /^q(?:uit)?$/; + say "Howdy!" if /^hello$/; +} +~~~~ + +What the Perl program does is, it implicitly defines `$_` as the result of `<>` +and verifies it against three particular patterns at every iteration. This +should come as a natural thing to anyone who speaks a language, as the `$_` +variable is tied to the `while (<>)` context, and it's only natural to use it +as an implicit comparator (that is, without even mentioning it) in that +specific context[^3]. This pearl is structurally identical to our pretzels +example and GHCi's `it`, which, by the way, isn't called `it` arbitrarily, +since we use it (sic) abundantly in everyday communication. + +What bothers me, however, is that this approach isn't used more in computing. +`ping` for example is dumb enough to not infer the current network address +whenever I type something like: + +~~~~ {.bash} +$ ping .7 +~~~~ + +The full address would, of course, be something along the lines of +`192.168.1.7`, but I'm already part of the `192.168.1.0/24` network, otherwise +I wouldn't be able to communicate with `.7`. Sure, an argument against context +awareness would be that I could be part of other networks too, say, +`10.0.0.0/16`, but ping could simply select the first available device and let +the user specify it explicitly if required[^4] [^5]. Well, at least IPv6 +addresses have shortened forms. + +Before I end the post, I feel compelled to mention that context awareness also +has a big disadvantage, and that is the increased probability of ambiguity, +which is especially damaging to artificial/formal languages. Languages such as +Perl solve this issue by introducing a "canonical form" and additional +constraints, such as binding `it`/`$_` to the innermost context. + +In natural language, on the other hand, beating a horse to death has a +different meaning depending on whether you're a gymnast or a cowboy. + +[^1]: We both know we're in a house with two rooms, in $r_0$ at some point in +time, we are paying attention to each other and there are pretzels. Lots of +tasty and incredibly salty pretzels. + +[^2]: Shamelessly stolen from [Stack Overflow][3]. + +[^3]: That's what you get for using a language designed by a linguist. + +[^4]: According to the [manual page][4], by passing the `-I` flag. + +[^5]: This covers most use cases. 2013 or not, I'm not using fancy stuff such +as multipath TCP, so I have only one active net interface most of the times. I +bet the same holds true for most amateur ping users, maybe even for some +sysadmins. + +[1]: https://en.wikipedia.org/wiki/Neighbourhood_(mathematics) +[2]: http://www.haskell.org/ghc/docs/7.6.1/html/users_guide/ghci.html#ghci-introduction +[3]: http://stackoverflow.com/questions/3589837/what-is-the-significance-of-an-underscore-in-perl +[4]: http://linuxcommand.org/man_pages/ping8.html