ssp

In a figure-8 path where the intersection is in the center of a pixel, does Rasterizer set that pixel to 0.5 or to 0?

http://ssp.impulsetrain.com/

If we assumed a radially symmetric kernel, then coverage would just be some monotonic function of the distance from the pixel center to the edge

I don't think that's true. Consider a simple case where the shape is a square and you are sampling in such a way that the closest edge point is closer to a corner of the square than the filter width. Using a function of distance you will get the same result as when sampling far from the corner. But the coverage is different in the two cases.

The equivalent in Oort produces:

    localhost:~/oort/examples% ../oort callcc2.nl 
    2
    1

The Oort program:

    typedef continuation_t = fn (p: int32) -> void;
    
    call_cc (fun: fn(k: continuation_t) -> void) -> int32
    {
        retval: int32;
    
        fun (fn (v: int32) -> void {
            retval = v;
            goto current_continuation;
        });
        
        // If fun returns without calling the continuation,
        // then just return 0
        return 0;
    
    @current_continuation:
        return retval;
    }
    
    x: int32 = 0;
    
    print call_cc (fn (k: continuation_t) {
        x = 1;
        k (2);
        });
    
    print x;

Does copying the stack really work? What if some local variable changes in between the call/cc and calling the continuation? If the stack is a copy, that change will not be reflected when the continuation runs.

If you generalize labels so that they become first class, then call/cc can be written in terms of goto. http://ssp.impulsetrain.com/goto.html

Do you have plans to make money off of this?

It won't work on modern Linux with modern CPUs because the array will not be in an executable mapping.

> But unfortunately, it is probably a billion users too late to start again from scratch.

A potentially interesting way around this is to make the client open source and get it shipped by all the Linux distributions. That would give application developers an initial audience which would help solve the chicken-and-egg problem.

That would be my take anyway. A big issue with Java is that it required installing a huge standard library - that should just be downloaded as required. And flash was never really intended for applications; it was always about "rich content". And Air (the application framework built on flash) has the problem that it's proprietary so you have to trust Adobe.

This one is even better: http://www.hnsearch.com/search#request/all&q=%22like+say...

- GTK3 uses the triangle technique

GTK+ uses the triangle technique along with a delay of 225 ms. When the pointer is inside the triangle, the delay is 1500 ms.

Firefox subscribes to the misguided "fake the look and feel of the default toolkit" idea, so on Linux it has a 225 ms delay, but without the triangle. Unfortunately 225 ms is way too short when there is no triangle.

A camera might produce a pixel by computing the average light input over a square, and in that sense you could consider the pixel itself a square.

But in signal processing you interpret it as a two step procedure: First, for every mathematical point of the scene, compute the average light input of the surrounding square to produce a band limited signal. Second, for every pixel report the value at the corresponding point in the band limited image.

The first step is filtering (in this case with a box filter), the second is point sampling.

The person who owns http://nissan.com/ has somehow against all odds managed to hang on to it.

I suspect there is some incoherent thinking about the BSD license. If you are a BSD advocate, consider this:

Someone takes a BSD project and bases a proprietary program on it. Is that person doing something wrong? Well, no, you say, because that's the whole point of the BSD license. It's also fine to keep rolling in new versions of the BSD project.

Now suppose someone takes a BSD project and relicenses it under the GPL, announces it on the internet, gets it into all the Linux distributions, and starts soliciting contributions of new GPL-only features while also rolling in new versions of the BSD project as they become available. Is that person doing something wrong?

I suspect that a calm, "No, that's also great. That's why we made it available under BSD." would not necessarily be the response.

Also worth reading Bruce Tognazzini on Magic and Software Design:

http://www.asktog.com/papers/magic.html

How does it work more precisely? For example, can it correctly detect strumming and flageolets?

There is a difference though: The IBM PC was the undisputed gold standard for compatibility. Software typically listed the hardware requirements as "IBM PC or 100% compatible". (Some non-IBM-compatible DOS hardware was sold, but it died out pretty quickly).

It doesn't look like there any similar gold standard is emerging for phones.

Very good comment, though broadcast and video are much harsher environments for graphics than a computer monitor. The resolution is lower as you point out, especially chroma resolution, and there may be interlacing and/or compression going on too. Each of these makes heavier blurring more desirable for high-frequency images such as text.

Regarding this:

So a controlled amount of blur, and I'm not talking about anti-aliasing,

it's worth pointing out that anti-aliasing is a form of blur, but most software usually uses a box filter which is a really a poor filter. I have some demonstration images here:

http://www.freedesktop.org/~sandmann/tigers

Compare these two especially:

http://people.freedesktop.org/~sandmann/tigers/tiger-box.png

http://people.freedesktop.org/~sandmann/tigers/tiger-jinc-ga...

The first one is what cairo produces; the second is improved in three ways: (1) The antialiasing filter is based on the Jinc function rather than a box, (2) white and black are offset slightly from the top and bottom, and (3) the compositing is done in linear light, not sRGB.

The strokes in the second image are also somewhat wider in order to compensate for the lighter appearance that gamma-aware compositing produces.

The prefetcher knows what a linked list looks like

That seems unlikely to me. Which processors do this?

The principle is "compiler optimizations should pay for themselves."

This principle may seem deep because there is an element of self-reference in it, but it is really totally stupid. It's nothing but an arbitrary benchmark that will reject lots of useful optimizations. It's not "forgotten" wisdom from the golden ages; nobody ever abided by anything like it.

It's cool that the optimizing Oberon compiler did manage to make its own object code smaller than that of the non-optimizing compiler, but I'll eat my hat if they started out by stating this "principle", rather than just noticing after the fact that it had happened.

Is there an identifiable set of users who use only a subset of what Creative Suite provides? If so, supporting that subset better than CS could be a possibility.

It was also called "web browser" one of the last times it was tried. Those became quite popular I believe.

Flash has done quite well actually, but one flaw is that it is completely tied to the web browser, so it doesn't provide a really native experience. AIR would be a better counter-example. Also, flash is quite unreliable.

Java applets had an addtional problem in that they required a huge standard library and took forever to start up. I'd suggest instead to download the standard library on demand.

I've sometimes wondered whether you could solve those problems within a system that provided a more native experience. For example, consider a new kind of client that would download and run bytecode instead of HTML/CSS/JavaScript.

The bytecode would have a built-in abstraction layer over various platform facilities such as graphics and sound, allowing it to look and feel much more like a native application.

Why not?

Pierce branded a potential employer "evil" because of a minor detail in his contract

That's not true. This is the reason he gave:

An evil company is trying to get rich quick, and has no regard for the harm they're doing along the way. It's not making things of value, it's chasing a gold rush. An evil game company isn't really interested in making games, it's too busy playing a game -- a game with the stock market, usually. It views players as weak-minded cash cows; and it views its developers as expendable, replaceable tools to create the machines that milk those cows.

It was an epic screw-up to position it as a head-to-head competitor with NVIDIA and ATI for Direct3d. They should have positioned it as an HPC chip from the beginning and then perhaps later said: "Oh, btw, it has these texture samplers, so let's make a video driver just to see how this CPU of ours compares to GPUs for gaming." That would have set expectations at a much more realistic level.

The Soviet Union had a population of 189 million people in 1953 according to Wolfram Alpha.

What are the problems with Liang's algorithm?

On a modern computer you could easily store the entire dictionary, but it's not clear that that's actually an improvement since it wouldn't be as good at dealing with unknown words.

There are some simple things that could be done to protect against this kind of abuse:

- Loser pays the winner's costs, but capped such that the loser won't be bankrupted. This effectively means that when a big company loses, they get to pay for all of the trial, but individuals can still lose without being totally doomed.

- A judge could be allowed to grant "free trial" if he thought the case had merit and one of the parties couldn't afford the legal costs. This would mean that the state would cover the legal costs of that party no matter the outcome.