Nomura's Jellyfish. Picture by Kenpei at the Osaka aquarium. GFDL license.
Nomura’s jellyfish, a species frequently encountered in Japan and China, is one of the largest in the world. The body can reach a diameter of 2 m. Since they create big problems for the fishing industry, Japan has now sought China’s help on the issue. It is thought that a recent proliferation of the species, huge swarms appearing every year since 2000, originates at the mouth of the Yangtze river.
Evolution can do fascinating things sometimes. Upon reading about this, a doubtlessly romantic and delusional notion entered my mind. What if the sea ecosystem, or a subset of it, say 10-100 species, perceive the human fishing industry as a threat that needs to be defended against, and in response create an evolutionary niche where a new kind of species can thrive, a species whose only purpose is to obstruct fishing? A romantic notion since it plays off the mythical idea that human beings are at war with nature, or that nature is good and man is evil, something I don’t really believe in. But an interesting one nonetheless. Is such a development possible?
A cold, bright morning in Tokyo’s somewhat fashionable Azabu-Juuban district. I’m looking for a clinic, but I can’t find it. I’ve only visited it once before, more than a year earlier. I look for landmarks that I might remember, bring out the map on my phone, pay attention to every detail in the hope that I will recognize something.
The morning has turned into a game. It’s me against the city layout, me against my memory, me against entropy and the temporal degradation of my cognitive faculties. The ludic dimension has entered my life again. And soon enough, I find the place I was looking for.
When we have a sense of competition, that a victory against something or someone is possible, our awareness of life is heightened in every way. We pay more attention, we notice more, we become more here and now. The endless simmering chatter in our heads, nearly meaningless thoughts that usually refuse to yield anything meaningful, gives way to absolute focus.
It occurs to me that a society where everyday tasks can be carried out like they are games, victories to be won, might be a more moral society, with greater happiness and life awareness for everyone. In such a society, even if you lose a particular game, you win something else.
In his first amendment to Human, All Too Human (1886), entitled Miscellaneous Maxims and Opinions, Friedrich Nietzsche states that
300. HOW FAR EVEN IN THE GOOD THE HALF MAY BE MORE THAN THE WHOLE. — In all things that are constructed to last and demand the service of many hands, much that is less good must be made the rule, although the organiser knows what is better and harder very well.He will calculate that there will never be a lack of persons  who can correspond to the rule, and he knows that the middling good is the rule. — The youth seldom sees this point, and as an innovator thinks how marvelously he is in the right and how strange is the blindness of others. (Helen Zimmern transl.)
Friedrich Nietzsche did not describe software making – I can only assume that he was describing authors and ideologists – but this seems to capture the difficulties of software development only too well. And it seems to give a recipe for how to overcome the communication difficulties (abandon exotic, over-refined solutions and focus on an easily understood middle ground, so that everybody can get together and comprehend the architecture). This was originally published in 1886.
With that, merry christmas!
In the chilly yet sunny winter afternoon, I took a walk past the imperial palace in the centre of Tokyo. I find sunny winter days refreshing.
The palace is interesting to behold. It is fronted by lots of that most precious of Tokyo commodities, open space. Supposedly, during the height of the land bubble, the land on which the palace is built was worth more than the state of California. This is in turn surrounded by some of Tokyo’s most prestigious office buildings in the Marunouchi and Hibiya districts. Tokyo station is just a few minutes away on foot.
The scene is one of juxtapositions. Open space meets tightly packed high rise buildings. Traditional Japanese architecture counters sleek office buildings. Yet this  never feels contradictory, because there is an underlying theme of restraint and control.
As you might expect from a royal residence, the public courtyard is immaculate. The grass is so well cut and even as to resemble a golf course. The trees on the lawn are of uniform height, lushness and distance from each other. The gravel is supremely even.
The office buildings are similarly controlled: shades of grey and brown, a certain minimalism and homogeneity in design that is easier found here than in Europe, the sense that unnecessary detail has been removed.
There is a sense of power in all this; a will and a shared set of ideas that have been realized to a high degree. The homogenous, flat skyscraper with a grid of windows is the triumph of human, platonic ideas over the organic and the irregular. The palace garden is man’s will taming the uncontrolled vegetation we find in nature. Yet such control is always a question of scale. We can cut and prune the trees, but we cannot control the color of their leaves or the exact angle of every branch. And we can cut and prune the buildings, but generally, we cannot control the shape of the overall skyline in detail. Something organic manifests itself in the multitude, even as some parts are controlled.
Power and rebellion, in constant struggle and symbiosis.
The Scala collections library (in version 2.7.7) has a MultiMap trait for mutable collections, but none for immutable ones. I hacked something up to use while waiting for an official version. I’m finding this to work well, but I don’t have much experience with collections design, so it’s likely to have some flaws. Also, this is a class and not a trait, so you can’t use it with any map you like. And from a concurrency perspective, maybe it’s sometimes better to use backing collections other than the HashSet and the HashMap.
import scala.collection.immutable._
/**
A multimap for immutable member sets (the Scala libraries
only have one for mutable sets).
*/
class MultiMap[A, B](val myMap: Map[A, Set[B]]) {
def this() = this(new HashMap[A, Set[B]])
def +(kv: Tuple2[A, B]): MultiMap[A, B] = {
val set = if (myMap.contains(kv._1)) {
myMap(kv._1) + kv._2
} else {
new HashSet() + kv._2
}
new MultiMap[A, B](myMap + ((kv._1, set)))
}
def -(kv: Tuple2[A, B]): MultiMap[A, B] = {
if (!myMap.contains(kv._1)) {
throw new Exception("No such key")
}
val set = myMap(kv._1) - kv._2
if (set.isEmpty) {
new MultiMap[A, B](myMap - kv._1)
} else {
new MultiMap[A, B](myMap + ((kv._1, set)))
}
}
def entryExists(kv: Tuple2[A, B]): Boolean = {
if (!myMap.contains(kv._1)) {
false
} else {
myMap(kv._1).contains(kv._2)
}
}
def keys = myMap.keys
def values: Iterator[Set[B]] = myMap.values
def getOrElse(key: A, elval: Collection[B]): Collection[B] = {
myMap.getOrElse(key, elval)
}
def apply(key: A) = myMap(key)
} |
import scala.collection.immutable._
/**
A multimap for immutable member sets (the Scala libraries
only have one for mutable sets).
*/
class MultiMap[A, B](val myMap: Map[A, Set[B]]) {
def this() = this(new HashMap[A, Set[B]])
def +(kv: Tuple2[A, B]): MultiMap[A, B] = {
val set = if (myMap.contains(kv._1)) {
myMap(kv._1) + kv._2
} else {
new HashSet() + kv._2
}
new MultiMap[A, B](myMap + ((kv._1, set)))
}
def -(kv: Tuple2[A, B]): MultiMap[A, B] = {
if (!myMap.contains(kv._1)) {
throw new Exception("No such key")
}
val set = myMap(kv._1) - kv._2
if (set.isEmpty) {
new MultiMap[A, B](myMap - kv._1)
} else {
new MultiMap[A, B](myMap + ((kv._1, set)))
}
}
def entryExists(kv: Tuple2[A, B]): Boolean = {
if (!myMap.contains(kv._1)) {
false
} else {
myMap(kv._1).contains(kv._2)
}
}
def keys = myMap.keys
def values: Iterator[Set[B]] = myMap.values
def getOrElse(key: A, elval: Collection[B]): Collection[B] = {
myMap.getOrElse(key, elval)
}
def apply(key: A) = myMap(key)
}
Usage:
var theMultiMap = new MultiMap[String, Int]()
theMultiMap += (("george", 1))
theMultiMap += (("george", 3))
theMultiMap += (("bob", 2))
theMultiMap -= (("george", 1)) |
var theMultiMap = new MultiMap[String, Int]()
theMultiMap += (("george", 1))
theMultiMap += (("george", 3))
theMultiMap += (("bob", 2))
theMultiMap -= (("george", 1))
