"The Hard Parts of Open Source" by Evan Czaplicki - YouTube
Problems with internet communication and some ideas for systems that nudge people into having more intentional discussions.
EvanCzaplicki  community  talks  videos  youtube  StrangeLoop 
4 days ago
spawn() of Satan | tavianator.com
Pros/cons of fork()-style process spawning. Issues with posix_spawn(). Hope for a brighter future.
TavianBarnes  linux  unix  syscalls  programming 
6 days ago
Embed me some HTML, Please - apenwarr
The C preprocessor's stringizing operator, "#", converts a macro's argument to a string constant, newlines and quotes and all.

#define qq(s) #s

int main()
printf(qq(blah blah\n "quoted" stuff (and some parens)
with newlines));
return 0;
AveryPennarun  c  quoting 
4 weeks ago
"Tackling Concurrency Bugs with TLA+" by Hillel Wayne - YouTube
It starts slow---I skipped most of the first 12 mintues---but he goes on to give some compelling examples from his work where TLA+ gave crazy insights into his product's architecture.
HillelWayne  tla+  videos  youtube  talks  StrangeLoop 
5 weeks ago
(PDF) Text comparison using data compression
Overview of techniques for text comparision using data compression. I looked this up after seeing this [tweet](https://twitter.com/ccshan/status/1039214903498866688), which contains this script:

separate=$(for f; do gzip -9 -c < "$f"; done | wc -c)
together=$(cat "$@" | gzip -9 -c | wc -c)
echo "$separate / $together = $((separate*100/together))%"

The technique in the script is referred to as "Compression Based Dissimilarity"in the paper, although they have the fraction flipped.
compression  text-processing  papers  JanPlatos  VaclavSnasel  MichalPrilepok  Chung-chiehShan 
5 weeks ago
BUILD: Toolmaker's Clamp Thingy - YouTube
All of ThisOldTony's videos are wonderful, but this is one of his best.
ThisOldTony  videos  youtube  funny  machining 
6 weeks ago
"The Biological Path Towards Strong AI" by Matt Taylor - YouTube
Numenta is trying to implement intelligence with better models of biological neurons.
talks  videos  youtube  MattTaylor  machine-learning  Numenta 
7 weeks ago
A little bump in the wire that makes your Internet faster | apenwarr
"This approach just feels more magical, because you'll have a physical box that produces negative latency."

Fat flows fill big buffers and then thin flows get stuck behind them, so install a speed bump that keeps track of the different flows (Flow Queueing), puts the thin ones at the head of the line, and throttles the fat ones so the problem doesn't just move to upstream routers/buffers (Controlled Delay).
AveryPennarun  networking  queues  tcp  openwrt 
9 weeks ago
Doing the Two-Step for Efficient Reversible Deletes | David R. MacIver
Thoughts on Knuth's Dancing Links paper and an alternative data structure for efficient undo when doing recursive depth first search and backtracking, such as for SAT solving.

I've never read Dancing Links but I had the impression it was way fancier than MacIver portrays it.
algorithms  DonaldKnuth  DavidMacIver  data_structures 
11 weeks ago
Joe Duffy - Hello, Pulumi!
Duffy shares his motivations for creating Pulumi, a tool that lets you use, configure, and deploy to various clouds, using real languages.
cloud  architecture  JoeDuffy  deployment 
june 2018
Formally Specifying UIs • Hillel Wayne
Some ideas on visualizing state machines, particularly for UIs.
HillelWayne  ui  visualization 
june 2018
Announcing glom: Restructured Data for Python — Sedimental
Brings some declarative data processing to Python. Reminds me of miller's emit command.
python  library  MahmoudHashemi 
may 2018
tpope/vim-apathy: apathy.vim: Set the 'path' option for miscellaneous file types
Pope explains Vim's commands for finding included files and patterns in included files.

A couple commands seem particularly useful to referring to definitions:

- `[i` prints the first line containing the word under the cursor
- `[<c-i>` jumps to that line

I often use `*` and then search forward a few times to find a definition, and [<c-i> seems much nicer.
TimPope  github  vim 
may 2018
"How Heritability Misleads about Race" by Ned Block
There is a difference between traits being heritable or "genetically determined". Heritability, as a statistical concept, is defined as the ratio of genetically caused variation to total variation, while genetic determination is an informal concept: a characteristic could be said to be genetically determined if it is coded in the genes and is bound to develop in a "normal" environment. Importantly, both direct (genetically determined) and indirect genetic effects can be included in heritability, depending on which indirect effects are known.

Indirect genetic effects arise since environment interactions change depending on certain genes, affecting how other genes are expressed. This can make traits heritable despite not being genetically determined. A substantial variation in a highly heritable trait between groups doesn't necessarily imply genetic differences for that trait.

For a listing of different types of indirect genetic effects see [Gene-environment correlation](https://en.wikipedia.org/wiki/Gene-environment_correlation).
genetics  iq  CharlesMurray  NedBlock  critique  TheBellCurve  via:MaciejCeglowski 
april 2018
Tools for making git visualizations.
git  graphics  javascript  visualization  tools 
march 2018
Upgrade your cargo cult for the win | Meaningness
On the necessity of cargo-cult and how to transcend it.

A combination of Picasso's “Learn the rules like a pro, so you can break them like an artist.”, and Daishi's "Do not seek to follow in the footsteps of the wise; seek what they sought."
epistemology  DavidChapman  science 
february 2018
"Predictive Load-Balancing: Unfair but Faster & more Robust" by Steve Gury - YouTube
Gury presents a load-balancing algorithm that keeps p99 latency low despite

- servers with uneven latency
- thundering herds
- outliers
- large clusters that dilute the value of latency statistics


- using the stable but quickly-responding moving median of app server latency as the main utility function to rank servers
- cautiously waiting for a new server to respond to 2 requests before giving it more
- weighting latency with a moving average of error rate to avoid fast-but-wrong servers
- connecting to a small number of servers to keep stats relevant
- aging server stats out so servers that have recovered can be detected
- aging servers out of the connected set to avoid starving other servers in the cluster
- updating latency stats before requests come back to deal with sudden slowness
talks  videos  youtube  algorithms  networking  distributed  load_balancing  SteveGury  via:CindySridharan 
february 2018
Drawing better looking curves / Observable
Using a "curvature comb" to visualize the smoothness of a Bezier curve.
graphics  bezier  via:MikeBostock 
february 2018
Engineers can’t gauge their own interview performance. And that makes them harder to hire. – interviewing.io blog
An interesting point about interviews I've never heard of before:

> There’s a very statistically significant relationship (p < 0.0008) between whether people think they did well and whether they’d want to work with the interviewer. ...it means that in every interview cycle, some portion of interviewees are losing interest in joining your company just because they didn’t think they did well, despite the fact that they actually did.
february 2018
Render markdown with javascript.
markdown  web 
february 2018
Extended Date/Time Format (EDTF) 1.0 Submission
A scheme for representing dates with varying levels of uncertainty. Also a draft extension to ISO 8601.

For example:

uncertain: possibly the year 1984, but not definitely
"approximately" the year 1984
some unspecified year in the 1990s.
time  iso8601  standards  reference 
december 2017
Uncle Bob is Ruining Software • Hillel Wayne
Someone being an effective programmer doesn't necessarily make them an authority on best practices.
programming  epistemology 
december 2017
OxidationPlan - Mercurial
Mercurial is getting rewritten in Rust (or parts, at least)
mercurial  rust  rewrite  c  performance  via:campbellr 
december 2017
A Patreon alternative where you pay in advance, allowing for drastically reduced transaction fees.
december 2017
Using an expression in substitute command | Vim Tips Wiki | FANDOM powered by Wikia
Also, another sweet trick is to replace matches with values from a list, using an existing block of text as an impromptu template:

let vals = ['a', 'bunch', 'of', 'words']
let i = 0
g/^/s/X/\=vals[i]/ | let i = i+1

Note that :g "sees" the `|` (unlike :sub and many other commands), so the assignment happens after each substitution.

For greater convenience and at the cost of indirection, you can define a function, say `Inc`, that increments a global variable (`i` in this case) but returns the old value:

let vals = ['a', 'bunch', 'of', 'words']
let i = 1
vim  text-processing 
october 2017
Developing ethical, social, and cognitive competence – Vividness
David Chapman summarizes Robert Kegan's compelling model of ethical, social, and cognitive competence through child -> young adult -> communal society -> systematic society -> fluid/meta-systematic society.
ethics  psychology  society  philosophy  DavidChapman  RobertKegan  via:ScottAlexander 
october 2017
"Stop Rate Limiting! Capacity Management Done Right" by Jon Moore - YouTube
How to apply backpressure to clients using an Additive Increase/Multiplicative Decrease scheme (like with TCP) based on the number of concurrent connections. Rate-limiting sucks because if the service isn't healthy connections build up on the proxies and the service stays overloaded. Backpressure needs to be propagated throughout the request path.

In the demo, multiple proxies to an app server start with a low limit for concurrent connections that slowly increases as OKs are returned by the app server. When the app server applies backpressure to a proxy it decreases the limit by 25% and rejects connections until the number of concurrent ones is under the limit. The sum of the concurrency limits for the proxies ends up hovering around the actual capacity of the app server, without any extra communication between the proxies or app server, and without any hardcoded limits on the proxies. Also, when the service is at full capacity the number of concurrent connections at the proxies can be predicted by Little's Law, NumConcurrent = ArrivalRate * Latency (on average), if the capacity (NumConcurrent) of the service is known.

It seems like app servers could also use AIMD to choose when to apply backpressure, decreasing the concurrency limit when average latency or something crosses some threshold.
videos  queues  scale  youtube  talks  distributed  StrangeLoop  JonMoore 
october 2017
The Mathematics of Crime and Terrorism - Numberphile - YouTube
Fry talks about how to model events that are mostly Poisson-distributed but also show clustering behaviour, like a burglar targeting a favourite neighbourhood or earthquakes and aftershocks, by adding exponentially-decaying "kicks" (Hawkes process).
math  probability  videos  HannahFry  youtube 
september 2017
Home | FLEEN
John Greene's generative art. Mosaics, shapes, etc.
programming  java  generative  art  geometry  graphics 
september 2017
Grandfathered In | Geoff Greer
"A useful way to recognize status quo bias is to ask, 'What things wouldn’t be allowed if they were introduced today?'"

Related is the concept of path dependence. From wikipedia:

Path dependence explains how the set of decisions one faces for any given circumstance is limited by the decisions one has made in the past, even though past circumstances may no longer be relevant.
september 2017
Up and Down the Ladder of Abstraction
On using visualizations to jump between levels of abstraction to gain an intuitive understanding of a system.
visualization  abstraction  BretVictor 
september 2017
Scalability! But at what COST? | USENIX

We offer a new metric for big data platforms, COST, or the Configuration that Outperforms a Single Thread. The COST of a given platform for a given problem is the hardware configuration required before the platform outperforms a competent single-threaded implementation. COST weighs a system’s scalability against the overheads introduced by the system, and indicates the actual performance gains of the system, without rewarding systems that bring substantial but parallelizable overheads.

We survey measurements of data-parallel systems recently reported in SOSP and OSDI, and find that many systems have either a surprisingly large COST, often hundreds of cores, or simply underperform one thread for all of their reported configurations.
databases  graph-theory  programming  performance  benchmark  research  distributed 
september 2017
How I Make Explorable Explanations
I particularly liked the part about story-telling using "buts" instead of "thens".
teaching  learning  NickyCase 
september 2017
Noise Functions and Map Generation | Red Blob Games
Fun, approachable, and practical introduction to noise generation. Focuses on using an inverted Fourier transform to create noise containing a spectrum of weighted frequencies.
noise  programming  algorithms  random  games 
september 2017
« earlier      
3blue1brown abstraction acm agile ai alankay alcohol algorithms alternative analytics anatomy android animation ansible api apl apple appliedscience apps architecture art assembly audio automation averypennarun backup bash benchmark benkrasnow bitcoin book books boxing browser bryancantrill bsd build business c c++ camera canada cap career cgpgrey charting chat chriswellons chrome cli clojure cloud code-review coffee collaboration color comedy comic comics common-lisp community comparison compatibility compilers compression compsci concurrency container containers cooking crime critique cryptography cs css culture cycling d3 danluu data_structures database databases dating davidchapman debug debugging dedupe demo deployment depression design desktop development devops dinner distributed distro diversions django dns docker documentation drm dtrace economics editor editors electronics emacs energy engineering environmentalism epistemology erlang error-handling estimating estimation ethics expect facebook failure feminism fighting filesystem filesystems fitness food foss functional funny games gaming gc gdb gdc gender generative genetics geometry gifs gifts git github gnu golang google gpg grantsanderson graph-theory graphics grep guide hadoop hardware haskell health hillelwayne hiring history hosting howto html http humor images init interview interviews iterators jamesdamore java javascript json juliaevans k keyboard language latex lauriepenny learning library linear-algebra linguistics linux lisp logging logic mac machine-learning maciej-ceglowski macros make management manufacturing markdown martinsustrik maryrosecook math meetings memory mercurial messaging metaprogramming microservices microsoft middleware midori migration mobile monitoring music mysql naming nathanieljsmith networking nginx nickycase nlp nosql ocaml oop openstack openwrt operating-systems ops optimization oracle os osx packaging painting papers parsing password patterns pdf performance perl philosophy photo-gallery photography pinboard plan9 podcast politics portability posix postgres postmortem powershell practices presentations probability procedural productivity products profiling programming prolog prose psychology puzzle puzzles python queues quotes random react recipes refactoring reference regex reliability religion remote replication research rest review reviews rewrite richhickey robots roguelike ruby running rust scaling scanning science scifi scottalexander screen scrum search security seo sex shell signals slides smb soa society software solaris sorting sports sql squats ssh standards statistics stock story strangeloop style sync sysadmin talks tcl tcp tdd teaching teamwork terminal testing text-processing themorningpaper time timeseries tmux tools toys troubleshooting tutorial type-systems typography ui unclebob unix ux vcs versioning via:akerboom via:boingboing via:campbellr via:drmaciver via:jwz via:onethingwell via:popular via:reddit via:scottalexander via:starslatecodex via:torboto video videos vim vimeo virtualenv visualization web webgl weightlifting wheel window-manager windows women writing wwii x11 xml yossikreinin youtube

Copy this bookmark: