Skis / Toys / Fun

Quick background — one of my day jobs is being a ski instructor in the winter and in the process of getting my certifications have learned a bit about the teaching model and ways people learn.  Thus ended up having this interesting realization the other day while chatting with my brother.

People learn in three primary ways (the Fleming VAK model):

• Visual — see it written, slides
• Auditory —  lecture, discussion
• Kinesthetic — move it, touch it, do it

Without going into blending, or some other theories of learning, since I’m preferential to VAK and how it relates to ski instruction (another topic another day).  The big thought that I had was that the big change in recent years (last 10) is that teachers are teaching with powerpoint.

Why do I feel that powerpoint is bad?  Lets think about this for a second, if we subscribe to the VAK model of learning.  That means that to successfully retain something you need to do one or more of the VAK steps to imprint the learning into your memory.  If your instructor hands you a deck of slides, now instead of coping the key points of the lecture you’re just reading them.  Which to a kinesthetic learning is a loss.

To a visual learner, this might be a boon, but at the same time I personally doubt that a visual learner has a photographic memory.  The process of a professor writing things down is going to give the visual learner some time to process the input given rather than potentially memorize a slide.

Finally the auditory learner, at one side probably no change, but at the other, since a PPT deck is so structured in flow there is no tangents or discussion that’s quickly available.  So, if somebody asks a question, instead of going with “lets cover this now” it’s hold that though and in five slides we’ll touch on it, if you still have questions ask then.

Generally, too much structure doesn’t allow for the process of discovery and the ability to reinforce material through multiple means of learning styles (VAK).

Just finished up a quick one day project…  Was curious about Torando and since I’ve been playing with Django wondered about mixing the two…   Of course at one level there isn’t much reason to put django and tornado together since django has a “fine” webserver built in and Torando is all about async.

Thus you need to invent an app that requires async, traditional http chat with long polling is the trick.  So, pulling a demo from the NodeJS land and building a bunch of glue work I ended up with a working Django+Torando = Chat application.  Sorry there is no demo, since it looks and works pretty much like the NodeJS chat application (borrowed their UI and JS).

However if you want to check out the code take a look at this:

http://github.com/koblas/django-on-tornado

The key part that’s interesting is this ability to add asyn requests to a django handler:

from django_tornado.decorator import asynchronous

@asynchronous
def recv(request, handler) :
    response = {}

    if 'since' not in request.GET :
        return ChatResponseError('Must supply since parameter')
    if 'id' not in request.GET :
        return ChatResponseError('Must supply id parameter')

    id = request.GET['id']
    session = Session.get(id)
    if session :
        session.poke()

    since = int(request.GET['since'])

    def on_new_messages(messages) :
        if handler.request.connection.stream.closed():
            return
        handler.finish({ 'messages': messages, 'rss' : channel.size() })

    channel.query(handler.async_callback(on_new_messages), since)

Part of this post is the gratuitous, gosh that was easy to integrate!  Of course part is a small point that I would like developers to think about.

First off here’s the code snippet, which owes it’s history to:

Zendesk Remote Authentication with Django and Unicode Names and Zendesk remote authenticatin with Djnago (the original posting)

def authorize(request):
    if not request.user.is_active :
        return HttpResponseRedirect(reverse('openauth:signin'))

    try:
        timestamp = request.GET['timestamp']
    except KeyError:
        raise Http404

    u = request.user

    data = ''.join((u.profile.name(), u.email, u.username, settings.ZENDESK_TOKEN, timestamp))
    hash = md5(data.encode('UTF-8')).hexdigest()

    url = "%s/access/remote/?%s" % (settings.ZENDESK_URL, urllib.urlencode({
                'name'        : u.profile.name(),
                'email'       : u.email,
                'external_id' : u.username,
                'timestamp'   : timestamp,
                'hash'        : hash,
            }))

    return HttpResponseRedirect(url)

What’s different — or why am I making this post:

• Use u.get_full_name() rather than the appends with the spaces, in my case I’ve got another object hanging out (profile) which contains the users name.
• Use the django username as the external_id — I though about using user.id, but since username should be unique and fairly inflexible that’s a good approximation.
• Use a join rather than a whole bunch of “%s%s%s%s” no formatting needed…

Finally, the big rant the original code used a bunch of formatted prints to build the URL argument.  If you’ve been handed a language with libraries like python and a framework like django, you don’t think about cross site scripting or other breakages (& in the username) which is going to cause problems…. It’s trivial to use urlencode to avoid these problems.

I just read a post talking about the “Does your startup pass The Sleep Test“, in principal the idea is sound it’s a little simplistic.

Fifteen years ago I worked as a consultant, the money was good but the problem I quickly realized is that fundamentally I was just trading time for money.  We can all see how a construction worker trades time for money — $15/hour here I come I’ll hammer and pour concrete all day.  Being a ski instructor is the same way, just like any trade job you’re just on the work for X hours get Y dollars, but you have to wake up and do it all again…  What’s funny is there are a lot of white collar jobs that are the same way, Lawyer is being a great example — hence why many people are slaving away on the partner path — then at least they get the benefit of their co-workers time.

Fundamentally, you need to build a business that for every hour you put in yields a % gain in a core asset.  That asset can then be realized in a few different ways.

• A blog — you post frequently — have a regular readership that grows and advertising to support it.  This passes the sleep test, people read while you’re asleep, but at some point to grow you need to be a publisher (e.g. TechCrunch) because if you don’t and go on vacation your asset will decrease in value.
• A piece of software — you or a small team builds a piece of software and sell it, you potentially can sell the software for many times the cost of development.  If done right you can build service contracts and upgrades that yield long term revenue on your customers post sale.
• Software as Service — similar to above, but now you can charge on a reoccurring basis, though fundamentally this is really just shrink wrapped software with the support side built into the monthly charges.  Variants on this are advertising supported web apps. etc. etc.
• Secondary assets — you build a widget give it away for free, but fundamentally you’re building a secondary asset that you hope to either data mine or sell directly.   When you signup for that free car at the mall, the offer is the car, but the company is now getting access to your contact information to both sell you a timeshare but also now they’ve got Name/Address/Phone/Email all in a nice neat package..  Plus as a “Are you interested in a Timeshare” phone call you can verify all of the information.

Once a business has an asset, Readers/Customers/Core Asset it now has something to grow and foster.  This is asset is then what the business should be organized around the care of.