Cache behavior in the absence of a Fresh-until: header

    Your default value would force service authors to include a
    Fresh-until: <some number> header in 99% of all HTTP/1.1 responses.
    We have no guarantee that they will indeed do this.
    
First of all, I have obviously failed to make myself clear.  I
am not expecting *service authors* to provide a Fresh-until:
value for every resource.  I expect that this will be done
by the HTTP server code.  I.e., I am expecting *HTTP server
implementors* (e.g., Netscape, Microsoft, Starnine, whomever)
to ensure that their servers always include a Fresh-until:
header to be compliant with HTTP/1.1.  Presumably, the server
will insert a default value unless the service author supplies
something.

Further, I am NOT!!!!! insisting that the default inserted by
the HTTP server be "zero".  It could be zero, it could be 1
second, it could be 1 week, it could be 1000 years.  That's
up to the HTTP server implementor, and it's probably something
that would be settable in the server configuration file(s).

All I am saying is that if a cache receives a response from
an HTTP/1.1 server that does not include a Fresh-until: value,
the safest thing for the cache to do is to assume a value of
zero.

To repeat, so that I am making myself entirely clear:
	I am NOT insisting that service authors set values
	I am NOT insisting that the default sent by servers
		be zero
	I am NOT insisting that the default sent by servers
		be any specific non-zero value

I'm also open to discussion of the value that caches should
assume, but I think it is important to understand *why* I
think the value should be zero before dismissing it.  For
one thing, if caches assume a value of zero, there is a strong
incentive for HTTP server implementations to comply with my
proposed requirement that they always send a value of some sort.

Also, I'm trying to err on the side of safety rather than performance.
Any heuristic value other than zero leaves open the possibility of a
mistake (leading to the user seeing the wrong thing).

Remember, my goal is NOT to force any particular behavior, but
to ensure (as much as possible) that all parties are explicit
about what they want, so that caches do not need to make inferences.
Elsewhere you have argued eloquently that the server should be
in firm control of the situation, because the "application" semantics
are only fully known to the server.  I agree with you on this point,
and I think it would be a real mistake to rely on a purely
heuristic approach to get the caches to follow the servers' wishes.

Aside from this confusion (which I'll take full blame for), Koen and
I clearly agree that some maximum freshness lifetime needs to be
imposed in the absence of a server-supplied value.

-Jeff

Received on Wednesday, 10 January 1996 02:49:46 UTC