vault_

Things like NumbaPro[1] and OpenACC[2] are going to go much further towards making gpu programming more mainstream than a lisp dialect.

NumbaPro is a python library that let's you JIT python into CUDA or CPU vector extensions via decorators.

OpenACC is similar (or possibly developed out of) OpenMP in that it takes a directive driven approach to accelerating code. Given a loop you can add a pragma above it with instructions of how it should run a GPU and it will make it happen.

[1] http://docs.continuum.io/numbapro/ [2] http://www.openacc-standard.org/

EDIT: I forgot to mention that I believe we'll be seeing less writing of GPU code directly and more using of libraries that do the hard work for you. Some algorithms on GPUs are quite tricky to get right, and even with a language that makes them easy to express they are non-trivial to design and test. (Nvidia already provides Thrust with cuda which provides a nice STL like library that implements a lot of common routines)

[3] http://docs.nvidia.com/cuda/thrust/

> Use a model to guide research.

This I'll concede. I misinterpreted your point and tone as "don't rely on anything you haven't already measured". I would also agree that it's rather grating to read things that say "X totally happens (according to model Y)". But I don't think that it is inherently bad for one to say "Model Y predicts X".

> No. It started as a model (or idea), but every single step was confirmed using the actual world, and not a model.

This however, I do disagree with. It's still a model. It wasn't "confirmed"; it was "not disproven". Physics will always be a model. I don't see the problem with saying "this model turned out to be wrong so we need to come up with a better one" (exactly what's happening in the article). A large number of important breakthroughs in physics were from scientists demonstrating the failures of models or running into them accidentally (see caloric theory and the Michelson–Morley experiment).

If you were to be sending a probe to the edge of the solar system, what exactly would you use to plan and predict its journey if not models then? Would you wait until you have a way to measure what happens at the edge of the solar system before sending out your probe to measure it?

The entirety physics is essentially a model. If you want to completely know everything before you start trying to do anything, you'll get anything done.

That's not a debugger though; that's a compiler.

All of the debuggers I've seen are line based with the option of single stepping through assembly.

Hopefully the LLDB people will be able to modernize debugging to the degree that the clang guys have modernized error messages, but that still remains to be seen.

Mueller wasn't saying that it wasn't done intentionally. He was saying not to assume that its removal had been maliciously hidden.

I would argue your solution is exactly backwards.

The job of the compositor is to draw a window how it asks to be drawn. The window in question is extending that choice to the user: "how do you want me to look." It then tells the compositor to draw it in that fashion. I would argue that this is the correct place for this choice.

If you use the compositor to control transparency, what you have is the window asking to be drawn in a certain way and the compositor saying "Eh, you'd look way better at 50% opacity". If it's the user controlling this it's even worse. Now they have to be able to write a regular expression on certain window classes for each application they want to modify, and have far less granularity in how the window is modified.

The compositor exists to faithfully draw windows and place them on the screen according to what is requested. Only in exceptional cases should it be asked to do weird things with certain windows.

It's not uncommon in C as an alternative to exceptions. You don't want to be using it for every-day flow control, but when you're checking results from syscalls repeatedly, using a gigantic nested if-else chain would get more messy than using goto. The other alternative is early return/exit calls, but then you have to remember to clean up everything each time before you return/exit.

I sent a pull request with heap things, a couple sorts, and interpolation search.

Is it nonlinear even if you have a maximum number of digits in the numbers you're sorting (like say, 64-bit integers)?

This is a pretty limited list of algorithms. It should definitely include linear time sorting algorithms (e.g. bucket or radix sort), as well as graph algorithms (shortest path at least, but also probably all pair shortest path and minimum spanning tree).

There should also be a section about heaps and their operations. There are a huge number of ways to implement a heap (e.g. linked list, binary tree, or a more exotic structure like a binomial of fibonacci heap) and there are a lot of tradeoffs in complexity of different operations between them.

Check out deviantArt's infinite scroll implementation. If you go to their home page, and scroll to the bottom, there's a big green "Show More" button. No infinite scrolling happens until you explicitly want it to and you are able to get to the stuff in the footer. Once you start scrolling, it's very fast and there's not much of a delay as it loads more things. It also updates the URL as you scroll so when you click on something and hit the back button you are where you left off. It's quite slick.

Why wasn't I aware of this guide last week when I had to write a kernel driver for my OS class?!

One thing that's surprised me with Linux development is how nice the APIs are to work with. Things like the file_operations struct, and the linked list stuff are very well thought out and easy to use (as easy as they could be for C programming).

My only complaint is that a lot of the written documentation is out of date about a number of topics. As the kernel has evolved it's gained and lost a number of APIs and depending on when resources were published they may say a number of conflicting things about how to carry out a task (registering a character device and getting it in /dev is the big one that comes to mind).

That's assuming that Intel gets a decent cut of tablet market at all. Intel making a decent low power CPU isn't going to make Arm go away, and Arm is only going to work its way up the ladder from its current dominance in the embedded and mobile space.

I don't think equating languages that compile to javascript with C++ improves the analogy all that much. If anything a better analog would be a language that compiles to C like Chicken Scheme or Vala.

I also don't think that comparing one's language to C++ is necessarily a good way to advertise it. ;)

This is basically what computers do, it's called speculative execution. Modern computers actually have several pipelines, each for a different function. This is what makes a computer "superscalar". Basically, the CPU tries to keep the pipelines of all of the execution units filled at all times. If it's able to, it will schedule both sides of a branch to be executed, and flush out whichever half wasn't used.

You may be able to find it on high-end workstations sold by server companies (read, a 4U server turned on its side, with added feet), but by and large it's a server-only thing. The reason being it's only really necessary to have the level of remote access offered by these systems if it's difficult to access the hardware, or you have a very large amount of the hardware (in most cases where it's used, both of these are true).

The webm container format is a subset of Matroska, so that should widen its base to some degree.

The goal of brainfuck is to be as minimal as possible. Being bad is just a side effect of that.

If you want a language that was designed to be bad look at Malbolge or INTERCAL.

This comment is a fantastic example of what is probably the most insidious form of trolling.

You can set per-user shortcuts for this. http://www.hcs.harvard.edu/~jrus/site/cocoa-text.html

I'm unsure if it works in 10.7 though.

Neither Windows nor OS X comes with an office suite installed by default. It wouldn't be unprecedented if a linux distro were to come without one.

If you have any spares I'd love one as well. My email is in my profile.

Are people really that distracted by the blue search button? I've seen it mentioned a couple times now about how the search button draws their attention away from what's actually on the page.

Maybe I'm in the minority, but I tend to look at the middle of pages, and have no problems with the button.

> A traveling wave tube—basically an inverse klystron—captures most of the particles’ flux kinetic energy and efficiently converts it into electrical energy

Anyone else think this sounds like sci-fi technobabble?

Awesome is composited (well, has support for compositing). You just have to use an external compositor. xcompmgr and cairo-compmgr are two that I know of.

It kind of reminds me of the story of the development of the Graphic Calculator application. http://www.pacifict.com/Story/

They're extending existing users time until June 2012, at which point it will be shut down as all of its features are in iCloud.

There's a complete list of new features here: http://www.apple.com/macosx/whats-new/features.html

To address the concerns of re-installation, they're including a partition with the system install disk on it (which can get to Time Machine or whatever else you need).

One thing that graphing calculators are really useful for is simple number crunching. In academic settings you frequently need to take down numbers and then compute statistics about them. Tables and matrices are probably the 2 most useful things you can do with a graphing calculator (they're also among the least well known, at least among students).

Granted, spreadsheets do all of that and more, but it can sometimes be quicker to punch it all into a calculator, especially if you're already using one.

The coolest hidden feature of OS X is probably the text input system.

http://www.hcs.harvard.edu/~jrus/site/cocoa-text.html