Steve, what you’re saying about calling in help from neighbouring frames is theoretically quite interesting – indeed it’s very similar to how mpeg compression works – and Kev it’s true that sometimes the characters are using technology from the future. But frequently what we’re watching is meant to be contemporary and that’s the problem.

The fuckers seize upon one frame and immediately leap into this fantasy world in which benign rows of differently coloured dots have magical properties. No, they are not just rows! Behind each row is another row and then another – and if you pivot left or right there are countless more rows. That’s really the most charitable explanation for the ridiculous visual revelations that occur…

It’s not just that it’s impossible in real life. It’s that everyone knows it’s impossible by now. Maybe twenty years ago a scene like this, served up to us once, wouldn’t have been a problem for our mass suspension of disbelief. But nowadays, so many of us deal directly in the currency of megapixels and image enhancement. A shocking number of us know it’s bullshit. Yet they are still incorporating these moments into cheap drama.

What really galls me is that it’s not even being done out of necessity or practicality – the familiar moment is being written into telescripts and screenplays because writers think it makes for a dramatic moment!

There a lot of things you can say about it but I think Tadhg describes it best as “lazy writing”.

I’ve always thought that this would be great in all sorts of situations, particularly with hidden knowledge, or generally in games for information. Image that with, say, iPads (Or any similar ‘pad/slate’ device)? The information could be updated continuously throughout the game,but without interfering with the actual playing experience. I think the technology is there, similar to the Surface table, but for a more intimate role-playing experience.

I thought about this image enhancement thing too, having been a graphic designer and Photoshop specialist in the past, and of course every time I see this happen in a series or movie I shout at the TV, because I know that you can’t get out more than you put in. You can, by and large, only cleverly remove stuff.

But the Bladerunner scene you’re referring to is different, because the technology is extrapolating unseen images from reflected light, etc – in other words, it’s suggesting that there are ways to build what’s in the image into something more. I actually like the idea very much, and I’m sure it will be possibly in the future; it’s at least creative and not very overblown. Similarly, Star Trek and Battlestar Galactica… Well, in the first, anything goes, and the latter, I seem to remember that it was still more believable than an average episode of CSI, especially considering that they’re battling clones and robots and jumping between star systems. CSI really takes the biscuit but we all know that. I’ve always wondered what people in forensics and medical professionals think of that.

It’s probably not in the scope of today’s technology, though look what amateurs can do by combining multiple images/video to create celestial photography from smaller scopes.

On the other hand, the Blade Runner one was outlandish, though sci-fi gets a free pass on IMHO.

I use BufExplorer most, and a bunch of Python editing aids, probably followed by sessionman.vim, and then NERDTree and snipMate to a significantly lesser extent. Oh, and Bclose.

I kind of always knew I’d move to Vim eventually. I just needed the time to devote to switching over, really. (Although if I’d moved before I wrote all my jEdit macros, the switch to Vim would have been significantly easier…).

Now when you start writing vimscripts and personal colorschemes and so on, post more, because the best tools come of necessity.

Now get into plugins; I personally use TabBar, vcscommand and all the cscope bindings day-to-day.

Welcome to the brotherhood.
:wq

The Wikipedia article doesn’t quite do it justice, something like this: http://afteractionreporter.com/2009/03/13/why-play-dwarf-fortress-heres-why/ does

;whee, Scheme comments start with semicolons
;See findlongestrepeater above, adapted for Scheme
(define (longest-rep str)
  (let ((x (string->list str)))
    ;foldl is python's reduce. it's a functional language staple.
    (foldl compare-blocks '() (contig-blocks x))))

(define (compare-blocks prev cur)
  (if (> (length prev) (length cur)) prev cur))

;Recursive rewrite, python in comments
;def contig-blocks(l):
(define (contig-blocks l)
  ;if l[1:] == []:
  (if (null? (cdr l))
      ;return [l]
      (list l)
  ;else:
      ;r = contig-blocks(l[1:])
      (let ((r (contig-blocks (cdr l))))
      ;if l[0] == r[0][0]:
        (if (eq? (car l) (caar r))
          ;return [[l[0]] + r[0]] + r[1:]
            (cons (cons (car l) (car r)) (cdr r))
      ;else:
          ;return [l[0]] + r
            (cons (list (car l)) r)
            ))))

Note that I don’t wholly agree with your rule for not using assignment operators. As I use it above, it’s merely a shorthand. Anywhere I use “r” as a variable, it could be replaced by the recursive call. And that’s what makes it functional — literally, in the mathematical sense of having one and only one returned value for the same input — time and state invariant, and zero side-effects.

Barak: that looks both interesting and weird… presumably because I don’t have LISP experience. I did expect it to come in significantly shorter than the Python, although I know you said you avoided syntactic sugar.

Dhananjay Nene: Thanks for that suggestion, making a function out of finding contiguous blocks and then comparing them definitely seems like the right way to approach it. I wrote a post about trying to find a way to do that without using the assignment operator.

print reduce(longest,contiguous_blocks(strng),"")

Note: String FP rules would prefer curr = curr + [c] instead of curr.append(c)

strng = 'aasdkjfbbbbdfjdslfaaaaaaasdlkfjcccc'
def contiguous(strng):
    curr = strng[0]
    for c in strng[1:] :
        if c in curr :
            curr = "".join((curr,c))
        else :
            yield curr
            curr = c
    yield curr

print reduce(lambda curr, other : curr if len(curr) > len(other) else other,contiguous(strng),"")