beoba's comments

Arbitrary illustrative excerpt:

Whether American or Chinese, individuals who focus too much on ‘achievement,’ and who believe the illusion that they’ve achieved everything simply through their own honest hard work, often think very little of everyone else as a result.

In other news, Buggy Whip Owner Considers Cars Harmful (Possibly Evil).

Does anyone know of a way to just turn this off entirely? I already have things organized by directory/filename. From what I can tell, the current 'solution' is to manually go through each file and fix whatever stupid information was auto-detected. Which is backwards, because if someone's anal enough to deal with that, they've likely already got things meticulously organized how they want by directory/filename, so why not just go by that directly?

I get the strong impression that they didn't really make local media playback a priority.

They could work out a process for developers who want to contribute GPLed apps, but they've decided not to.

Let's say you've got two lists, named "A" and "B", which each have 1000 integers. You want to return a list of unique integers which are present in both lists (ie the intersection of two lists). These 'lists' could be arrays or linked lists.

The brute force method would be something like this:

  Out = []
  for a in A:
    for b in B:
      if a == b and !Out.contains(b)://O(n) list search
        Out.append(b)
  return Out

---

A better way is to sort one or both of the lists then do the comparisons along each of them (this syntax assumes the lists are specifically arrays, but it'd effectively be the same for linked lists):

  Out = []
  sort(A)
  sort(B)
  b = 0
  for a in xrange(len(A)):
    vala = A[a]
    valb = B[b]
    if vala == valb:
      Out.append(vala)
      ++a
      ++b
    elif vala < valb:
      ++a
    else://vala > valb
      ++b
  return Out

Not bad, definitely better than what we were doing before. But we might be able to go a little better...

---

Yet another way is to use some hash sets, which (generally) have O(1) insertions and retrievals, and only store unique values, such that if you insert the same value twice, the second insertion is effectively ignored. We can do something like this:

  Out_set = set([])
  A_set = set([a in A])
  for b in B:
    if A_set.contains(b)://O(1) set search
      Out_set.append(b)
  return list(Out_set)//optional, could return Out_set

---

So just by using our knowledge of data structures, we've turned ~1000000000 iterations into ~2000-3000 iterations. This is on the order of reducing the distance to the moon to around a kilometer. And that's just with two lists that are limited to 1000 items each.

And this sort of thing is a pretty common scenario in any language, no matter how 'abstracted' it is.

Understanding algorithmic complexity and knowing which data structure(s) to use to solve a given problem are universal skills.

This setup rapidly turns into a series of kludges to make the thing work.

All that's missing is a smug logo, and it'll be a hit!

(also mentioned in the article)

Otherwise it's just "task add something", "task list", "task done something".

And if you do find yourself wanting to use those "bells and whistles", they're just a man page away.

"BlackHat Europe 2010 - Changing Threats To Privacy From TIA to Google"

Additional nitpick: Employment statuses are generally determined at the state level.

I think a good solution to this situation is to in turn request the screener/interviewer's credentials. After all, it's no big deal right?