beoba

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?

Example: http://www.thedenverchannel.com/news/26164101/detail.html

Still smugly using my Translink-branded card.

"Oh wait, this machine has foo 1.5.2, not 1.5.6!!!"

Though a solution to this scenario is to avoid including too many libraries in the standard distribution in the first place, so that incompatible changes in those libraries don't affect the base.

This in turn means that big packages with lots of dependencies would need to say "you need fooliba-1.5.6, foolibb-4.3.2, etc" instead of just "you need foo-5.2", but other languages do this and they seem to manage it alright.

Also, actual tutorial links are:

Part 1: http://blog.hawkhost.com/2010/06/28/tmux-the-terminal-multip...

Part 2: http://blog.hawkhost.com/2010/07/02/tmux-%E2%80%93-the-termi...

Obligatory wikipedia background:

"WELL membership is available to almost anyone, but requires a paid subscription and use of one's real name."

"The WELL was frequently mentioned in the media in the 1980s and 1990s, probably disproportionately to the number of users it had relative to other online systems. [...] This early visibility was largely the result of the early policy of providing free — comped — accounts for interesting journalists and other select members of the media. As a result, for many journalists it was their first experience of online systems and, later, the Internet, even though other systems existed."

Not much happened with them, either.