(Photography)

Here’s a photo of a Christmas tree, as my cam­er­a’s sen­sor sees it:

This is be­cuase while the cam­er­a’s ana­log-to-dig­i­tal con­verter (ADC) out­put can the­o­ret­i­cally out­put val­ues from 0 to 16382, the data does­n’t cover that whole range:

The real range of ADC val­ues is ~2110 to ~136000. Let’s set those val­ues as the white and black in the im­age:

Much bet­ter, but it’s still more mono­chro­matic then I re­mem­ber the tree be­ing. Camera sen­sors aren’t ac­tu­ally able to see color: They only mea­sure how much light hit each pixel.

In a color cam­era, the sen­sor is cov­ered by a grid of al­ter­nat­ing color fil­ters:

Let’s color each pixel the same as the fil­ter it’s look­ing through:

This ver­sion is more col­or­ful, but each pixel only has one third of it’s RGB color. To fix this, I just av­er­aged the val­ues each pixel with it’s neigh­bors:

Applying this process to the whole photo gives the lights some color:

However, the im­age is still very dark. This is be­cause mon­i­tors don’t have as much dy­namic range as the hu­man eye, or a cam­era sen­sor: Even if you are us­ing an OLED, the screen still has some am­bi­ent light re­flect­ing off of it and lim­it­ing how black it can get.

There’s also an­other, sneakier fac­tor caus­ing this:

Our per­cep­tion of bright­ness is non-lin­ear.

If bright­ness val­ues are quan­tized, most of the ADC bins will be wasted on nearly iden­ti­cal shades of white while every other tone is crammed into the bot­tom. Because this is an in­ef­fi­cient use of mem­ory, most color spaces as­sign ex­tra bins to darker col­ors:

As a re­sult of this, if the lin­ear data is dis­played di­rectly, it will ap­pear much darker then it should be.

Both prob­lems can be solved by ap­ply­ing a non-lin­ear curve to each color chan­nel to brighten up the dark ar­eas… but this does­n’t quite work out:

Some of this green cast is caused by the cam­era sen­sor be­ing in­trin­si­cally more sen­si­tive to green light, but some of it is my fault: There are twice as many green pix­els in the fil­ter ma­trix. When com­bined with my rather naive demo­saic­ing, this re­sulted in the green chan­nel be­ing boosted even higher.

In ei­ther case, it can fixed with proper white-bal­ance: Equalize the chan­nels by mul­ti­pling each one with a con­stant.

However, be­cause the im­age is now non-lin­ear, I have to go back a step to do this. Here’s the dark im­age from be­fore with all the val­ues tem­porar­ily scaled up so I can see the prob­lem:

… here’s that im­age with the green taken down to match the other chan­nels:

… and af­ter re-ap­ply­ing the curve:

This is re­ally just the bare min­i­mum: I haven’t done any color cal­i­bra­tion, the white bal­ance is­n’t per­fect, the black points are too high, there’s lots of noise that needs to be cleaned up…

Additionally, ap­ply­ing the curve to each color chan­nel ac­ci­den­tally de­sat­u­rated the high­lights. This ef­fect looks rather good — and is what we’ve come to ex­pect from film — but it’s has de-yel­lowed the star. It’s pos­si­ble to sep­a­rate the lu­mi­nance and curve it while pre­serv­ing color. On it’s own, this would make the LED Christmas lights into an over­stat­u­rated mess, but com­bin­ing both meth­ods can pro­duce nice re­sults.

For com­par­i­son, here’s the im­age my cam­era pro­duced from the same data:

Far from be­ing an “unedited” photo: there’s a huge amount of math that’s gone into mak­ing an im­age that nicely rep­re­sents what the sub­ject looks like in per­son.

There’s noth­ing that hap­pens when you ad­just the con­trast or white bal­ance in edit­ing soft­ware that the cam­era has­n’t done un­der the hood. The edited im­age is­n’t “faker” then the orig­i­nal: they are dif­fer­ent ren­di­tions of the same data.

In the end, repli­cat­ing hu­man per­cep­tion is hard, and it’s made harder when con­strained to the lim­i­ta­tions of dis­play tech­nol­ogy or printed im­ages. There’s noth­ing wrong with tweak­ing the im­age when the au­to­mated al­go­rithms make the wrong call.

Skip to main con­tent

Ask the pub­lish­ers to re­store ac­cess to 500,000+ books.

8 Days Left: The year is al­most over—help us fin­ish strong in 2025!

Please Don’t Scroll Past This

Can you chip in? As an in­de­pen­dent non­profit, the Internet Archive is fight­ing for uni­ver­sal ac­cess to qual­ity in­for­ma­tion. We build and main­tain all our own sys­tems, but we don’t charge for ac­cess, sell user in­for­ma­tion, or run ads. We’d be deeply grate­ful if you’d join the one in a thou­sand users that sup­port us fi­nan­cially.

We un­der­stand that not every­one can do­nate right now, but if you can af­ford to con­tribute this Thursday, we promise it will be put to good use. Our re­sources are cru­cial for knowl­edge lovers every­where—so if you find all these bits and bytes use­ful, please pitch in.

Please Don’t Scroll Past This The Internet Archive is work­ing to keep the record straight by record­ing gov­ern­ment web­sites, news pub­li­ca­tions, his­tor­i­cal doc­u­ments, and more. If you find our li­brary use­ful, please pitch in.

Remind Me

By sub­mit­ting, you agree to re­ceive donor-re­lated emails from the Internet Archive. Your pri­vacy is im­por­tant to us. We do not sell or trade your in­for­ma­tion with any­one.

An icon used to rep­re­sent a menu that can be

tog­gled by in­ter­act­ing with this icon.

An il­lus­tra­tion of an open book.

An il­lus­tra­tion of two cells of a film

strip.

An il­lus­tra­tion of an au­dio speaker.

An il­lus­tra­tion of two pho­tographs.

An il­lus­tra­tion of a per­son’s head and chest.

An il­lus­tra­tion of a hor­i­zon­tal line over an up

point­ing ar­row.

Search the his­tory of more than 1 tril­lion web pages.

Capture a web page as it ap­pears now for use as a trusted ci­ta­tion in the fu­ture.

Internet Archive’s in-browser video “theater” re­quires JavaScript to be en­abled.

It ap­pears your browser does not have it turned on.

Please see your browser set­tings for this fea­ture.

Sharyn Alfonsi’s “Inside CECOT” for 60 Minutes, which was cen­sored by Bari Weiss, as it ap­peared on Canada’s Global TV app.

To see all avail­able qual­i­fiers, see our doc­u­men­ta­tion.

We read every piece of feed­back, and take your in­put very se­ri­ously.

Secure your code as you build

To see all avail­able qual­i­fiers, see our doc­u­men­ta­tion.

We read every piece of feed­back, and take your in­put very se­ri­ously.

Secure your code as you build

You signed in with an­other tab or win­dow. Reload to re­fresh your ses­sion.

You signed out in an­other tab or win­dow. Reload to re­fresh your ses­sion.

You switched ac­counts on an­other tab or win­dow. Reload to re­fresh your ses­sion.

uv in­stalls pack­ages faster than pip by an or­der of mag­ni­tude. The usual ex­pla­na­tion is “it’s writ­ten in Rust.” That’s true, but it does­n’t ex­plain much. Plenty of tools are writ­ten in Rust with­out be­ing no­tably fast. The in­ter­est­ing ques­tion is what de­sign de­ci­sions made the dif­fer­ence.

Charlie Marsh’s Jane Street talk and a Xebia en­gi­neer­ing deep-dive cover the tech­ni­cal de­tails well. The in­ter­est­ing parts are the de­sign de­ci­sions: stan­dards that en­able fast paths, things uv drops that pip sup­ports, and op­ti­miza­tions that don’t re­quire Rust at all.

pip’s slow­ness is­n’t a fail­ure of im­ple­men­ta­tion. For years, Python pack­ag­ing re­quired ex­e­cut­ing code to find out what a pack­age needed.

The prob­lem was setup.py. You could­n’t know a pack­age’s de­pen­den­cies with­out run­ning its setup script. But you could­n’t run its setup script with­out in­stalling its build de­pen­den­cies. PEP 518 in 2016 called this out ex­plic­itly: “You can’t ex­e­cute a setup.py file with­out know­ing its de­pen­den­cies, but cur­rently there is no stan­dard way to know what those de­pen­den­cies are in an au­to­mated fash­ion with­out ex­e­cut­ing the setup.py file.”

This chicken-and-egg prob­lem forced pip to down­load pack­ages, ex­e­cute un­trusted code, fail, in­stall miss­ing build tools, and try again. Every in­stall was po­ten­tially a cas­cade of sub­process spawns and ar­bi­trary code ex­e­cu­tion. Installing a source dis­tri­b­u­tion was es­sen­tially curl | bash with ex­tra steps.

The fix came in stages:

* PEP 518 (2016) cre­ated pypro­ject.toml, giv­ing pack­ages a place to de­clare build de­pen­den­cies with­out code ex­e­cu­tion. The TOML for­mat was bor­rowed from Rust’s Cargo, which makes a Rust tool re­turn­ing to fix Python pack­ag­ing feel less like co­in­ci­dence.

* PEP 517 (2017) sep­a­rated build fron­tends from back­ends, so pip did­n’t need to un­der­stand se­tup­tools in­ter­nals.

* PEP 621 (2020) stan­dard­ized the [project] table, so de­pen­den­cies could be read by pars­ing TOML rather than run­ning Python.

* PEP 658 (2022) put pack­age meta­data di­rectly in the Simple Repository API, so re­solvers could fetch de­pen­dency in­for­ma­tion with­out down­load­ing wheels at all.

PEP 658 went live on PyPI in May 2023. uv launched in February 2024. uv could be fast be­cause the ecosys­tem fi­nally had the in­fra­struc­ture to sup­port it. A tool like uv could­n’t have shipped in 2020. The stan­dards weren’t there yet.

Other ecosys­tems fig­ured this out ear­lier. Cargo has had sta­tic meta­data from the start. npm’s pack­age.json is de­clar­a­tive. Python’s pack­ag­ing stan­dards fi­nally bring it to par­ity.

Speed comes from elim­i­na­tion. Every code path you don’t have is a code path you don’t wait for.

uv’s com­pat­i­bil­ity doc­u­men­ta­tion is a list of things it does­n’t do:

No .egg sup­port. Eggs were the pre-wheel bi­nary for­mat. pip still han­dles them; uv does­n’t even try. The for­mat has been ob­so­lete for over a decade.

No pip.conf. uv ig­nores pip’s con­fig­u­ra­tion files en­tirely. No pars­ing, no en­vi­ron­ment vari­able lookups, no in­her­i­tance from sys­tem-wide and per-user lo­ca­tions.

No byte­code com­pi­la­tion by de­fault. pip com­piles .py files to .pyc dur­ing in­stal­la­tion. uv skips this step, shav­ing time off every in­stall. You can opt in if you want it.

Virtual en­vi­ron­ments re­quired. pip lets you in­stall into sys­tem Python by de­fault. uv in­verts this, re­fus­ing to touch sys­tem Python with­out ex­plicit flags. This re­moves a whole cat­e­gory of per­mis­sion checks and safety code.

Stricter spec en­force­ment. pip ac­cepts mal­formed pack­ages that tech­ni­cally vi­o­late pack­ag­ing specs. uv re­jects them. Less tol­er­ance means less fall­back logic.

Ignoring re­quires-python up­per bounds. When a pack­age says it re­quires python, uv ig­nores the up­per bound and only checks the lower. This re­duces re­solver back­track­ing dra­mat­i­cally since up­per bounds are al­most al­ways wrong. Packages de­clare python be­cause they haven’t tested on Python 4, not be­cause they’ll ac­tu­ally break. The con­straint is de­fen­sive, not pre­dic­tive.

First-index wins by de­fault. When mul­ti­ple pack­age in­dexes are con­fig­ured, pip checks all of them. uv picks from the first in­dex that has the pack­age, stop­ping there. This pre­vents de­pen­dency con­fu­sion at­tacks and avoids ex­tra net­work re­quests.

Each of these is a code path pip has to ex­e­cute and uv does­n’t.

Some of uv’s speed comes from Rust. But not as much as you’d think. Several key op­ti­miza­tions could be im­ple­mented in pip to­day:

HTTP range re­quests for meta­data. Wheel files are zip archives, and zip archives put their file list­ing at the end. uv tries PEP 658 meta­data first, falls back to HTTP range re­quests for the zip cen­tral di­rec­tory, then full wheel down­load, then build­ing from source. Each step is slower and riskier. The de­sign makes the fast path cover 99% of cases. None of this re­quires Rust.

Parallel down­loads. pip down­loads pack­ages one at a time. uv down­loads many at once. Any lan­guage can do this.

Global cache with hardlinks. pip copies pack­ages into each vir­tual en­vi­ron­ment. uv keeps one copy glob­ally and uses hardlinks (or copy-on-write on filesys­tems that sup­port it). Installing the same pack­age into ten venvs takes the same disk space as one. Any lan­guage with filesys­tem ac­cess can do this.

Python-free res­o­lu­tion. pip needs Python run­ning to do any­thing, and in­vokes build back­ends as sub­processes to get meta­data from legacy pack­ages. uv parses TOML and wheel meta­data na­tively, only spawn­ing Python when it hits a setup.py-only pack­age that has no other op­tion.

PubGrub re­solver. uv uses the PubGrub al­go­rithm, orig­i­nally from Dart’s pub pack­age man­ager. Both pip and PubGrub use back­track­ing, but PubGrub ap­plies con­flict-dri­ven clause learn­ing from SAT solvers: when it hits a dead end, it an­a­lyzes why and skips sim­i­lar dead ends later. This makes it faster on com­plex de­pen­dency graphs and bet­ter at ex­plain­ing fail­ures. pip could adopt PubGrub with­out rewrit­ing in Rust.

Zero-copy de­se­ri­al­iza­tion. uv uses rkyv to de­se­ri­al­ize cached data with­out copy­ing it. The data for­mat is the in-mem­ory for­mat. Libraries like FlatBuffers achieve this in other lan­guages, but rkyv in­te­grates tightly with Rust’s type sys­tem.

Thread-level par­al­lelism. Python’s GIL forces par­al­lel work into sep­a­rate processes, with IPC over­head and data copy­ing. Rust can par­al­lelize across threads na­tively, shar­ing mem­ory with­out se­ri­al­iza­tion bound­aries. This mat­ters most for res­o­lu­tion, where the solver ex­plores many ver­sion com­bi­na­tions.

No in­ter­preter startup. Every time pip spawns a sub­process, it pays Python’s startup cost. uv is a sin­gle sta­tic bi­nary with no run­time to ini­tial­ize.

Compact ver­sion rep­re­sen­ta­tion. uv packs ver­sions into u64 in­te­gers where pos­si­ble, mak­ing com­par­i­son and hash­ing fast. Over 90% of ver­sions fit in one u64. This is mi­cro-op­ti­miza­tion that com­pounds across mil­lions of com­par­isons.

These are real ad­van­tages. But they’re smaller than the ar­chi­tec­tural wins from drop­ping legacy sup­port and ex­ploit­ing mod­ern stan­dards.

uv is fast be­cause of what it does­n’t do, not be­cause of what lan­guage it’s writ­ten in. The stan­dards work of PEP 518, 517, 621, and 658 made fast pack­age man­age­ment pos­si­ble. Dropping eggs, pip.conf, and per­mis­sive pars­ing made it achiev­able. Rust makes it a bit faster still.

pip could im­ple­ment par­al­lel down­loads, global caching, and meta­data-only res­o­lu­tion to­mor­row. It does­n’t, largely be­cause back­wards com­pat­i­bil­ity with fif­teen years of edge cases takes prece­dence. But it means pip will al­ways be slower than a tool that starts fresh with mod­ern as­sump­tions.

Other pack­age man­agers could learn from this: sta­tic meta­data, no code ex­e­cu­tion to dis­cover de­pen­den­cies, and the abil­ity to re­solve every­thing up­front be­fore down­load­ing. Cargo and npm have op­er­ated this way for years. If your ecosys­tem re­quires run­ning ar­bi­trary code to find out what a pack­age needs, you’ve al­ready lost.

Christmas is of­ten re­garded as a time for good­will, but one young UK cou­ple’s act of kind­ness 50 years ago changed their lives for­ever.

On 23 December 1975, Rob Parsons and his wife Dianne were prepar­ing for Christmas at their Cardiff home when they heard a knock at the door.

On their doorstep stood a man with a bin bag con­tain­ing his pos­ses­sions in his right hand and a frozen chicken in his left.

Rob stud­ied the man’s face and vaguely re­mem­bered him as Ronnie Lockwood, some­one he would oc­ca­sion­ally see at Sunday School as a boy and who he was told to be kind to as he was a “bit dif­fer­ent”.

“I said ‘Ronnie, what’s with the chicken?’ He said ‘somebody gave it to me for Christmas’. And then I said two words that changed all of our lives.

“And I’m not ex­actly sure why I said them. I said come in.”

👋 Hello! If you print this page, you’ll get a nifty cal­en­dar that dis­plays all of the year’s dates on a sin­gle page. It will au­to­mat­i­cally fit on a sin­gle sheet of pa­per of any size. For best re­sults, ad­just your print set­tings to land­scape ori­en­ta­tion and dis­able the header and footer.

Take in the year all at once. Fold it up and carry it with you. Jot down your notes on it. Plan things out and ob­serve the pas­sage of time. Above all else, be kind to oth­ers.

Looking for 2026? Here you go!

People ex­am­in­ing doc­u­ments re­leased by the Department of Justice in the Jeffrey Epstein case dis­cov­ered that some of the file redac­tion can be un­done with Photoshop tech­niques, or by sim­ply high­light­ing text to paste into a word pro­cess­ing file.

Un-redacted text from these doc­u­ments be­gan cir­cu­lat­ing through so­cial me­dia on Monday evening. An ex­hibit in a civil case in the Virgin Islands against Darren K Indyke and Richard D Kahn, two ex­ecu­tors of Epstein’s es­tate, con­tains redacted al­le­ga­tions ex­plain­ing how Epstein and his as­so­ci­ates had fa­cil­i­tated the sex­ual abuse of chil­dren. The ex­hibit was the sec­ond amended com­plaint in the state case against Indyke and Kahn.

In sec­tion 85, the redacted por­tion states: “Between September 2015 and June 2019, Indyke signed (FAC) for over $400,000 made payable to young fe­male mod­els and ac­tresses, in­clud­ing a for­mer Russian model who re­ceived over $380,000 through monthly pay­ments of $8,333 made over a pe­riod of more than three and a half years un­til the mid­dle of 2019.”

Prosecutors in the Virgin Islands set­tled its civil sex-traf­fick­ing case against Epstein’s es­tate, Indyke and Kahn in 2022 for $105m, plus one half of the pro­ceeds from the sale of Little St James, the is­land on which Epstein resided and on which many of his crimes oc­curred. The jus­tice de­part­ment press re­lease an­nounc­ing the set­tle­ment did not in­clude an ad­mis­sion of li­a­bil­ity.

Indyke, an at­tor­ney who rep­re­sented Epstein for decades, has not been crim­i­nally in­dicted by fed­eral au­thor­i­ties. He was hired by the Parlatore Law Group in 2022, be­fore the jus­tice de­part­ment set­tled the Epstein case. That firm rep­re­sents the de­fense sec­re­tary, Pete Hegseth, and pre­vi­ously rep­re­sented Donald Trump in his de­fense against charges stem­ming from the dis­cov­ery of clas­si­fied gov­ern­ment doc­u­ments stored at Trump’s Florida es­tate. Calls and email seek­ing com­ment from Indyke and the Parlatore Law Group have not yet been re­turned.

Trump has re­peat­edly de­nied any knowl­edge of or in­volve­ment in Epstein’s crim­i­nal ac­tiv­i­ties and any wrong­do­ing.

Other sec­tions fur­ther al­lege how Epstein’s en­ter­prise con­cealed crimes.

“Defendants also at­tempted to con­ceal their crim­i­nal sex traf­fick­ing and abuse, con­duct by pay­ing large sums of money to par­tic­i­pant-wit­nesses, in­clud­ing by pay­ing for their at­tor­neys’ fees and case costs in lit­i­ga­tion re­lated to this con­duct,” reads one redacted pas­sage.

“Epstein also threat­ened harm to vic­tims and helped re­lease dam­ag­ing sto­ries about them to dam­age their cred­i­bil­ity when they tried to go pub­lic with their sto­ries of be­ing traf­ficked and sex­u­ally abused. Epstein also in­structed one or more Epstein Enterprise par­tic­i­pant-wit­nesses to de­stroy ev­i­dence rel­e­vant to on­go­ing court pro­ceed­ings in­volv­ing Defendants’ crim­i­nal sex traf­fick­ing and abuse con­duct.”

Redactions of sec­tions 184 through 192 of the doc­u­ment de­scribe prop­erty taxes paid by com­pa­nies in­cor­po­rated by Epstein on prop­er­ties that were not on the bal­ance sheet for those firms.

“For in­stance, Cypress’s Balance Sheet as of December 31, 2018 did not re­flect any as­sets other than cash of $18,824. Further, Cypress re­ported only $301 in ex­penses for the year ended December 31, 2018, de­spite it pay­ing $106,394.60 in Santa Fe prop­erty taxes on November 6, 2018,” reads one redacted pas­sage.

“Similarly, in 2017, Cypress re­ported as its only as­set cash in the amount of $29,736 and ex­penses of $150, de­spite it pay­ing $55,770.41 and $113,679.56 in Santa Fe prop­erty taxes dur­ing 2017.”

The Epstein Files Transparency Act signed into law last month per­mits the Department of Justice “to with­hold cer­tain in­for­ma­tion such as the per­sonal in­for­ma­tion of vic­tims and ma­te­ri­als that would jeop­ar­dize an ac­tive fed­eral in­ves­ti­ga­tion”.

It was un­clear how prop­erty ma­te­r­ial com­plies with the redac­tion stan­dard un­der the law. An in­quiry to the Department of Justice has not yet been an­swered.

I’ve been read­ing Lord of the Rings for two months and I’m just at the end of the first part. It’s not be­cause I’m not en­joy­ing it. It’s one of the most en­joy­able read­ing ex­pe­ri­ences I can re­mem­ber.

From the be­gin­ning, I’ve read the whole thing aloud. I’ve found read­ing aloud help­ful for stay­ing en­gaged — lim­it­ing my­self to mouth-speed rather than eye-speed means I won’t rush, miss im­por­tant de­tails, and then lose in­ter­est, which has al­ways been a prob­lem for me.

At first I was anx­ious to read a 1,500-page book this way, be­cause it would take so long. But, as some­one pointed out to me, if I’m en­joy­ing it, why would I want to be done with it sooner?

So I tried slow­ing down even more, and dis­cov­ered some­thing. I slowed to a pace that felt al­most ab­surd, treat­ing each sen­tence as though it might be a par­tic­u­larly im­por­tant one. I gave each one maybe triple the usual time and at­ten­tion, ig­nor­ing the fact that there are hun­dreds of pages to go.

This leisurely pace made Middle-Earth blos­som be­fore my eyes. When I paused af­ter each comma, and let each sen­tence ring for a small mo­ment af­ter the pe­riod, the events of the story reached me with more weight and strength. That ex­tra time gave space for Tolkien’s im­ages and moods to prop­a­gate in my mind, which they did au­to­mat­i­cally.

Some part of me still wanted to rush and get on with it, to make good time, to gloss over the songs and lore to get to Moria and Mount Doom and the other mar­quee mo­ments of the story. But the more I ig­nored that im­pulse, the bet­ter the ex­pe­ri­ence got.

By of­fer­ing the book about triple the usual amount of at­ten­tive­ness, I was get­ting about triple the sto­ry­ness (i.e. mean­ing, en­gage­ment, lit­er­ary plea­sure). Whatever the thing is that I’m seek­ing when I pick up a novel in the first place, there’s much more of it avail­able at this pace.

This ef­fect re­minded me of a para­dox around eat­ing I rec­og­nized long ago. When you slow down your eat­ing speed, say to half or a third your de­fault speed, you get much more en­joy­ment out of a smaller amount of food. The ex­tra at­ten­tion given to each bite al­lows more of the “good stuff,” what­ever that is ex­actly, to reach you.

What’s para­dox­i­cal is that it’s pre­cisely the seek­ing of that “good stuff” that nor­mally dri­ves me to eat so quickly, and miss most of what I’m seek­ing. When you try to bar­rel ahead to ac­cess the good stuff quicker, you get less of it in the end. Slow down and much more of it is re­leased.

And it’s re­leased au­to­mat­i­cally, in both read­ing and eat­ing. You don’t have to search it out. The good stuff (the mean­ing in the text, the plea­sure in the eat­ing) just rises up to meet you in that ex­tra time you give it. Slowing down, and of­fer­ing more time to the act of con­sump­tion, im­me­di­ately in­creases read­ing com­pre­hen­sion (and eat­ing com­pre­hen­sion).

Both are anal­o­gous to slow­ing down while you vac­uum a car­pet. If you pass the vac­uum head too quickly, you miss half the dirt. Slow down, and you can hear how much more grit is sent skit­ter­ing up the tube. The suc­tion and bris­tles are work­ing, but they need more time to do their work fully, to draw up the deeper-ly­ing stuff.

It seems that my de­fault con­sump­tion speeds for read­ing and eat­ing (and maybe every­thing else) re­duce the re­wards of those things sig­nif­i­cantly, un­der­min­ing the point of do­ing ei­ther.

Part of it is my own im­pa­tience. But I also sus­pect that mod­ern liv­ing, with its in­fi­nite sup­ply of con­sum­ables, tends to push our rate-of-in­take di­als too high. I’m not go­ing to run out of books, or snacks, or op­por­tu­ni­ties to learn some­thing. There’s al­ways more, so not every crust of bread or printed page needs to be ap­pre­ci­ated fully.

Internally though, the mind is jug­gling like Lucy and Ethel on the con­veyor belt at the choco­late fac­tory. Our re­cep­tors for mean­ing and ap­pre­ci­a­tion, like the vac­uum head, need more time to do their full work, to make all the con­nec­tions they’re de­signed to make.

It might sound like I’m just of­fer­ing clichés — less is more, stop and smell the roses, take your time — and I guess I am. But clichés suf­fer the same is­sue: they are of­ten pro­found in­sights, con­sumed and passed on too rapidly for their real mean­ing to reg­is­ter any­more. You re­ally should stop and smell roses, as you know if you’re in the habit of do­ing that.

At least see what hap­pens when you re­duce your con­sump­tion speed — of any­thing, but es­pe­cially books, in­for­ma­tion, and food — by a half, or two thirds. Notice that (1) some­thing in you re­ally wants to plow through at the high­est vi­able set­ting, and (2) how much more of the re­ward is re­leased when you slow down any­way.

As far as I can tell, al­most every­thing be­comes more sat­is­fy­ing when you give it more time and in­ten­tion, even things like check­ing the mail­box or writ­ing a shop­ping list.

Slowing down your rate of con­sump­tion will in­evitably change what you want to con­sume. Reading throw­away news ar­ti­cles or AI slop with great care and at­ten­tion is only go­ing to show you how empty of value it is. Reading dense writ­ing in inky old books, crafted for your mind by great mas­ters, be­comes eas­ier with­out the rushed pace, and the mean­ing just blooms out of it.

Same with food. Try to sa­vor a cheap, waxy “chocolate” bar, or a bag of store-brand cheese puffs, and you dis­cover a harsh taste that you don’t want to look at too closely. Enjoy a home­made pas­try with great at­ten­tion, and dis­cover there’s even more in it than you re­al­ized.

Mass pro­duc­tion is good in so many ways, but the faster we tend to con­sume its fruits, the more we end up seek­ing things for their glossy, can­died sur­faces. The more we go for these sur­face-level re­wards, the more the cul­ture fo­cuses on of­fer­ing only that part — such as TikTok videos, processed food, CGI-forward movies, and pub­lic dis­course in the form of un­ex­am­ined talk­ing points.

Who knows how far we’ve drifted from the best modes of con­sum­ing the things we value. Once some­thing be­comes a norm, it seems like an ap­pro­pri­ate stan­dard, no mat­ter how much has been lost. Apparently, read­ing silently and alone was un­usual un­til as late as the 18th cen­tury. Certainly sit-down meals and cook­ing at home were.

I don’t mean to sound like a scold. Let’s say none of this is morally good or bad. It’s just that in so much of what we do, we could be get­ting much more of the part of it that we re­ally seek — but it’s only avail­able at slower speeds.

If you’re cu­ri­ous, try con­sum­ing things more slowly, so slowly it seems silly to oth­ers — say a third your ha­bit­ual speed — and see what rises up to meet you.

Recently I opened a dis­cus­sion fo­rum for Raptitude read­ers who want to give some­thing up for the month of December (alcohol, so­cial me­dia, snacks, etc).

It’s been a real suc­cess, and many peo­ple want to do some­thing sim­i­lar in January. If you want to quit some­thing, or just give it up for a month, you’re in­vited to join.

Follow this link at the end of this post to get an in­vite.

This site re­quires JavaScript to run cor­rectly. Please turn on JavaScript or un­block scripts