In absence of Twine and it’s expert system, there is a growing movement of people using Gmail instead.

Gmail?

Yes Gmail.

First and foremost, you can use the space of a Gmail account as a place to store files using Gspace. Available space on a Gmail account has recently doubled to almost 6GB.

Using tags and labels, it becomes easy to transform Gmail into a personal database. Automatic tags can be inserted by using this syntax:

username+tag@gmail.com

This will attach the tag to the email in question. Using the filter option, you can find these emails easily. Bookmarks from del.icio.us can be piped through Yahoo! Alerts thanks to the RSS feed and then automatically sent to your Gmail account. Using:

username+bookmark@gmail.com

It is possible to find these bookmarks easily again. This is a way of backing them up. However the tags associated with the bookmarks on del.icio.us are lost this way.

It is also possible to use the Google Toolbar to email to yourself information that you find relevant on the web. At the same time, important documents can be sent to Google Docs for safekeeping.

The new version of Gmail disables this Greasemonkey script, which made it possible to view the Google Reader through Gmail.

Although Gmail doesn’t learn yet, there is a definite possibility that it will do so at some point in the future. Using Yahoo! Pipes further enhances this use.

/*Similar Articles**

1. Twine
2. More on Twine
3. Triple Twine And Comments By Nova Spivack

****************/

Peter Rip, one of the VCs behind Radar Networks, give his own impression of Twine. He doesn’t yet use it to its full potential, however he does mention ways that he sends information to Twine. By sending bcc copies of some emails and by using a Twine bookmarklet.

For Twine to be functional and relevant, it will have to be able to process information from other services like del.icio.us accounts, emails and contacts from Gmail and Facebook friends. Working through those things might be a challenge.

A comment left by Radar Networks founder Nova Spivack about the technology behind Twine and it’s relationship with the DOD:

First, in answer to the question about any potential relationship between Radar and DOD. Actually Radar Networks was never involved with DoD. In fact, the actual history is that several years ago we were invited to be part of SRI’s CALO project http://www.ai.sri.com/project/CALO — which was funded by DARPA – to invent next generation tools for knowledge workers. We were one small group among approximately 400 researchers in around 30 institutions including many of the leading universities in the US. CALO is a “who’s who in AI” — involving many of the leading academics in the nation. Radar Network’s role was very small — we provided a desktop disk-level RDF triplestore and helped with the ontology and user interface work. All the work we did was open-sourced under LGPL and anyone can see it and use it. You can see all the code here: http://www.ai.sri.com/software/IRIS

IRIS is a smart personal information manager for the desktop. Today IRIS may use only very little of the original codebase and I’m not sure how much, if any of our work, survives in the codebase today. It has been many years since we looked at it. You are welcome to look at that codebase and decide for yourself. As it is LGPL it is freely available and open to scrutiny.

In any case, we were just a tiny part of that project. We later raised venture funding from Paul Allen, and we began development of a completely different codebase. Instead of being oriented towards the PC desktop, like IRIS, we focused on building an “Internet-scale” server architecture and platform for the Semantic Web. The codebase we use today is completely different and not related to CALO or IRIS. Whereas IRIS was about exploring a future semantic desktop, Twine is about the semantic web – it is a totally different approach with completely different goals and constraints.

We are in no way affiliated with CALO or SRI, although we remain very good friends with our colleagues from that project — including some of the best ontologists and AI thinkers in the world.

We were honored to be part of the CALO project – one of the most ambitious academic research initiatives in artificial intelligence in years – and it’s wonderful that there is support for big ambitious breakthroughs from our government. After all many of the technologies we now take for granted as the Internet of today were originally funded by DARPA. Similarly, much of the core technologies of the Semantic Web stem from DARPA research, such as DAML + OIL.

But it should be extremely clear that Radar Networks’ codebase and product is totally separate from that past research. Neither Radar Netorks nor Twine is in any way funded by or affiliated with any government agency or program, and our position on privacy is very clear: we believe in the individual’s right to privacy. We also believe in open standards, and open-source. All of our code has been implemented to be potentially open-sourced in the future and while we haven’t decided if that makes sense to do at this time, there is nothing in our code that we are ashamed of or that would compromise anyone’s security or privacy deliberately. In fact many of the coders here at Radar Networks are hard-core open-source folks, like Peter Royal of the Apache Foundation, and Jim Wissner, our chief architect who is extremely in favor of individual privacy. My own personal views on this subject are equally strong. I am a passionate believer in democracy and the rights and protections granted to individuals by the US Constitution. I am very concerned about the present trend towards eroding those rights and as long as I have any say in the matter, I can promise that my company will do its utmost to protect privacy and the Constitution of the United State. Hopefully this has alleviated any doubts about this issue. If not, feel free to contact me and we can discuss this further until you are completely satisfied.

And more:

Regarding the questions about what we have at Radar Networks that is “novel” and “innovative.” There is a lot of new work and intellectual property here. Most of it is related to the Semantic Web platform, the way we do machine learning, the way we enable knowledge management, new ways to improve search results, new ways to do personalization, based on uses of the “semantic graph” we are building. We are not claiming to own the idea of natural language processing (NLP), nor have we patented that. Instead we apply a wide variety of methods including NLP, statistics, graph theory, machine learning, ontologies, in an innovative combination, along with human input and folksonomies. Ultimately we are about open standards, open API’s, and even open-sourcing. This will all be revealed over time. We have been working since 2001 on this. We have a very large amount of code and IP, and over time we will unfold this and release more and more of what we have been working on so that others can play with it. I hope that in the future, when the codebase has evolved further, we can even release an open-source stand-alone version. We’ve done some experiments around that and we have some interesting ideas. I can’t promise that yet because we are not sure it is key to our business model to do it yet — in fact it may just be simpler to focus on being a SaaS (software-as-a-service) business and open the platform via open API’s (which we have and are working on). That is a decision we will make in the future. Regardless of that, for now our mission is very clear: Make Twine an amazing and delightful service for individuals and groups, and then enable outside developers and services to integrate with Twine in numerous ways. For this first phase our focus is really on learning and entering into a conversation with users and developers. I am sure there will many wonderful discoveries and synchronicities along the way, and I guarantee that we cannot imagine them yet. This is a great adventure and we are very excited to be on it, and I look forward to feedback from all of you as we explore this new frontier together.

On future patents:

Regarding our potential future patents, there is a lot of novel IP in our work. It’s not a matter of merely combining existing ideas in a new way. We’ve invented a lot of new stuff especially in the last 2 years, and even quite recently. But who knows what the USPTO will do. I wouldn’t deign to predict that. I’ve seen a lot of patents granted that have absolutely no merit and don’t deserve to exist. I’ve also seen denials of very novel ideas on completely misguided grounds based on examiners not really understanding the domains well enough. There have also been many very legitimate, well-deserved patents. It’s a bit of a chaotic system it seems.

The patent office examiners are overloaded and the entire field of software patent law needs an overhaul. There are too many old patents lying around that nobody is using, making it hard to do anything new without risk of stepping on a landmine. At the same time, the standard for what is patentable is too fuzzy in some cases, and so people try to patent things that just don’t deserve it. There are too many patents being filed and granted.

One solution to the problem would be to make all (past, present and future) software patents have a shorter lifetime — say 4 years max. That would relieve the backlog on the PTO, and would also prevent barriers to progress, competition from innovation that results from dormant patent land-mines lying around. First of all only serious players would bother to apply for a patent if they could only get 4 years of protection. Secondly, if one got a patent, but failed to do anything with it within 4 years, then they would not be able to sit on it and just wait for someone else to sue in the future.

A four-year timeframe would be fair because if an invention is not commercialized and monetized by its inventor within 4 years from being granted a patent in the software space (a long time in our field), then it should be opened up to others. That would really reduce the number of lawsuits (spurious or otherwise), and enable the software industry to flourish.

Software is not like mechanical devices — it evolves much faster. Our present patent system wasn’t designed for software — it just can’t keep up with the pace of software innovation — it was designed for an earlier, more physical-mechanical world. The friction between the pace of the software industry and the intellectual-property process we currently have for it, is actually holding back our emerging new economy. It increases costs and risks for everyone, and reduces the spread and reuse of new ideas. Another area where I feel very concerned is genomics patents and patents around drugs — these are for all intents and purposes very similar to software patents — and it’s very worrisome to see what is going on in that space. When fundamental operations on building blocks of the human, plant and animal kingdom become patentable “inventions” it just seems wrong.

In any case, regardless of my opinions above, I do believe that companies and individuals who invest time and money in inventing things — software or otherwise — should be granted some protection for a limited period of time so that they can have the first shot at monetizing their investment. That’s only fair. Without this protection at least some amount of incentive and investment in early-stage ideas would dry up, and that would hurt innovation and progress just as much as having too much protection.

In any case, until the patent system for software changes (for everyone, equally), then I and my company have to work within the present system. I do believe that our intellectual property is novel, but time will tell. It will probably be many years before we’ll know for sure.

/*Similar Articles**

1. Twine
2. More on Twine

****************/

We’ve discovered a newish article on Read Write Web on Twine. It includes a bit more information about Twine, it’s functions and usability.

Twine was created by RadarNetworks. It’s been in private beta since October 2007. This article gives us a bit more information about the app, but it’s still vague in what it can do. There are a lot of grand goals that they want to accomplish with Twine. Time will tell if Twine will deliver.

Nova Spivack described Twine as a “knowledge networking” application. It has aspects of social networking, wikis, blogging, knowledge management systems – but its defining feature is that it’s built with Semantic Web technologies. Spivack says that Twine aims to bring a usable and scalable interface to the long-promised dream of the Semantic Web.

The aim of Twine is to enable people to share knowledge and information. At first glance it is very much like Wikipedia, but there is a whole lot more smarts to the system. Spivack described it to me as “knowledge networking”- i.e. it aims to connect people with each other “for a purpose”. It’s not based around socializing, but to share and organize information you’re interested in. Using Twine, you can add content via wiki functionality (there are many post types), you can email content into the system, and “collect” something (as an object, e.g. a book object). The screenshots below show of this in action — note that the product itself isn’t available just yet, as it’s in private testing.

Spivack is calling Twine a “Semantic Graph”, which he says will map relationships to both people and topics. So Twine’s Semantic Graph actually integrates the Social Graph. Spivack said that his company has patents pending on this.

From Mashable come these comments:

What I found to be helpful was the contextual manner in which Twine will assess your text, so that Paris Hilton the Person won’t get filed away under your Places (because I’m sure you talk about Paris Hilton all day). This level of automatic intelligence takes a lot of the heavy lifting away from you, catching patterns you may miss for any reason, such as the fact that certain events occur over a long period of time, giving you ample opportunity to forget that two events may be related.

As this also functions as a way to network with others for the purpose of sharing information, there are privacy settings that you can take advantage of, and several ways in which you can build your trusted network, giving you a direct manner with which you can access information you need, from the right people. Twine has informed us of its plans to offer an array of APIs so that its service can be integrated with pretty much every other tool out there, like task list managers, iCals, maps and many more.

There hasn’t been anything new discussed about Twine in the blogosphere or the web since mid October  2007. If anyone has any news about Twine, please feel free to comment or inform us.

Twine aggregates emails, bookmarks, documents, contacts, photos, videos, product info, data records, and more. Twine actually understands the meaning of any information you add in, it helps you organize all your stuff automatically. Finally, you can search and browse everything and everyone you know, about anything, in one convenient place.

Radar Networks Announces Twine.com, A Revolutionary Semantic Web Application, at Web 2.0 Summit

Radar Networks, a pioneer of Semantic Web technology, today announced the invite-beta of Twine, a new service that gives users a smarter way to share, organize, and find information with people they trust. Twine was introduced and previewed publicly for the first time today, at the 2007 Web 2.0 Summit, a Web industry conference in San Francisco. Twine is one of the first mainstream applications of the Semantic Web, or what is sometimes referred to as Web 3.0.

Twine Ties it all Together

Twine is a new service that intelligently helps you share, organize and find information with people you trust.

Share more productively. In Twine you can safely share information and knowledge, and collaborate around common interests, activities and goals. Twine helps you better leverage and contribute to the collective intelligence of your network. Use Twine to share more productively with friends, colleagues, groups and teams.

Get more organized. Twine provides one place to tie everything together: emails, bookmarks, documents, contacts, photos, videos, product info, data records, and more. And, because Twine actually understands the meaning of any information you add in, it helps you organize all your stuff automatically. Finally, you can search and browse everything and everyone you know, about anything, in one convenient place.

Find and be found. You are like a snowflake – you are totally one-of-a-kind. Twine recognizes what makes you special: your unique interests, personality, knowledge and relationships, to help you find and discover things, and be found by others, more relevantly.

Who is Twine For?

Friends. Colleagues. Groups. Teams. Anyone who needs help dealing with the growing array of information and relationships on the Web today. Whether you just need to organize and share with friends, or you need to collaborate better with teams, Twine provides the smartest way to tie it all together.

How Does Twine work?

We thought you’d never ask! Well, in a nutshell Twine uses the Semantic Web, natural language processing, and machine learning to make your information and relationships smarter. But if that’s all Greek to you, just think of Twine as your very own intelligent personal Web assistant, working for you behind the scenes so you can be more productive.

Let’s remind ourselves what exactly an inference engine is:

In computer science, and specifically the branches of knowledge engineering and artificial intelligence, an inference engine is a computer program that tries to derive answers from a knowledge base. It is the “brain” that expert systems use to reason about the information in the knowledge base for the ultimate purpose of formulating new conclusions. Inference engines are considered to be a special case of reasoning engines, which can use more general methods of reasoning.

Pyke is a knowledge-based inference engine (expert system) written in 100% python that can:

• Do both forward-chaining (data driven) and backward-chaining (goal directed) inferencing.
  • Pyke may be embedded into any python program.
• Automatically generate python programs by assembling individual python functions into complete call graphs.
  • This is done through a unique design where the individual python functions are attached to backward-chaining rules.
  • Unlike other approaches to code reuse (e.g. Zope adapters and generic functions), this allows the inference engine to ensure that all of the function’s requirements are completely satisfied, by examining the entire call graph down to the leaves, before any of the functions are executed.
  • This is an optional feature. You don’t need to use it if you just want the inferencing capability by itself.

The knowledge engine supports:

• Multiple fact bases, each with its own list of facts.
• Both forward-chaining rules and backward-chaining rules.
• Multiple rule bases, each with its own list of forward-chaining and/or backward-chaining rules.
• Rule base inheritance — activating the derived rule base includes the rules from the parent rule base.
• The inference rules are compiled into python functions, allowing python code snippets to be used within the rules. This greatly enhances the expressiveness of the rules.

Automatic program generation:

• Calls the generated python programs plans.
• Plans may be run multiple times without needing to rerun the inference rules.
• Plans may be pickled and cached to disk to be used by other programs or in later runs of the same program.
• No pyke modules are required to run the plans.

Potential pyke applications:

• Complicated decision making applications.
• The back-end (code generation and optimization) of compilers. Pyke is used as the back-end of its own compiler that translates rules into python code.
• Automatic SQL statement generation.
• Automatic HTML generation and automatic HTML template processing.
• Automatic program builder to reuse a common set of functions for many different specific situations. This could also easily incorporate a new custom function into a much larger program, where the use of the custom function might influence the choice of other standard functions in other parts of the program.
• The control module for a web framework tool.
• A high-level planner to automatically distribute the modules of a large system over several computers in a distributed system to meet specific performance and capacity goals. This could be used to automatically scale the same system code from a small one program, one computer system to much larger distributed systems to meet a wide range of performance goals.
• Diagnosis systems, including automated customer service systems.
• Program or library customization for specific uses.
• In addition to being able to build programs, pyke can instantiate, configure and interconnect a network of objects to meet a specific need or situation.

Overview

Pyke is an inference engine that applies rules to facts to establish additional facts (through forward-chaining rules), and/or to prove goals and optionally assemble python functions into customized call graphs, called plans (through backward-chaining rules).

Pyke may then be reset, deleting the last set of facts, so that the cycle may be repeated. For each cycle a different rule base may be activated.

The plan capability allows the postponement of code execution until the top-level goal has been completely proven. This shields the code from blind alleys and backtracking within the rules.

Once a plan has been created, it may be executed multiple times with different arguments. It may also be pickled, and later run again without requiring any pyke modules.

Knowledge Bases

Knowledge is made up of both facts and rules. These are organized into named repositories called knowledge bases. A knowledge base is like a directory for files on disk, except that knowledge bases may not be nested. Therefore, facts and goals always have a two-level name.

Here are some examples of facts you might see in a web server application:

header.cookie('session=123456789;remember=the_alamo')
cookie.session(123456789)
cookie.remember(the_alamo)
header.accept_encoding(gzip)
header.accept_encoding(deflate)
request.path('/my/site.html')
request.path_segment(0, my)
request.path_segment(1, 'site.html')
request.path_segment(-2, my)
request.path_segment(-1, 'site.html')

Note that three different knowledge bases (all fact bases) are shown here named header, cookie, and request; each with multiple facts.

There are different types of knowledge bases.

• Those that contain facts are called fact bases.
• Those that contain rules are called rule bases.
• It is also possible to create other kinds of knowledge bases that lookup facts and prove goals in different ways. The only one of these in pyke is the special knowledge base.

All knowledge bases share the same name space; so that no two of them, regardless of their type, may have the same name.

Rules

Premises and Conclusions

Rules have two parts to them: an if part (the premises), and a then part (the conclusions). (Though pyke uses different names for these). Each of these if and then parts contain one or more facts or goals represented by patterns.

Logically, the rule says that if all of the premises in the if part of the rule are true, then each of the conclusions in the then part of the rule must also be true.

Inferencing

Rules are specified individually within a rule base. They are not nested or explicitly linked to each other. So pyke must automatically figure out how to combine these rules to accomplish some larger task. This is called inferencing and there are two different approaches that pyke uses, depending on the rule’s type.

• All forward-chaining rules are processed when a rule base is activated.
  • Forward-chaining rules may assert new facts, and activate more specific rule bases.
• Backward-chaining rules are processed when your program asks pyke to prove a specific goal.
  • These rules don’t assert new facts or activate more specific rule bases. But they do have the ability to assemble python functions into a customized call graph or program, called a plan, to meet a specific need.

Plans and Automatic Program Generation

Once you understand how backward-chaining works, it is relatively easy to do automatic program generation.

Adding Plans to Backward-Chaining Rules

The way this is done is by attaching python functions to the backward-chaining rules. These functions are written at the end of each rule in the .krb file. They don’t affect how the rules run, but are gathered up to form a call graph that is returned along with the pattern variable bindings that prove the top-level goal.

Example

Consider a small rule base to construct programs to transfer money between bank accounts. Each from_acct and to_acct takes one of two forms:

1. (name, account_type)
   • This is a local account with this bank.
   • Example: (‘bruce’, ‘checking’).
2. (bank, name, account_type)
   • This is a foreign account with another bank.
   • Example: (‘my_other_bank’, ‘bruce’, ‘checking’).

At least one of the bank accounts must be a local account.

Here’s the example rule base:

 1  transfer1:
 2      use transfer($from_acct, $to_acct) taking (amount)
 3      when
 4          withdraw($from_acct)
 5              $$(amount)
 6          deposit($to_acct)
 7              $$(amount)

 8  transfer2:
 9      use transfer($from_acct, $to_acct) taking (amount)
10      when
11          transfer_ach($from_acct, $to_acct)
12              $$(amount)

13  withdraw:
14      use withdraw(($who, $acct_type)) taking (amount)
15      with
16          print "withdraw", amount, "from", $who, $acct_type

17  deposit:
18      use deposit(($who, $acct_type)) taking (amount)
19      with
20          print "deposit", amount, "to", $who, $acct_type

21  transfer_ach1:
22      use transfer_ach($from_acct, ($bank, $who, $acct_type)) taking (amount)
23      when
24          withdraw($from_acct)
25              $$(amount)
26          deposit((central_accts, ach_send_acct))
27              $$(amount)
28      with
29          print "send", amount, "to bank", $bank, "acct", $who, $acct_type

30  transfer_ach2:
31      use transfer_ach($from_acct, $to_acct) taking (amount)
32      when
33          get_ach($from_acct)
34              $$(amount)
35          withdraw((central_accts, ach_recv_acct))
36              $$(amount)
37          deposit($to_acct)
38              $$(amount)

39  get_ach:
40      use get_ach(($bank, $who, $acct_type)) taking (amount)
41      with
42          print "get", amount, "from bank", $bank, "acct", $who, $acct_type

Running the Example

The plan is created as a byproduct of proving the goal:

>>> import pyke
>>> pyke.load('examples')
>>> pyke.activate('plan_example')
>>> no_vars, plan1 = pyke.prove_1('plan_example', 'transfer',
...                               (('bruce', 'checking'),
...                                ('bruce', 'savings')),
...                               0)

plan1 is now a program to transfer X amount from ‘bruce’, ‘checking’ to ‘bruce’, ‘savings’.

>>> plan1(100)
withdraw 100 from bruce checking
deposit 100 to bruce savings

The program may be used multiple times:

>>> plan1(50)
withdraw 50 from bruce checking
deposit 50 to bruce savings

Notice the strings: bruce, checking and savings in the output. These were specified as pattern variables in the code and are cooked into the plan along with the function call graph.

Let’s create another program:

>>> no_vars, plan2 = pyke.prove_1('plan_example', 'transfer',
...                               (('my_other_bank', 'bruce', 'checking'),
...                                ('bruce', 'savings')),
...                               0)

plan2 is now a program to transfer X amount from ‘my_other_bank’, ‘bruce’, ‘checking’ to ‘bruce’, ‘savings’.

>>> plan2(150)
get 150 from bank my_other_bank acct bruce checking
withdraw 150 from central_accts ach_recv_acct
deposit 150 to bruce savings

And the final use case:

>>> no_vars, plan3 = pyke.prove_1('plan_example', 'transfer',
...                               (('bruce', 'checking'),
...                                ('my_other_bank', 'bruce', 'savings')),
...                               0)
>>> plan3(200)
withdraw 200 from bruce checking
deposit 200 to central_accts ach_send_acct
send 200 to bank my_other_bank acct bruce savings

Conclusion

So you can see that it quite easy to use pyke to automatically combine python functions into programs!

It also allows data within each python function to be specified using a pattern variable so that pyke can customize these values to match the specific situation.

Most text taken from the Pyke homepage.

Git is a modern distributed version control system focused on speed, efficacy and real-world usability on large projects. More generally, Git can serve as a general tool for directory content tracking.

Git was created by Linus Torvalds with assistance from a loosely-knit team of hackers across the Net. It is currently maintained by Junio C. Hamano.

From the wiki page:

Git is a distributed revision control / software configuration management project created by Linus Torvalds. It should not be confused with GIT (GNU Interactive Tools), a Norton Commander-like file manager created by Tudor Hulubei and Andrei Pitis.

Git’s design was inspired by BitKeeper and Monotone.^[2][3] Git was originally designed only as a low-level engine that others could use to write front ends such as Cogito or StGIT.^[4] However, the core Git project has since become a complete revision control system that is usable directly.^[5] Several high-profile software projects now use Git for revision control, most notably the Linux kernel.^[6]

Git’s current software maintenance is overseen by Junio Hamano. Released under the GNU General Public License, version 2, Git is free software.

I’ve just designed a quick header image and chosen a new theme. More to be posted soon.

To further this aim, I have created a new channel on The Memoirs (Memetics). In this channel, I will also reprint most of my original articles from ViralOne, so that they are all located on one blog.

I have noted quite a few instances of this happening. For the time being, I will just recount my experiences without doing any analysis on them, since I am only the 1st part of my study.

A child’s mind to me is still forming and evolving. They are very beautiful in their directness and the way that they work. They are a perfect medium for viral memes. Depending on the child, the ideas will stick and be transmitted to other children easily, through the simplest of ways.

Case 1: Religion Propagated By A Meme

One of the first cases of this happening was about a little girl called Chloe. (All names are fictional). She was a very religious little girl, and from time to time, talked to other children and teachers about her love for Jesus. She prayed daily and thought it was a very important thing in her life. She usually prayed before eating her meals. Slowly, a few of the other children started praying before their meals as well.

In the most stupefying part of this episode, a teacher had forgotten his key to the classroom. He said he would go downstairs to get it. The girl asked him to wait, maybe if they prayed hard enough, the door would open by the hand of God. They tried and failed, but this is a clear and definite example of this type of phenomenon. A child, firm in her beliefs, influencing the other children to do the same as she does.

And why not?

Maybe if one child thinks it is so important, it might be as important to other children as well.

Does this explain things that we deal with in adult life?

Maybe so.

Fanatics are once such case where such insights can and could provide a lot of clues. How does a sane, normal man suddenly become part of a terrorist cell and is prepared to martyr himself for a cause? What are the factors that form this type of situation, enabling the agents of the meme to target and influence their targets?

Are fanatics brainwashed? Do the memes that have infected their minds take hold and unlike other people, never leave their minds? Do they become obsessed and consumed by them, to the point of being ready to relinquish their lives for them?

How do you profile fanatics like this? Are their ways to counter these memes with counter-memes?

In one of my favorite novels (I have a lot of favorite novels), Snow Crash by Neal Stephenson, the author examines in a cyberpunk setting how language based memes can exist and the theories behind them. Naturally, since they are in a science-fiction setting, they have extraordinary reasons for their existence. Still, memetics is a new field of study that is extraordinarily important in a lot of fields of study, from information technology to marketing.

One of the best recent viral marketing campaigns was for the movie Snakes On A Plane. Bloggers were actually able to influence studio execs, by keeping the name Snakes On A Plane, and suggesting a phrase that Samuel L Jackson said in dialogue, reminiscent of Pulp Fiction.

The studio execs were already thinking that the 1st weekend’s boxoffice would be over 100 million, a great investment since the movie took only 30 million to produce. They were surprised and dismayed to learn that the movie grossed only 15 million in its opening weekend. What went wrong?

One easy explanation is that the new media translates with difficulty into the old media. Bloggers and net denizens and the successful viral marketing campaign were not enough to get good numbers at the box office. Why? Because they neglected their traditional means of getting media attention, the old way through TV ads, movie critics, newspaper ads and etc. To get old media attention, you need old media methods. To get new media attention, you need new media methods.

If the goal was the upcoming release of movie only available online through the studio’s website, then it would have been successful. That is new media. Old media is sitting in a movie theatre. To get that kind of success, you need to reach the right people. Not the blogger in Taiwan. The movie fanatic in North America.

That is why it failed.

This is the old doing the new in a most successful way.

Peter is a 79 year old widower from the UK. He started doing videos for YouTube 2 weeks ago, under the alias geriatric1927. Since then, he has had over 2 millions view of his videos as well as over 22000 subscribers to his feed.

This succeeded in a most successful way.

Chartreuse on the old vs the new.