A+ title after looking up what interregnum means

s for strafe left
d for backward
f for strafe right
rmb for forward

I remapped my controls to this when playing Doom, and have stuck with it for 20 years now...

I've probably had sleep paralysis about a dozen times, always with hallucinations. And always unpleasant ones. The first time I saw a dark figure watching me from my closet simply melt away into my clothes. Another time I opened my eyes to watch a roommate, whom I had a profile view of and was totally engrossed in GTA, transform from a pale demon.

With more experience, you start to realize early in the hallucination process that this could be sleep paralysis. And so you check whether you can move any part of your body, or even scream -- but you can't. You can only control your thoughts. And so you just tell yourself that the hallucination will pass, and ride it out. I don't know how long that takes. Probably only five or ten seconds, but sometimes it feels like a minute.

The birthday paradox a good one. The probability of someone sharing your birthday is approximately 1/365. But if there are 23 people in a room, there is over a 50% chance that two of them share the same birthday.

It's been awhile since I've actually read an ERD, but I've designed databases at multiple startups. Looking at it...

Things that look right:
- a league has multiple seasons
- a season has multiple divisions
- a division has a series of matches
- each match has two teams
- each team has multiple players
- each match has a series of rounds
- each round has a series of events

Things that look a little off:
- Rankings is not really an entity. I'd expect the Teams table to have a NumWins column and a NumLosses column. Whenever a new match (or row in the Matches table) is added, you could increment the appropriate column of each team (or row in the Teams table) in a transaction. The Teams table could even have in a column named WinPercentage that's computed as NumWins/(NumWins+NumLosses). Then you can create an index that sorts the rows in Teams by NumWins or WinPercentage in descending order. This yields the rankings.
- I'd expect each match to have one map, not each round. Assuming that a match is played in its entirety on 1 map.
- Statistics _probably_ isn't really an entity either. When you want to generate the statistics for a match or a round, you'd probably select the appropriate events (or rows from the Events table) in a query, and then apply aggregate functions like SUM or MAX or AVG to get the data that you want.

Things you won't have to worry about depending on where you stop designing:
- It's probably kinda hard to specify the columns of the Events table. Some events have players but no items (e.g. a player changing teams) and maybe even some events have items but no players (e.g. a health pack respawns). The more challenging aspect will be that some events have a lot of associated data. For example, if player1 kills player2, you could store player1 class, player2 class, player1 location, player2 location, player1 weapon, player2 damage. That's six data items associated with simply "player1 kills player2." Do you create a column for each one? Do you do this for each new event you add to the system? This is where we typically give up and have a "payload" column, that is a string, and stores JSON containing any arbitrary data.

On the topic of normalization, this is good. I went through my NoSQL phase and thought you had to denormalize everything. That's premature optimization, and probably isn't the point of this assignment.

Run traceroute (tracert in Windows) and see if there's one hop that's problematic? If so, talk to your ISP, but it may actually be out of their hands if it's with some upstream provider or network.

YouTube has been trash ever since they enabled DASH (Dynamic Adaptive Streaming over HTTP). This prevents the player from loading the entire video as quickly as possible. Instead the player tries to download as little as possible as it plays the video -- and it does this poorly.

The YouTubeCenter extension allows you to disable DASH. You can get YouTubeCenter from https://github.com/YePpHa/YouTubeCenter/wiki. If you're using Chrome, because it's not a signed Chrome extension, you have to drag the .crx file from Explorer/Finder into the Extensions window. Then once it's installed, visit YouTube and go into Settings. Click on the Player tab and then uncheck "Dash Playback."

I know this sounds like some snakeoil, but I swear it works. Now I can watch 720 and 1080 videos with no stuttering. And if it does stutter, I can just pause the video and let the player load it in its entirety.

+1 for requests. Run away from urllib. Far, far away.

There's a lot of good advice here. Throwing in some more that I've found really useful both personally and professionally:

* When things don't work out, don't blame others. This builds this mindset that other people control your fate and that you're a helpless bystander in your own life. If you accept responsibility, then it builds the mindset that you have the power and control to fix the problem. Acknowledging "I created this mess for myself" is painful, but the realization that "and I have the power to fix this mess" is powerful. In a professional setting, acknowledging failure and then fixing your own problems totally blows people away.
* Become comfortable with the idea of failure. Look back on all the times you lost sleep and worried incessantly over something and it didn't work out. Did the world end? No. You lived to worry about something else today. And if this doesn't work out, the situation will repeat itself yet again. Also think of failure as mapping out your personal frontier and testing boundaries. Thomas Edison developed over 10,000 lightbulb prototypes before finding one that work. He said "I have not failed. I've just found 10000 ways that won't work."
* Don't hang around negative people. Surrounding yourself with confidence builds confidence.

Awesome work! Just a note: You're not serving the minified versions of angular.js and socket.io. I don't know if that's intentional, but the human-readable versions are pretty big.

You can see the American Apparel name on the first shirt's tag. They're pretty snug in my experience.

Sunset in LA:

https://scontent-a-pao.xx.fbcdn.net/hphotos-frc1/375590_10101581598695356_400737721_n.jpg

Aaaaand paranoid ice cream in NYC:

https://scontent-a-pao.xx.fbcdn.net/hphotos-ash4/s720x720/392110_10100940331010936_872980211_n.jpg

It's been so long since I've programmed in Scheme. A really good book for learning it is The Little Schemer by Daniel P. Friedman. Don't let that baby playful little elephant on the cover fool you. He will fuck you up.

If you've programmed in an imperative language before, just remember that something like:

int x;
if (y > 10) {
  x = 1;
} else if (y > 5) {
  x = 2;
} else {
  x = 3;
}

turns into:

(let (x) (cond
  ((> y 10) 1)
  ((> y 5) 2)
  (else 3)))

Or something equally ugly. Because you can't just declare, but have to initialize everything. And that every loop turns into recursion.

wat

FWIW I implemented this feature on a custom message board solution awhile back. It may not be as complete as the way Enigma did it, but IIRC, the way I did it was:

Have a table named LastViews, with the columns:

(user_id, thread_id, last_post_seen, timestamp)

(user_id, thread_id)

form the primary key. So when a user views a given thread, we can quickly look up what the last post they saw was, and take them to that. If that row didn't exist, then when they're taken to the first page, and we can insert such a row with the last post on that page and the current time. If that row did exist, but there are more posts now, then we update the row with the last post on the page and the current time. (Basically, we performed an upsert with one SQL statement. I forget the details, it was awhile ago.)

To avoid the table growing too much, we decided to only keep those rows with a timestamp in the last week. So we built an index on timestamp, and basically had a cron job that deleted all rows with a

timestamp < (now - 7 * 24 * 60 * 60)

. This only runs fast if you have the index on timestamp. It wrote out the last time it ran to a log file, along with how many rows it deleted, and then we had the monitoring tool Monit ensure that this really was being updated every hour.

Anyway, not sure if that's how you're doing it, and clearly it's done, but just to throw a solution out there that worked well for us. And props on the constant improvement to the site!

You can prove that it's impossible:

If a room has an even number of doors, then the line doesn't have to start or end in that room. (It can always enter through one door and exit through another.)

If a room has an odd number of doors, then the line has to start or end in that room. (Easy case with one door: Exit through that door. Next case with three doors: Exit through one door, then simply pass through the other two like if the room has an even number of doors.)

But three rooms have an odd number of doors (top left, top right, bottom center), and no line has three ends.

(Edit: Totally missed The2DollarHooker's post. Yeah, what he said.)