skysight-inc/HackerNews huggingface dataset:
90 degree fov was what worked for me (and most shooters I know used at the time). Sorry I didn't clarify that above.

They eventually allowed changing it as a cheat, but it was frustrating for a while .

The community talks a little bit about the differences/issues here:
http://developer.valvesoftware.com/wiki/Field_of_View
There isn't a single good answer to this, all depending on what storage you use, the work you need to do etc. But in general I'd think you want the task to be as granular as sensible, so you can spread the work to many servers. The best thing you can do is to try out, stress-test and benchmark the different ways to do this. As of your description, I'm not even sure if celery is the right tool for the job, but you could join irc.freenode.net #celery to get more information.
They want a rotation representation that:

1) can be accumulated (quaternion multiplication) and interpolated (slerp) 'smoothly',

2) and in a way that does not depend on the absolute orientation.

- Smooth:

If you dive in and start using 3 angles (yaw,pitch,roll) to represent 3d rotation, then the rotations are like the hairy ball - however you order them, there will be values where you can't easily step to another physically very close rotation without a huge change in values - the discontinuities in the hairy ball.

This is classically called 'gimbal lock', where a gimbal mount is a physical manifestation of angle representation. In simulations, it might show itself as strange behaviour when pitched up/down close to 90deg, or an interpolation between apparently close rotations going wild.

By using unit quaternions (4 values), and avoiding the discontinuties (but now having two representations for each physical rotation) it becomes easy to acuumulate the rotations that come from a flight model, animation, user etc. without out ever getting stuck in a corner.

- Independant of absolute rotation:

A related point is that an incremental rotation by multiplying quaternions will always produce the same relative rotation irrespective of absolute attitude. You can see angle based represetnations going wrong when, for example, a camera control system offers buttons that are suposed to be left/right/up/down relative to the camera, but produce varying results as the camera rotates.

It's possible to do the same things with 3x3 matrices - but it is a bit more tricky to keep them normalised over time, and obviously takes more storage. A typical solution to all the above angle problems in a simulation would be to convert (yaw, pitch, roll) to a matrix, accumulate, then convert back. My brief experience of aerodynamics texts is that all the equations are obfuscated with unpicking and rebuilding angles. It's a bit like doing arithmentic with Roman numerals - possible, but painful.
For people who already know all about Python, LLVM, etc the http://code.google.com/p/unladen-swallow/wiki/ProjectPlan page is more informative.
Intro to jQuery Plugins & Testing
As much a joke as the original paradox. I think it's a joke in a very broad sense.
Mnemonic methods where you remember elaborate stories using your own language are actually kind of a bad idea, though the intent is good. The idea is that you remember a concept better when there are plenty of connections with other things in your head. This is true, and this is why mnemonic methods work very well for beginners, especially people who are getting nowhere on their own.

However, in order to become fluent in a language, you need to think in that language, which means you need to build up concept associations in that language. By teaching yourself e.g. English mnemonics when learning Japanese, you are irreversibly tying your Japanese knowledge to your English, and giving yourself a handicap in acquiring fluency.

If you instead remember a word by memorizing a specific use / context of that word in the target language (and add some visual imagery to that for good measure), then this gives you memory associations that will actually remain useful as you become a better speaker. This is why immersion works so well: your entire learning is grounded in the necessity of speaking with and understanding the culture you are living in. If you need to eat, you will develop a food vocabulary very rapidly.

Mind you, I speak about four languages, am fluent in three and grew up naturally speaking two, so maybe my brain is also wired differently than most.
Nice summary.

On finding a problem you'd be happy working on for a few years, he said "fall in love with the problem". I like that.

One of the interviewers asked what source control he used, and admitted that he himself just makes directory tree backups periodically. Peldi spent some time explaining why you should use source control. He himself started with Perforce since that's what he knew, then switched to svn because he's a boring old fart. The cool kids use git or hg.
I would be interested in a write-up of how you do your planning and finances using Vim (format, helper scripts, etc).

I'm mostly interested in your workflow/text file formatting is like.
Wimpy little 50 cent microcontrollers can be servers. I have personally done this.
On UNIX/Linux it is also viewed by many as a modern replacement for Perl

I still have a LOT of perl in use simply because of my hatred of python's regular expressions and I suspect that I'm not the only one...
Su.pr Offers Short Urls With Your Own Domain
Show that this extremely simple sort has sub-cubic expected running time.
Pick two elements at random. If they are out of order, swap them.

How long will it take until the array is sorted?

UPDATE: To turn this into an algorithm, you will need to determine how to check whether the array is sorted.
You might want to flesh out your description a bit more, since it's somewhat generic as is.

Maybe Stackoverflow.com would be a good venue for this type of question.
The GIL has really frustrated me for multiple years. When you're embedding Python into an application, it's really difficult to take advantage of the best multi-core options Python has because those options are all multi-process tricks.

At Pycon last year, when I reminded Guido about the difficulty for embedded apps (that can't fork 200MB processes every time a thread is needed), he shrugged and recommended Jython or IronPython usage.

It's great to see that we'll have this problem solved in a few years. (I assume it will take that long to be production-worthy.)

I'm sure this LLVM integration and change will pretty much break/invalidate all of the embedding API, but to me it'd be worth the rewrite.
Surprised this story was killed. This comment didn't help.
The joy of electronic books
A friend of mine used RtK and spaced repetition to learn those 2000 kanji. The key to his mind was to practice every day without any skips, otherwise he would backslide several days for every day missed. It seems to have been effective for him at least.
"How would these goals be more easily achieved now?"

I feel the guy's pain. Of all technologies we use at our company, the Java folks are the ones that take the longest to deliver a functioning product. I wouldn't be surprised if productivity under Mono/.NET was similarly problematic.

"Or did Microsoft just tick off the open source community and that made him decide to change?"

It's very unlikely Microsoft holds patents that threaten MySQL, PHP, Django, Rails or Clojure users. I would guess their patent-space overlaps quite nicely with Mono.

"F# on mono"

If Microsoft's empty threats scare you or your costumers, F# is not an option.

"I also found the comment about the .exe and .dll file extensions weird."

It _is_ weird. Only Windows uses such an odd convention. I think VMS used something like it. OS/2 too, but it is every bit as dead as we joke BSD is (it is not - I use it - calm down, *BSD people).

"Whatever the criteria, you have to establish them and the stick to them", "Sounded more like somebody just chasing whatever was trendy at the time"

Criteria can change. Rails and Django may be "trendy", but that "trendiness" happened because those who use them can deliver applications very quickly, faster than, say, JSF or ASP.NET MVC - It's derived from real-world results. "ability to easily find programmers" is nice, but if you can't train programmers in a language to make them functional in a week, you are probably training the wrong ones.
I agree, but for the record syntax choice is pretty arbitrary; I find Python quite nice to look at, while Ruby looks like a kludge.
How to built shadow text using CSS
This sounds a lot like BogoSort, which has an average-case running time of O(n * n!), basically exponential. Best-case is only O(n), though:

http://en.wikipedia.org/wiki/Bogosort

There is a variant called Quantum Bogosort, assuming the many-worlds hypothesis, which works like this:

1. Perform BogoSort

2. If the array is out of order, destroy the universe.

This has an average-case running time of O(n) for the universes that survive, at the cost of destroying n! universes. Destroying the universe is left as an exercise to the reader.
It would be great if you could comment on coders coding at night and sleeping during the day or other schedules to optimize productivity. Is this detrimental from a sleep perspective? (I have heard unqualified statements that light affects the amount of awareness when awake/sleeping)
Average case is not that bad actually. Try coding it.
"thousands of inter-depending functions heaped on top of each other."

If you are in this situation, I would suggest a full rewrite with policies that prevent your team from building such a mess.
Edited for wrongness. http://en.wikipedia.org/wiki/Bogosort#Bozo_sort
I had heard of this but not read it before. I'm glad I did, yet IMHO the piece does not deliver on its premise of self-confrontation. It's mostly a series of pirouettes.

It is hard to face such things (e.g. the realization that you no longer value the things you'd built a self around) and harder to write about them, especially if you're a talented writer and a celebrity and people are eagerly eating up whatever you say.

One place that seemed more compelling to me is the second half of part two, in which he dissects his attitudes to life and figures out whom he got them from. But nothing comes of it.
I think the article side steps the value in learning something well by doing it yourself (in the case of the new hire). I appreciate the confidence gained by pair programming and hand holding. But oftentimes even though they were able to be productive with a senior team member, that does not translate to having confidence or being productive when alone. Depending on how the pair worked together, the new team member could have blindly nodded their head. They'll still need to take the additional time to relearn or do it again themselves. In that case, I'd rather pair program to get them ramped up, work on something by themselves, then come back later to review what they've done without side stepping the value in self learning and exploration, which enables them to take ownership of the idea/methodology. Perhaps they'll even have a new approach which is healthy for the team at large.
Technically, though, there aren't any paradoxes here.

The real reason why it is a paradox doesn't have much to do with notion of infinity per se, but with problem of infinite decision aka Supertask.

Which reminds me of an article on physics of supertasks that among other things somewhat outlines how classical theory is more paradoxical before than after quantization http://th-www.if.uj.edu.pl/acta/vol36/pdf/v36p2887.pdf (43pp but easy reading).
This is a good post, Colin.

One thing people reading it may not realize is the importance of picking good IVs and the necessity of including them in the MAC.

Someone might just authenticate the ciphertext and neglect to include the IV, leaving themselves open to a few attacks.
The difference between Bogosort and Bozosort is where the check for sortedness occurs - in BogoSort, you permute the whole array (by swapping individual pairs) and then check to see if it's in order, in Bozosort you swap the pairs and then check to see if it's in order. Amichail didn't specify which one he wanted.
I wont lie, I went straight for the Taylor approximation. According to wikipedia:

"As an iterative method, the order of convergence is equal to the number of terms used. With 2 terms, it is identical to the Babylonian method; With 3 terms, each iteration takes almost as many operations as the Bakhshali approximation, but converges more slowly. Therefore, this is not a particularly efficient way of calculation."

Heh, woops. My second inkling was the way slide rules do it: exponentials and logarithms ( sqrt(n)=exp(.5*ln(n)) ) Turns out that's more on target:

"Pocket calculators typically implement good routines to compute the exponential function and the natural logarithm, and then compute the square root of S"
This is a serious question. Can someone explain to me why higher-level languages like Python, Ruby, and JavaScript can't share a fast VM? It doesn't have to be the JVM or .NET, but why is everybody duplicating so much work? I know the Perl guys were moving in this direction, but nobody else seems to be onboard. Even within Google, they have v8 for JavaScript already.
Infinity doesn't "exist" because the notion of "existence" doesn't apply to mathematical constructs. We don't find them in nature; we use them to describe things we find in nature. The number two doesn't "exist", though there are plenty of things it models well.

There are, of course, things that are described by infinity: the energy required to accelerate a mass to the speed of light, the number of points at which a magnetic field can travel through a surface, etc.
Umm, factorial time generally means that for input sizes about 10-20, the problem essentially can't be computed in the lifetime of the known universe. Sorting 20 elements with BogoSort takes on the order of 46 quintillion operations.
I have to point out that (IMHO) you've taken that quote a _bit_ out of context. If you'll read the rest of my remarks, you'll see the qualification text: I was wrong about eval() in Python however my arguments remain standing in languages which don't support sandboxing - and, as a few readers pointed out, even Python's sandboxing isn't a sure bet. I used Python in my examples because that's where the original disagreement arose.
That probably wouldn't work for me. I learn better by reading (good documentation; failing that, code) than by listening. Conversation can be erroneous, but code (even bad code) never lies. I think optimal learning methods differ from person to person.
It's less than exponential time.
what do you hate about python regexes?
What kind of products am I looking for?

"We could not find any products to match your search :( "

For "netbook".
"Let alone the fact that infinity doesn't exist because we can't observe it."

Do you feel the same way about the complex numbers?
Yeah, diesel used to be terrible environmentally-speaking, but now it's actually very good. They've made big improvements over the years, between engine efficiency and that low-sulfur fuel they use now. That said, they're less convenient in some respects, which is going to be a barrier whether we like it or not.
why ask this question on an article about python possibly moving to LLVM? Rubinius and MacRuby target LLVM as well, for example.
An overlay network protocol like jxta would be perfect for this sort of thing.
Factorial time is not less than exponential time, in a big-O sense. See Stirling's Approximation:

http://en.wikipedia.org/wiki/Stirling%27s_approximation
I agree completely, the notion of the "inscrutable macro" is often brought up when arguing against a Lisp. Whatever one could say is dangerous about macros, I would argue, could be said equally of functions.

But I think something else is going on here, the Inscrutable Macro idea serves as a kind of "intuition pump" (of the negative kind) http://en.wikipedia.org/wiki/Intuition_pump to try and demonstrate macros' badness. If someone isn't very familiar with lisp they'll offer code that's merely not idiomatic, when someone is familiar with lisp then they'll offer up something that's just downright pathological, and I'll be the first to admit, that a pathological macro can be really pathological. At this point, equipped with their executable straw man, they claim "this macro is insane, and so macros are unmanageable."

If the measure for unmanageability is just that impossible-to-understand code can be written in some language then the IOCCC means C shouldn't be used.

In practice the Inscrutable Macro just isn't written.
The notion of existence is applied to mathematical constructs so long as these constructs are abstractions/generalizations of things that exist in the physical world.

The number two is a generalization of quantity. We know there may be two apples or two birds on the wire, and at one point we are taught quantity can be applied to virtually antyhing.

Now, what's infinity? Another abstraction of quantity, which has many definitions. However, every definition you take involves infinite time, e.g. you add 1 to a number ad infinitum or you accelerate a particle to the speed of light, and because reaching precise speed of light is not possible, you will be doing it infinitely.

So even "we use them to describe things we find in nature" - even that is not true. You can't find infinity in nature, neither anything that can be described with infinities.
The Dangers of Becoming a Web Celebrity
The expected running time is sub-cubic.
Daily Routines: How writers, artists, and others organize their days
Why so many dupes lately? http://news.ycombinator.com/item?id=650239

And this one has 15 points...
" I'd like to warn you though, that because I'm more or less familiar with the subject, I think it will be very difficult to find what I'm asking for."

Cool. Rather than posted challenges, how about educating us to why we are wrong. If you know this area well I'd be interested to learn more.
It's difficult to explain what it is, precisely, about python RegExes that make them awkward, and perhaps if I had never encountered the syntatic regex sugar that is perl, I would have never noticed. But, as a total python advocate and frequent writer of python scripts - I still find my brain hitting wait-states that don't occur in perl when I need to pattern match. I can live with that because of the 50+ things that make python so much better (for me) than Perl (Hash of Array / Array of Hash at the top of the list) - but it's sad that I still don't regex in Python as fluidly as perl.

I think the first hint that Python wasn't developed with RegEx users in mind would be that in the 700 Page "Learning Python, 3rd Edition" - Regular expressions aren't even mentioned in the Index.
What do I feel about the square root of -1? I love it. I don't think though it has the same existential significance as infinity. I may be wrong though.
Pocket calculators typically implement good routines

Yeah, they are accurate, but don't need to be fast. The blink of an eye is a long time.
Air France pilots faced a cascade of failures
They don't have a monopoly. You are free to use other VoIP apps or create your own.
its pretty standard, and working with e-commerce for a while now.

In what area of "e-commerce" is that standard and working? I don't know of any but I know at least one where DRM was tried and failed miserably (music distribution).

Moreover I can only repeat that DRM is technically infeasible for images because the images need to be displayed on the clients screen. When your eyes can see it then the lens of your digicam can also see it. Get it?
Can you explain the difference between i and inf? What do you see as the difference in existential significance?
Why not just write a program that can convert any program written in one language to any of the others? It is basically the same problem and about the same level of difficulty.
Fourier Transform as applied to MRI. The underlying theory of Fourier Transforms involves integrating from -inf to inf. The transform is used to extract the underlying waveforms from the signal received by the MRI machine.

Since the MRI machine only samples the signal coming in it uses a DFT, but that doesn't negate the fact that the theory of Fourier Transforms involves the notion of infinity and that engineers used that body of mathematics to build a real machine.
I learned French in one year by hooking up a mic/mixer to my laptop (so that I could easily hear myself speak) and watching French DVDs with French subtitles, pausing after every sentence and repeating what was said.

I'd rewind the film and switch to English subtitles when I didn't understand a phrase. It takes about 6 hours per film at first, but becomes faster and faster as you learn more vocabulary/grammar and get used to the process.

It's best to use real French films, because it's important that the actor's mouth movements match their voice, especially when they're speaking fast.

I live in Paris now, and speak French fairly well with no American accent.

I also read bilingual books and memorized songs on the bus (pasted the lyrics into iTunes so they'd show up on my iPod when listening to the song).
I've only heard good things about Volkswagen and diesel engines in the past year or so. What are the downsides do it?

Is it better for someone looking to buy a car in the next 2-3 years to just wait out for a hybrid or is diesel/gas here to stay for a lengthier time?
A few comments earlier there was a challenge:

The engineers who designed these systems all made frequent use of the notion of infinity

and I'm yet to see the proof.
I successfully registered a 5-character name within 10 seconds of the launch, so if there were a bug it wasn't simply refusing strings of 5 characters.
> Edit: a theory that involves infinities.

Asymptotic analysis of the computational complexity of algorithms.
I spent two full days with my (soon to be) girlfriend writing Scheme for a college assignment using two keyboards and mice on a big desk.

It was awesome and not only because of the sparks.

Her ideas worked, but were complex.
I typed faster, but my solutions were incomplete.

So we attacked the problem from two sides and it had to surrender.

The code that emerged was beautiful, clean and bug free.

I'm still trying to get her to code with me again :)
It probably has a lot to do with my lack of programming knowledge (I've never taken any formal programming classes [err...I took java in college but never actually went to the scheduled class because it was a lot of covering what these cRaZy things called variables were])...

A replacement on python looks like this...

foo = re.compile("<")
bar = foo.replace("&gt;", bar)

this works, but it just feels less awkward to me than

$bar = s/</&gt;/
Link to single page:

http://www.latimes.com/news/nationworld/world/la-fg-brazil-a...
This guy seems a little overly-desperate. I mean, $100? Really? Is a vanity URL worth that much?
The mnemonic method being referred to is aimed as specifically learning written Japanese. It is not about learning words. It's about learning kanji.

The problem is that Japanese has the most complicated written language in the world. It has two alphabets and a set of many thousands of symbols (kanji) borrowed from Chinese. Learning spoken Japanese is an entirely different undertaking than learning written Japanese.

You can be completely fluent in Japanese and still not be able to read a newspaper (this may actually be more common than not).
Live Times Wire
Look up the "Parrot" VM. That seems to be their goal.
IPhone Development: OpenGL ES from the ground up
LLVM isn't so much a VM for those languages to use directly as a portable assembly toolkit.

It's too low level to do compile to directly. It'd occupy a place in the stack somewhere near assembly, but with an optimizer in place. It's more of a VM toolkit than a VM itself.
Tbh what is really needed is optimized message passing ala the actor model. It is a leap forward and avoids a lot of problems that threads face (subtle concurrency bugs).