Team Rubber BlogTeam Rubber talks on the Internet in a blog

Reading through the RubberRepublic blog, I thought I’d point the whole of team rubber at the article on the semantics of the word “viral” when applied to marketing.

This is a very interesting topic to me. With my leniency towards very specific definitions, I’m going to start right from the start, and explain that I’m certainly not a believer in Wittgenstein’s views on natural language.

To me, it’s not unreasonable to define a strict subset of natural language with a single, well defined, 1-1 semantic value function for discussing technical matters (and I believe the definition of “viral” should fit into such a subset), in the same way that we define mathematical terms in first order logic (I’m not going to get into provability here).

i.e. I think that it’s possible, and reasonable, to define the meaning of individual words which are indisputable and fixed when talking in technical language.

For this reason, it really drives me up the wall when two people talk about something, use the same word, but are actually discussing different things.

An example is how we have recently changed the naming for our “Syndicated Ad Units” (Previously “Content Units”).

When we define terms for such a large system, we are effectively defining our own language (or at least the non-common alphabet – technically the set from which words are taken rather than set from which letters are taken). By changing the naming for the system, we have effectively created a second language.

These languages are technically as distinguishable as programming languages are – and switching between requires the same work as switching between programming languages.

Obviously we don’t want too much redundancy in our alphabet, or we end up

• Having to remember a much larger set of nouns
• diverging strongly from a 1-1 semantic value function, which is indistinguishable from the effect of losing orthogonality of the semantic values of individual nouns

To explain the second point, if we mark the semantic value function of a language “I” (for “interpretation”), and we have an alphabet that consists only of the words “abc”, “def” and “ghi”, then if we have orthogonality in semantic values of the nouns, we would have that changing the meaning of “abc” – marked I(“abc”) (though adding functionality to the thing we call “abc”) changes I(“abc def”) in the same way as I(“abc ghi”) changes. It also implies that I(“zyx…wv”) does not change  unless “abc” is part of “zyx…wv”.

We did a very interesting thing while we changed the language used for syndication – we changed which objects have their own names. This changes the set of concepts that can be described with a single word – {I(a) for a in the alphabet}, rather than simply changing the strings used for the objects in the alphabet.

This fundamentally changes the language, and changes the effort required when semantic value functions change (as they always will on a long term software project).

For example, let’s take some of the objects that have changed names (you can see what the semantic values of these names are here):

* “(gadget)” is added internally for this type of Fun Unit.

By enforcing these changes, several changes to the alphabet are implied – firstly the fact that we do not use “gadget” externally creates two alphabets, and hence two new languages – but the aim is to keep one language a subset of the other one.

Previous alphabet:

“Med. Rect.”, “Gadget”, “Content Unit”, “Text Link”, “Text/Image Link”, “Fun Link of the Day”

New alphabet (internal):

“Med. Rect.”, “Fun unit”, “Gadget”, “Text Link”, “Fun Links”, “Text and Image Link”, “Fun Link of the Day”

New alphabet (external):

“Med. Rect.”, “Fun unit”, “Text Link”, “Fun Links”, “Text and Image Link”, “Fun Link of the Day”

Now let’s look at how orthogonal the meanings of these are…

if we suddenly decided to break years of internet tradition and say that a “Med. Rect”  was actually 1024 pixels wide and one pixel high – that would effect all names with “med. rect.” in them equally. In fact, the meaning has not changed at all between the two languages – it defines the size that the syndicated placement will take up on your website.

similarly, the meaning of “Text Link” has not changed (and although we changed the string “Text/Image Link to “Text and Image Link”, the actual interpretation of these strings has not changed).

If you are looking closely though, you will have noticed that “Fun Link of the day Text Link Content Unit” has changed to “Fun Link of the day Fun Links” – this is an important change, since they have the same interpretation, the meaning of “Text Link” has not changed, and yet “Text Link” is not in the new name. This means that this semantic value must be associated with the phrase “Fun Link of the Day” – and so it is. But “Fun Link of the day” is also associated with a size (this is more obvious in the origional naming conventions) This is a many-1 mapping between the old language and the new one, and as such it changes the implied syntax quite dramatically.

Now for the most interesting strings – “Content Unit” has been changed to either “Fun Unit”, or “Fun Links”. This is very clearly a 1-many mapping during the changeover, which again changes the syntax of the language dramatically.

For example, let’s imagine (and this is purely imaginary), we decided to add a feature that (describing the semantic change in the old language) allowed you to “place your content unit in an RSS feed”.

In the old language, we have just updated the semantic value of “content unit”, however in the new language we have updated the semantic value of “Fun Unit” and “Fun Links”. Thus they are non-orthogonal (in fact, in terms of this change they would be parallel!).

For a user (of the language) who understands the new semantic value of “Fun Unit”, they cannot know that the semantic value of “Fun Links” has changed unless they have some prior knowledge about the language.

But how do we describe this intra-linguistical knowledge in the language itself? We cannot say “All content units have …”, because “content unit” is not in the new language. Rather, we would have to state that “Fun Units and Fun Links have …” – but this requires updated semantic values to two strings from the alphabet. This might not seem like much, but by talking in a specific language we actually train parts of our brains to translate from this language into semantics (this was explained by Derek Smith at the Bristol Knowledge Unconference much better than I could explain it). This is an actual change to our brain that we are requiring – and we are requiring two changes in the new language.

To avoid this, we have added another string to the alphabet of our new language – “Ad Unit”. An “Ad Unit” can be a “Fun Unit” or “Fun Links” – but not both – so the interpretation of “Ad Unit” is the common interpretation between a”Fun Unit” and “Fun Links”.

But then if the semantics have remained the same between the two languages, the interpretation of “Ad Unit” must be the same interpretation as “Content Unit” was before…

That would mean that “Fun Unit” and “Fun Links” (both new words) are completely irrelevant words – since they don’t add any semantic information to the language!

Well, to explain this one we have to go back to the reason that we actually replaced the language in the first place. The first language  was defined by myself and Andy as we were thinking over the technical requirements, for use in implementing the systems. The second language came about after our sales and network teams mentioned that they thought users would get confused over the meanings of phrases.

We took this as a sign that we actually had two languages in use already – since there was obviously some concept that was essential to how this second group of people viewed the system that was not a concept to the technical team.

After some very long discussions, this concept had still not appeared to me, but the non-technical users described something that resembled the new language as describing their concepts better. This is a very interesting point to have come to in development terms – since it appeared to be a sign of what the users want to use the system to which is far better than anything that could be got out of a simple user-interview.

After hammering this out for several days, we finalised the new language. The above examples are only a small sub-section, but they are the section that cause the largest change in the allowed syntax of the language.

What was the difference?

Firstly let me quote the definition that the non-technical users decided on for “Fun Units” and “Fun Links” (I would have been far more strict over the definition, but if you’ve read this far then there’s a good chance that you would have as well; we may re-visit this definition):

• “A Fun Link is an Ad Unit into which the Viral Ad Network can place a link to site hosting an asset”
• “A Fun Unit is an Ad Unit into which the Viral Ad Network can insert actual content”

And that seems to be the difference – to me as a developer, there is a difference between the A,IMG,OBJECT,SCRIPT tags etc, – but that difference is contained in the selection between “Text Link”, “Text/Image Link”, “Video Player” (not mentioned previously) and “Gadget” (“Text” can only contain A tags, “Text/Image” can contain A and IMG tags, “Video Player” can only contain an actual video file, and “Gadget” can contain whatever you want).

For a non-technical user, really focusing on “this could be content” is more important – even though you could say that that information is already contained in the language, it’s so important that they want to say it twice.

Hence we’ve got the “old” and the “new” languages describing these things – the old language is cognitively simpler to learn, contains less vocabulary to learn, requires less mental work when new features are implemented, contains a single induced syntactic structure (at least over the vocabulary mentioned here) due to the orthogonality of semantic values, and does not require intra-linguistical “meta-knowledge” to talk about subsets of the language. It also has very low redundancy due to the

The new language has enforced redundancy, non-static syntactical structure, a larger vocabulary, non-orthogonal nouns, and thus has no strict subsets (when talking about Ad Units) that are languages capable of describing semantic updates in themselves. On the other hand, it focuses the mind on what the non-technical users found most important by repeating itself.

As you may have guessed, developers will continue to use the “old” language, and not just because switching over to the new language would require thousands of lines of code to be re-worked.

Tim Wintle

(oh, BTW, My definition of “viral” was brought here)