kpreid

A capability system is sort of like having lots and lots of those roles. But a key element is that within the system you don't have to be an administrator or have any kind of privileged-operation access to create a new capability, you just do it, and then you can pass it around (loosely equivalent to giving the role to others).

Capability systems include a way to _pass_ capabilities as part of the basic routine operations.

Some people have used it with Raspberry Pis; I don't own any myself. I tried a BeagleBone Black once and found that the CPU couldn't keep up. The CPU use will vary a lot depending on what sample rate you set and what demodulator you're using. Lots of room for improvement, too.

The thing that happened is RTL-SDR, which is _not_ the name of a product but refers to the _use_ of a mass-market TV receiver USB device that happened to have a raw IQ signal mode in the hardware (RTL2832U chip). This being so cheap ($15-20) lots and lots of people jumped on it and this created a lot of interest in SDR in general.

I don't have a good overview to recommend you, but for ‘what kind of signals…’ I do recommend grabbing a RTL-SDR device, and just reading about how to use it should give you lots of pointers into the rest of the SDR world.

A public demo instance is blocked on adding sufficient anti-DoS provisions to the server. One possibility I've considered is to make a simulation-only version packaged for Sandstorm, which would allow for a one-click trial experience — but not show any actual RF, so the internal simulator would need to be made much richer to actually show off the features.

It turns out that UI is hard! But the biggest not-crap thing from back when I wrote that (persistent waterfall) is not actually visible in a screenshot; it would need a video.

— a video would make sense, wouldn't it.

As the author, I'll say that there's a large amount of "ooh shiny bleeding edge" and "if it works for me it's fine" going on. I see that newer Safari has a _different_ failure mode and I should look into that… okay fixed https://github.com/kpreid/shinysdr/commit/67327273

That is exactly what I plan to do.

The metagame (or "the meta") is the long-term game in which the moves are "I am going to play this character/deck and practice/use these strategies" -- decisions you make at the beginning, or before, play starts in the base game and the rounds are complete games of the base game.

Learning new information about the base game (or it being updated by the developers) changes what moves are best in the metagame — but as this knowledge propagates through the player base, the probability distribution of what-you-will-be-facing changes, which also changes the best choices of meta-moves.

For an example of why metagames are more than just knowledge about the base game, suppose that we have a fighting game with character A (or a CCG with a player-designed deck A) who is well-rounded and B who doesn't do so well in most cases but is good at beating A. Then even if the base game doesn't change at all and nobody learns a new trick, B is a good choice if and only if lots of other people are playing A — meaning you have a dynamical system.

A lively metagame keeps things interesting because players keep doing new (or dusting off old) things to defeat the current things, rather than sticking to what works — because "what works" changes. It avoids the problem of "X is best, so either you ignore other parts of the game or you are deliberately playing suboptimally".

Rotary motion was used for conversion long before semiconductor devices were invented: https://en.wikipedia.org/wiki/Rotary_converter

I don't know what the limits on efficiency are, and the Wikipedia article mainly addresses AC-to-DC conversion rather than DC-to-AC, but I assume simply from the fact that they aren't used these days that they aren't an improvement on solid-state inverters.

The cable is the least likely part to be the source of the problem. The data lines are inside a shield, and in USB they are balanced (“D+” and “D-”). Both of these act to prevent radiation of the signals.

If a keyboard radiates it is likely to be either from the unshielded, unbalanced matrix wires going to the keyswitches, or leakage from the controller going onto the outside of the shield. (I think the latter could be reduced by using (more/bigger) decoupling capacitors, i.e. shorting out the RF.)

Coiling a wire does not generally make it a more effective antenna; it may or may not make it less effective depending on the circumstances. (The reason some antennas are coiled is to get the same length of conductor into a smaller space.)

I use this for programs which otherwise output to pagers, when I'd rather have the output just in terminal scrollback. (And unlike the -1 option it's generic to all programs with terminal behaviors.)

Somehow, natural languages appear to fit somewhere in the middle.

I don't recall where, but I have heard an argument that there is pressure on the information density of natural language, as follows: If you are frequently misunderstood, then you can save effort (not have to repeat/explain) by adding redundancy. If you are never misunderstood, then you can save effort by removing redundancy.

There's no particular reason the result of this process should be good for crosswords, but it's a reason to be in the middle rather than at the extremes.

The old flat had border lines (usually black lines between light-colored backgrounds). The new flat uses differences between background colors to mark the same sorts of boundaries. I think this makes enough difference that it's worth considering them distinct.

For 35 degrees, you don't need 3D; a ring of 72 35-degree angles is a cycle (with a star pattern, rather than a polygon). There is a similar solution for any rational fraction of a full revolution (equivalently, any angle which is rational when measured in degrees (or gradians), but not radians).

However, the article said “about 35 degrees” so the actual number is probably something 34.5 ≤ x ≤ 35.5 but not actually 35.

My geometric intuition says that in 3D you can always construct a cycle but I don't know how to formalize it. Imagine a flat zig-zag chain of alternating bends; you can reshape it to a curve of arbitrary radius (around the axis of the width of the chain) by turning each bend slightly relative to its neighbors (about the axis of the beam), in alternating directions. Then you can choose a radius which makes the ends meet exactly.

Not a bad idea to respond to visibility, but to solve the blob problem it would be better to explicitly synchronize text creation and text position. This is basic in game/simulation programming: you don't want the rules of the game to change depending on the performance of the computer — it may be slower, but it should be internally consistent.

For example, have a single, explicit 'scroll position' or 'time' variable (they're equivalent in this case), increment it on a timer, and insert new text when (time mod N) rolls over.

Only specific questions:

“This question is protected to prevent "thanks!", "me too!", or spam answers by new users. To answer it, you must have earned at least 10 reputation on this site.”

It's basically like semi-protection on Wikipedia: things which have gotten a lot of attention can get lots of noise, so only more established users are allowed to add content.

I like it.

Feature request: once I've picked a search result, (allow me to) hide the results — that is, have no left sidebar, so the whole UI fits in a smaller window.

The halting problem is undecidable over all possible Turing machines (i.e. programs, assuming Turing machines are an adequate model for the sort of programs of interest). It is entirely possible to choose some subset for which you know how to decide the halting problem, and program within the that subset.

It is a matter of cleverness (rather, successful algorithm design and theorem proving) how large you can make that subset. Such a subset could, for example, consist of programs written in a particular (non-Turing-complete) language, such that it is known how to construct a proof of (non-)halting because the structure of the program corresponds to the structure of a proof assembled from parts corresponding to the language's constructs.

This subset, this language, will necessarily exclude universal Turing Machines and other forms of interpreters — but I see no particular reason this is a problem for writing power plant control systems.

The structure of the above argument applies just as well to characteristics other than halting. For example, one can straightforwardly prove that any program does not access unallocated memory, provided that that program was written in a memory-safe language; the language is designed such that none of its constructs, nor any composition thereof, can be caused to do so. The analogous impossibility condition for this example is that you cannot express a C (or other non-memory-safe language) implementation in this language (without a virtual memory layer).

A bit of disagreement with your last paragraph: The (Common) Lisp macro processor is Turing-complete trivially because it invokes a Turing-complete language along the way, not because of power inherent in its expansion strategy.

Common Lisp macro bodies are written in Common Lisp, i.e. written in a Turing-complete language — they would still be Turing-complete even if we wrote them in the subset Lisp-without-macros. The C preprocessor, on the other hand, does not invoke a Turing-complete language to compute a macro's expansion.

display: (table | table-cell | table-row);

Same layout functionality, no abuse of HTML semantics.

Design by committee ("the players say they really want X, let's include X") is not the same thing as design with consideration of feedback ("the players really liked X_0, let's build X_1, and deemphasize Y because it didn't turn out fun").

I note that this is the same workflow as for making a modified copy of some content on a wiki. (And when a page is read-only on MediaWiki, "edit" becomes labeled "view source", but it's the same thing.) Is there a UI solution for this problem in general?

So did the Newton (1993 per Wikipedia). I remember it as my first-ever encounter with a (small) switching power supply — it seemed unreasonably light as “wall-warts” went.

The integrity of any "static file" which is a HTML or JS component of a web application is necessary to the security of that entire application. (Unfortunately.)

Indeed this is good style. The following, however, is not good style for allocating an array:

    long_struct_name *fooArray = malloc(count * sizeof * fooArray);

The esoteric language HQ9+ does this.

It's just the not-logged-in view.

The alternative would be a security hole in Google.

The Nexus One's below-the-screen buttons are capacitive. The Nexus One only has a mechanical trackball.

For us MobileMe/.Mac users, the usernames are in the format user(mac.com)@aol.com, and presumably user(me.com)@aol.com. Unfortunately, not @mac.com/@me.com.

I have noticed Google has one service which has responsive support: Google Project Hosting. <http://groups.google.com/group/google-code-hosting>; It may be just due to low volume of requests.