It has been something that has been going on in my head for a significant amount of time and I believe that it is the right time for politicians and famous individuals to take their online reputation management as seriously as the offline one. Here, i will outline a very basic strategy that i believe will equip celebrities and politicians to strengthen their brands.

So lets start with some assumptions that will make our lives easier as the post goes on.

• Paid advertising stand-alone is not an effective way of reaching out.
• A holistic or integrated approach towards internet marketing is what will allow long-term gains.
• Like most blog posts, this is highly subjective. Feel free to improve, argue, debate any points.

So with this initial setup we can charge into how a politician X can become an online brand.

Goals

To plan for the next coming elections, which means that it has to be a sustained campaign over the next 2-3 years to make a meaningful impact.

It also has to ensure that he remains at a peak during his election times, and is able to sustain public interaction at a locality level.

Mechanisms available

We all seem to assume that social media, by default is the internet. In a country with nearly 430 million wireless connections, a strategy also needs to address the offline, but mobile populace.

So here is a list of potential ways of reaching the user using social media

• Internet – Blogs / content
• Mobile (SMS, MMS or GPRS)
• Internet – Social networks
• and many more …

The list can go on, but it is all dependant on the target audience which may be some remote district in West Bengal (India).
Why ? Why not ?

“One does not fit all”, and that is the reality. I would love to use social media to create and enhance everybody’s reputation. For an example, an MLA from a remote bihar village has no use for social media in his political career (unless of course he has national / state level ambitions).

Cosmopolitan cities like kolkata, Delhi, Mumbai, Chennai, Bangalore have all shown that the internet may emerge as a potentially important mechanism for party propaganda as well as reputation management.

So if you guys want to have a chat with me discussing this further, do comment or email me at me@dipankar.name.

When you are using a platform like django you realise how slow sessions can get when you are using the database as a backend. The problem of using a memory cache like memcached is the fact that when you restart the server to refresh the cache or remove stale objects, the problem is that you lose your sessions data and a lot of people using your site get logged out. The only solution to this problem is to use 2 memcached instances , one for your regular python objects and another for your sessions objects … this is not a default feature in Django. So here is the solution to this particular problem.

In your project directory create the following files, the first file is basically a copy of a core django file (contrib/sessions/backends/cache.py) and the second is a file where the class gets initialized (its not necessary , but a good example).

from django.contrib.sessions.backends.base import SessionBase, CreateError
from kwippyproject.session_cache import cache

class SessionStore(SessionBase):
    """
    A cache-based session store.
    """
    def __init__(self, session_key=None):
        self._cache = cache
        super(SessionStore, self).__init__(session_key)

    def load(self):
        session_data = self._cache.get(self.session_key)
        if session_data is not None:
            return session_data
        self.create()
        return {}

    def create(self):
        # Because a cache can fail silently (e.g. memcache), we don't know if
        # we are failing to create a new session because of a key collision or
        # because the cache is missing. So we try for a (large) number of times
        # and then raise an exception. That's the risk you shoulder if using
        # cache backing.
        for i in xrange(10000):
            self.session_key = self._get_new_session_key()
            try:
                self.save(must_create=True)
            except CreateError:
                continue
            self.modified = True
            return
        raise RuntimeError("Unable to create a new session key.")

    def save(self, must_create=False):
        if must_create:
            func = self._cache.add
        else:
            func = self._cache.set
        result = func(self.session_key, self._get_session(no_load=must_create),
                self.get_expiry_age())
        if must_create and not result:
            raise CreateError

    def exists(self, session_key):
        if self._cache.get(session_key):
            return True
        return False

    def delete(self, session_key=None):
        if session_key is None:
            if self._session_key is None:
                return
            session_key = self._session_key
        self._cache.delete(session_key)

from django.core.cache.backends.memcached import CacheClass
from django.conf import settings

scheme, rest = settings.SESSION_CACHE.split(':', 1)
host = rest[2:-1]
cache = CacheClass(host,{})

SESSION_ENGINE = "kwippyproject.session_backend"
SESSION_CACHE = 'memcached://127.0.0.1:11200/'