text stringlengths 25 512 | source_url stringclasses 10
values | source_title stringclasses 10
values | source_domain stringclasses 7
values | license_type stringclasses 2
values | attribution_required bool 1
class | attribution_text stringclasses 1
value | license_url stringclasses 1
value | relevance_score float64 0.32 0.72 | quality_score float64 0.53 0.9 | topics stringlengths 2 72 | character_count int64 25 512 | subject_name stringclasses 1
value | subject_type stringclasses 1
value | extraction_date stringlengths 26 26 | embedding listlengths 384 384 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
layer between the modules, future microservices. Feature-rich languages We feel excited when new features got released in our favourite language. We spend some time learning these features, we build code upon them. If there are lots of features, we may spend half an hour playing with a few lines of code, to use one or ... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.384 | 0.862 | ["education"] | 463 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.951664 | [
-0.042714037001132965,
-0.07157940417528152,
0.005013884045183659,
0.03571654483675957,
0.06272430717945099,
0.0057995556853711605,
-0.006325033493340015,
0.015815718099474907,
0.04711906239390373,
-0.044716592878103256,
0.030125902965664864,
0.03459375724196434,
-0.042379625141620636,
0.0... | ||
you would have to recreate that thought process! You not only have to understand this complicated program, you have to understand why a programmer decided this was the way to approach a problem from the features that are available. 🤯 These statements are made by none other than Rob Pike. Reduce cognitive load by limit... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.396 | 0.844 | ["decision_making"] | 417 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.951826 | [
0.042441438883543015,
0.03573630377650261,
0.008564002811908722,
-0.08732917904853821,
-0.02212071232497692,
0.04773733764886856,
0.0802478939294815,
0.03346141055226326,
-0.04384301230311394,
0.027775168418884277,
-0.007156020030379295,
-0.006799150723963976,
0.0745832547545433,
-0.006507... | ||
OK, as long as they are orthogonal to each other. Thoughts from an engineer with 20 years of C++ experience ⭐️ I was looking at my RSS reader the other day and noticed that I have somewhat three hundred unread articles under the "C++" tag. I haven't read a single article about the language since last summer, and I feel... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.367 | 0.888 | [] | 512 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.951934 | [
-0.04606033116579056,
-0.04910675063729286,
-0.05072762072086334,
-0.03822449594736099,
-0.04787135124206543,
0.07374109327793121,
-0.12166468054056168,
0.033760782331228256,
0.05486830696463585,
-0.049690332263708115,
-0.003079845802858472,
0.03898024559020996,
0.04680437594652176,
0.0255... | ||
corners of the language (such as undefined behaviours of all sorts). It's not a reusable experience, and it's kind of creepy to throw it all away now. Like, can you imagine, the token || has a different meaning in requires ((!P<T> || !Q<T>)) and in requires (!(P<T> || Q<T>)) . The first is the constraint disjunction, t... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.335 | 0.882 | [] | 512 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.952049 | [
-0.08968808501958847,
0.013061894103884697,
0.05163050442934036,
0.0052666207775473595,
0.012856058776378632,
-0.04994336888194084,
0.03671840578317642,
0.05355975404381752,
0.032833512872457504,
-0.02714088000357151,
0.00006492627289844677,
0.025588592514395714,
0.05687153711915016,
0.066... | ||
of bytes there without extra effort - that won't start the lifetime of an object. This was the case before C++20. It was fixed in C++20, but the cognitive load of the language has only increased. Cognitive load is constantly growing, even though things got fixed. I should know what was fixed, when it was fixed, and wha... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.392 | 0.868 | ["career"] | 458 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.952177 | [
0.02136332355439663,
0.05991177633404732,
-0.009922952391207218,
-0.02110583335161209,
-0.02238576114177704,
-0.03501974791288376,
-0.03456851840019226,
0.08585934340953827,
0.09516463428735733,
0.05301506444811821,
-0.04222996160387993,
0.07030875235795975,
-0.027752690017223358,
0.000489... | ||
which also means that you will face that legacy. For example, last month a colleague of mine asked me about some behaviour in C++03. 🤯 There were 20 ways of initialization. Uniform initialization syntax has been added. Now we have 21 ways of initialization. By the way, does anyone remember the rules for selecting cons... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.321 | 0.854 | ["philosophy"] | 472 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.952318 | [
-0.022071512416005135,
0.024602647870779037,
-0.0033060486894100904,
-0.03527724742889404,
-0.029939984902739525,
-0.006634798366576433,
-0.06361361593008041,
0.03434586897492409,
-0.09414448589086533,
0.01121540181338787,
0.07530809938907623,
0.0331273227930069,
-0.018097765743732452,
-0.... | ||
on, but if the value is known statically, then... 🤯 This increased cognitive load is not caused by a business task at hand. It is not an intrinsic complexity of the domain. It is just there due to historical reasons ( extraneous cognitive load ). I had to come up with some rules. Like, if that line of code is not as o... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.439 | 0.9 | ["philosophy"] | 507 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.952448 | [
0.003743181936442852,
0.04844770208001137,
-0.04441579803824425,
-0.03337675705552101,
-0.05600319802761078,
-0.04390464723110199,
0.01543378084897995,
0.06999550014734268,
0.08517850935459137,
0.0927555188536644,
-0.058379240334033966,
0.06463751196861267,
0.016727887094020844,
0.00466007... | ||
ns I am trying to blame C++. I love the language. It's just that I am tired now. Thanks to 0xd34df00d for writing. Business logic and HTTP status codes On the backend we return: 401 for expired JWT token 403 for not enough access 418 for banned users The engineers on the frontend use backend API to implement login func... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.361 | 0.886 | [] | 512 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.952563 | [
-0.07769763469696045,
0.044120945036411285,
-0.004164714366197586,
-0.07332806289196014,
-0.018825486302375793,
-0.04240488260984421,
0.013965068385004997,
0.0009580879705026746,
0.0216644536703825,
-0.006804275326430798,
0.00046736758667975664,
0.016258137300610542,
0.011831715703010559,
... | ||
mporarily remember it 403 is for not enough access // 🧠++ 418 is for banned users // 🧠+++ Frontend developers would (hopefully) introduce some kind numeric status -> meaning dictionary on their side, so that subsequent generations of contributors wouldn't have to recreate this mapping in their brains. Then QA enginee... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.453 | 0.87 | [] | 512 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.952675 | [
-0.048737782984972,
0.016155771911144257,
-0.021434690803289413,
-0.04541357234120369,
-0.024837447330355644,
-0.041569795459508896,
-0.020491313189268112,
-0.0011158008128404617,
0.08279379457235336,
0.004071482922881842,
0.06314786523580551,
-0.001545748091302812,
0.04551416262984276,
0.... | ||
st they have to recreate the cognitive load that the engineers on the backend once created. Why hold this custom mapping in our working memory? It's better to abstract away your business details from the HTTP transfer protocol, and return self-descriptive codes directly in the response body: { "code" : " jwt_has_expire... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.396 | 0.88 | [] | 512 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.952788 | [
-0.04554186016321182,
0.016338901594281197,
0.004310763906687498,
0.0031618503853678703,
-0.05386790260672569,
-0.03311532735824585,
-0.017768744379281998,
-0.008937783539295197,
0.09169530868530273,
-0.005501846317201853,
0.016263915225863457,
0.044566795229911804,
0.009637628681957722,
-... | ||
sorts of numeric statuses (in the database or wherever) - prefer self-describing strings. We are not in the era of 640K computers to optimise for memory. People spend time arguing between 401 and 403 , making decisions based on their own mental models. New developers are coming in, and they need to recreate that though... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.401 | 0.866 | ["decision_making"] | 486 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.953067 | [
0.06745347380638123,
0.05476776883006096,
-0.14559713006019592,
-0.03236488997936249,
-0.03496745973825455,
-0.008141917176544666,
0.020337088033556938,
0.06613873690366745,
0.07358620315790176,
0.0333925299346447,
0.0076618799939751625,
0.03790101781487465,
0.047725774347782135,
-0.016341... | ||
e. But in the end it just doesn't make any sense. We can separate errors into either user-related or server-related, but apart from that, things are kind of blurry. P.S. It's often mentally taxing to distinguish between "authentication" and "authorization". We can use simpler terms like "login" and "permissions" to red... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.353 | 0.702 | ["war_conflict"] | 465 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.953287 | [
0.004616929218173027,
0.07818029820919037,
0.043784137815237045,
-0.0031373845413327217,
0.026463240385055542,
-0.022667011246085167,
0.09944983571767807,
0.02866292931139469,
0.045231740921735764,
0.0226006880402565,
0.03532688319683075,
0.04632646217942238,
0.04999849945306778,
0.0325523... | ||
principles you are taught as a software engineer. It is so deeply embedded in ourselves that we can not stand the fact of a few extra lines of code. Although in general a good and fundamental rule, when overused it leads to the cognitive load we can not handle. Nowadays, everyone builds software based on logically sepa... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.348 | 0.836 | ["war_conflict"] | 422 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.953429 | [
-0.018576186150312424,
-0.05672508105635643,
-0.035678133368492126,
-0.05426916852593422,
0.02779664471745491,
-0.06252285838127136,
-0.013348560780286789,
0.08592572063207626,
0.06572713702917099,
0.0330708883702755,
-0.008419344201683998,
0.05186901614069939,
0.04482779651880264,
-0.0522... | ||
ultiple codebases representing separate services. When you strive to eliminate any repetition, you might end up creating tight coupling between unrelated components. As a result, changes in one part may have unintended consequences in other seemingly unrelated areas. It can also hinder the ability to replace or modify ... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.326 | 0.834 | [] | 442 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.953566 | [
-0.047188617289066315,
-0.08435562252998352,
0.0044765593484044075,
-0.0011894310591742396,
0.05397719144821167,
-0.028800563886761665,
-0.028695199638605118,
-0.020953921601176262,
0.09190158545970917,
-0.08937160670757294,
0.06360535323619843,
0.07415774464607239,
0.04032585024833679,
-0... | ||
same problem arises even within a single module. You might extract common functionality too early, based on perceived similarities that might not actually exist in the long run. This can result in unnecessary abstractions that are difficult to modify or extend. Rob Pike once said: A little copying is better than a litt... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.522 | 0.87 | ["crisis"] | 503 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.953706 | [
-0.06852420419454575,
-0.0482073575258255,
-0.006372559815645218,
-0.004953483585268259,
0.09205441921949387,
-0.03445403650403023,
-0.09660350531339645,
0.03817066550254822,
0.03511849790811539,
-0.05193737521767616,
0.05884310603141785,
0.008366466499865055,
-0.06467045098543167,
0.06554... | ||
function that we could easily write by ourselves. All your dependencies are your code. Going through 10+ levels of stack trace of some imported library and figuring out what went wrong ( because things go wrong ) is painful. Tight coupling with a framework There's a lot of "magic" in frameworks. By relying too heavily ... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.329 | 0.844 | [] | 417 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.953835 | [
-0.03983991593122482,
-0.07395860552787781,
-0.024560239166021347,
0.01875254698097706,
0.060522809624671936,
-0.014043193310499191,
-0.04316437244415283,
0.05717160552740097,
-0.023830506950616837,
-0.008609387092292309,
0.005515264812856913,
0.024735677987337112,
-0.11918777227401733,
0.... | ||
to learn that "magic" first. It can take months. Even though frameworks enable us to launch MVPs in a matter of days, in the long run they tend to add unnecessary complexity and cognitive load. Worse yet, at some point frameworks can become a significant constraint when faced with a new requirement that just doesn't fi... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.362 | 0.872 | ["war_conflict"] | 507 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.953958 | [
0.03528384864330292,
-0.08244922757148743,
-0.028984006494283676,
-0.02113601565361023,
0.08014289289712906,
0.021716808900237083,
-0.03686532378196716,
0.0390038937330246,
0.04622892290353775,
0.02957192063331604,
-0.05465175583958626,
0.03959885984659195,
-0.035593245178461075,
0.0066428... | ||
gnitive load a newcomer would have to build (i.e. learn this custom framework) in order to deliver any value. 🤯 By no means do we advocate to invent everything from scratch! We can write code in a somewhat framework-agnostic way. The business logic should not reside within a framework; rather, it should use the framew... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.381 | 0.692 | [] | 425 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.954072 | [
0.00010729232599260285,
-0.05382940545678139,
-0.08023589849472046,
-0.04547162726521492,
-0.043372027575969696,
0.014674513600766659,
0.05007211118936539,
0.0870836079120636,
-0.05390775576233864,
0.020617349073290825,
0.009104705415666103,
0.02619653381407261,
-0.07256916910409927,
0.003... | ||
gic. Use the framework in a library-like fashion. This would allow new contributors to add value from day one, without the need of going through debris of framework-related complexity first. Why I Hate Frameworks Layered architecture There is a certain engineering excitement about all this stuff. I myself was a passion... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.322 | 0.84 | ["management"] | 437 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.954199 | [
-0.047425467520952225,
-0.02406267262995243,
-0.08766399323940277,
0.0006396769313141704,
0.03613687679171562,
0.03179112449288368,
-0.0034275788348168135,
0.0635509267449379,
0.003033541841432452,
0.03466708958148956,
-0.018899420276284218,
0.0007884838851168752,
-0.07130439579486847,
0.0... | ||
re and there and encouraged other teams to do so. The complexity of our projects went up, the sheer number of files alone had doubled. It felt like we were writing a lot of glue code. On ever changing requirements we had to make changes across multiple layers of abstractions, it all became tedious. 🤯 Abstraction is su... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.361 | 0.888 | ["management"] | 512 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.954325 | [
-0.06178819388151169,
0.01544750202447176,
0.03358803689479828,
0.011449168436229229,
0.03414337337017059,
-0.04985553026199341,
-0.04861575737595558,
0.04613127186894417,
0.08372289687395096,
0.038252390921115875,
-0.03494098037481308,
0.06827475875616074,
-0.0579451248049736,
0.015059170... | ||
issing is a vital requirement to quickly solve a problem. With this architecture’s layer uncoupling it requires an exponential factor of extra, often disjointed, traces to get to the point where the failure occurs. Every such trace takes space in our limited working memory. 🤯 This architecture was something that made ... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.528 | 0.84 | [] | 420 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.954439 | [
-0.04852360486984253,
0.00795659702271223,
-0.02199675887823105,
0.06837297976016998,
0.027853628620505333,
-0.026104561984539032,
0.05207043141126633,
0.019913814961910248,
0.06950274854898453,
0.0157377477735281,
-0.011816456913948059,
0.03476059064269066,
-0.016289234161376953,
-0.00099... | ||
plying it to projects it did more harm than good. We spent years on unnecessary mental activity and writing useless glue code with no clear business value. On the contrary, we made things worse for the business by forcing newcomers to learn our approaches (mental models) first. The time to market has worsened. In the e... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.525 | 0.87 | [] | 511 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.954564 | [
-0.05903911590576172,
0.02704603038728237,
0.05727480351924896,
-0.02175004594027996,
0.0074343434534966946,
0.030325131490826607,
-0.04317992553114891,
0.04797250032424927,
0.0005687992088496685,
0.021657055243849754,
0.0528569333255291,
0.1743367612361908,
0.002181126968935132,
0.0193558... | ||
ontal abstractions, no extraneous cognitive load. If you think that such layering will allow you to quickly replace a database or other dependencies, you're mistaken. Changing the storage causes lots of problems, and believe us, having some abstractions for the data access layer is the least of your worries. At best, a... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.509 | 0.856 | ["communication", "crisis"] | 512 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.954690 | [
-0.03342118114233017,
0.008022288791835308,
0.018465599045157433,
0.041171807795763016,
0.016407689079642296,
-0.01918850839138031,
0.014822165481746197,
0.015067034400999546,
-0.02783198468387127,
-0.014095569960772991,
0.010394136421382427,
0.024808691814541817,
-0.016251223161816597,
-0... | ||
distributed systems challenges, and implicit interfaces . With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviours of your system will be depended on by somebody. We did a storage migration, and that took us about 10 months. The old system was single-th... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.509 | 0.87 | ["crisis"] | 502 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.954818 | [
-0.0681469589471817,
0.022172342985868454,
0.02545754611492157,
0.04218932241201401,
0.05631088465452194,
-0.05981987714767456,
-0.10730921477079391,
0.03858473151922226,
0.12748286128044128,
0.06244027242064476,
-0.018464012071490288,
0.015031359158456326,
0.06284308433532715,
-0.05154688... | ||
e API contract, it was not reflected in the code. A new distributed storage didn't have that guarantee - the events came out-of-order. We spent only a few hours coding a new storage adapter, thanks to an abstraction. We spent the next 10 months on dealing with out-of-order events and other challenges. It's now funny to... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.528 | 0.872 | ["salary", "crisis"] | 493 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.954941 | [
-0.07589460164308548,
0.07373366504907608,
0.09166412800550461,
0.03827117756009102,
0.026267627254128456,
-0.011195279657840729,
-0.03720348700881004,
0.0639323815703392,
0.18411453068256378,
0.10483453422784805,
0.0037429132498800755,
0.022503191605210304,
-0.015924710780382156,
0.005120... | ||
rchitecture, if it doesn't pay off in the future? Plus, in most cases, that future of replacing some core component never happens. These architectures are not fundamental, they are just subjective, biased consequences of more fundamental principles. Why rely on those subjective interpretations? Follow the fundamental r... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.514 | 0.82 | ["philosophy", "salary"] | 428 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.955072 | [
-0.013775668106973171,
-0.010042143054306507,
0.01883254572749138,
-0.047129370272159576,
0.06308207660913467,
0.0014569415943697095,
-0.09194014221429825,
0.07819563895463943,
0.12902946770191193,
0.008145185187458992,
-0.07120563834905624,
-0.028845880180597305,
-0.012609357945621014,
0.... | ||
of truth, cognitive load and information hiding. Your business logic should not depend on low-level modules like database, UI or framework. We should be able to write tests for our core logic without worrying about the infrastructure, and that's it. Discuss . Do not add layers of abstractions for the sake of an archite... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.349 | 0.872 | ["philosophy"] | 510 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.955198 | [
0.021699966862797737,
-0.008065596222877502,
-0.04695750027894974,
0.012934790924191475,
0.021297963336110115,
0.01691066473722458,
-0.009251532144844532,
0.06849664449691772,
0.01002445537596941,
-0.08184747397899628,
0.034398388117551804,
-0.03796057775616646,
-0.008421608246862888,
0.04... | ||
hey are to be held in our limited working memory. Domain-driven design Domain-driven design has some great points, although it is often misinterpreted. People say, "We write code in DDD", which is a bit strange, because DDD is more about the problem space rather than the solution space. Ubiquitous language, domain, bou... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.375 | 0.854 | [] | 478 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.955315 | [
-0.027613749727606773,
-0.04883873835206032,
0.04824090003967285,
-0.02417088858783245,
0.03451023995876312,
-0.0735933780670166,
-0.0029034314211457968,
0.08326239138841629,
0.0672600194811821,
0.017657585442066193,
-0.11901639401912689,
0.02691061608493328,
0.06641266494989395,
0.0027332... | ||
ghts about the domain and extract the boundaries. DDD enables developers, domain experts and business people to communicate effectively using a single, unified language. Rather than focusing on these problem space aspects of DDD, we tend to emphasise particular folder structures, services, repositories, and other solut... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.501 | 0.826 | ["communication"] | 422 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.955562 | [
-0.0721721202135086,
-0.05200442671775818,
0.023957008495926857,
-0.11201383173465729,
0.044146113097667694,
-0.15090934932231903,
0.004757815971970558,
0.03130441904067993,
0.04204745963215828,
-0.008128256537020206,
-0.01874743215739727,
0.05999834090471268,
0.022502757608890533,
0.02307... | ||
erpret DDD is likely to be unique and subjective. And if we build code upon this understanding, i.e., if we create a lot of extraneous cognitive load - future developers are doomed. 🤯 Team Topologies provides a much better, easier to understand framework that helps us split the cognitive load across teams. Engineers t... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.361 | 0.864 | ["management", "education"] | 500 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.955737 | [
0.05578654259443283,
-0.10690614581108093,
0.00817237887531519,
-0.10047635436058044,
0.029010264202952385,
-0.02318531833589077,
-0.04258773848414421,
0.11184889823198318,
0.13191381096839905,
-0.01950954459607601,
-0.05108543485403061,
0.07943405210971832,
0.04625632241368294,
0.01242283... | ||
different mental models for 10 different readers. Instead of being common ground, it becomes a battleground for unnecessary debates. Cognitive load in familiar projects The problem is that familiarity is not the same as simplicity. They feel the same — that same ease of moving through a space without much mental effort... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.558 | 0.848 | ["war_conflict", "education", "philosophy"] | 471 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.955884 | [
0.07677749544382095,
-0.07459844648838043,
0.007876181975007057,
-0.016443302854895592,
-0.005314620211720467,
-0.03612111881375313,
0.10203683376312256,
0.07522985339164734,
0.05455738306045532,
0.014887201599776745,
-0.01725740358233452,
0.03590454161167145,
-0.044996488839387894,
0.0068... | ||
use incurs a learning penalty for everyone else. Once they have done that learning, then they will find working with the code less difficult. So it is hard to recognise how to simplify code that you are already familiar with. This is why I try to get “the new kid” to critique the code before they get too institutionali... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.523 | 0.86 | ["education", "crisis"] | 435 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.956017 | [
-0.0028137867338955402,
0.0971381738781929,
-0.0030641532503068447,
-0.06517647206783295,
-0.0436556376516819,
-0.03797343000769615,
-0.041447632014751434,
0.012100156396627426,
-0.01464127004146576,
0.0677606537938118,
0.08877976983785629,
0.02620917744934559,
-0.03624311834573746,
0.0037... | ||
ss one tiny increment at a time, not all at once. So you are the first person who has ever had to try to make sense of it all at once. In my class I describe a sprawling SQL stored procedure we were looking at one day, with hundreds of lines of conditionals in a huge WHERE clause. Someone asked how anyone could have le... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.326 | 0.874 | [] | 441 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.956149 | [
-0.027839472517371178,
0.026213189586997032,
0.01727273315191269,
0.013628125190734863,
0.016283178701996803,
0.008927702903747559,
0.032627541571855545,
0.030498547479510307,
0.07249657064676285,
0.030594520270824432,
0.04171133041381836,
0.005325873848050833,
0.04066498205065727,
-0.0538... | ||
, adding another one doesn’t make any difference. By the time there are 20 or 30 conditionals, adding another one doesn’t make any difference!” There is no “simplifying force” acting on the code base other than deliberate choices that you make. Simplifying takes effort, and people are too often in a hurry. Thanks to Da... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.54 | 0.86 | ["decision_making"] | 473 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.956277 | [
-0.007409066427499056,
-0.002804091200232506,
0.004782994277775288,
-0.010655850172042847,
0.050608981400728226,
0.02978157065808773,
-0.08480336517095566,
0.038532961159944534,
0.06196843087673187,
0.06889387965202332,
0.05425501614809036,
0.012712161988019943,
-0.009282459504902363,
-0.0... | ||
mory, you won't experience a high cognitive load. The more unique mental models there are to learn, the longer it takes for a new developer to deliver value. If you keep the cognitive load low, people can contribute to your codebase within the first few hours of joining your company. And that doesn't mean we sacrifice ... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.388 | 0.868 | [] | 496 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.956396 | [
0.07748525589704514,
-0.08389867097139359,
0.013088083826005459,
-0.006270380225032568,
-0.012727582827210426,
-0.03191521391272545,
0.01980508305132389,
0.08328089863061905,
0.06077326834201813,
0.03127804398536682,
-0.03658468276262283,
0.03675347566604614,
-0.032297588884830475,
-0.0142... | ||
Clean Architecture/Event Driven Architecture/DDD. This is an author's own interpretation of the things that excite him the most. His own subjective mental models. Extraneous cognitive load that others have to internalize. Once you onboard new people on your project, try to measure the amount of confusion they have (pai... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.432 | 0.844 | [] | 444 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.956526 | [
0.04759753867983818,
-0.004604184068739414,
0.02753705158829689,
-0.097743459045887,
-0.03594762831926346,
-0.10558177530765533,
0.024950634688138962,
0.02813427895307541,
-0.015217444859445095,
-0.028107410296797752,
-0.03762887790799141,
-0.03586003929376602,
-0.06117760390043259,
-0.041... | ||
row - you've got things to improve in your code. Examples Software systems are perhaps the most intricate and complex (in terms of number of distinct kinds of parts) of the things humanity makes. Fred Brooks, The Mythical Man-Month Our architecture is a standard CRUD app architecture, a Python monolith on top of Postgr... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.37 | 0.88 | ["war_conflict"] | 511 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.956652 | [
-0.0419958122074604,
-0.003511947114020586,
-0.0701654776930809,
-0.09065085649490356,
-0.009959143586456776,
-0.09525463730096817,
-0.03178756684064865,
0.032727815210819244,
-0.04375872015953064,
0.04766314476728439,
-0.04149559885263443,
0.021008361130952835,
0.05669350177049637,
-0.089... | ||
the most part failed One function that wires up the entire system. If you want to know how the system works - go read it Designing for Understandability: The Raft Consensus Algorithm These architectures are quite boring and easy to understand. Anyone can grasp them without much mental effort. Coding principles and expe... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.523 | 0.84 | [] | 451 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.956764 | [
0.009878995828330517,
-0.009928921237587929,
-0.07104746997356415,
-0.04550119861960411,
0.004811200778931379,
-0.1289089322090149,
-0.03598640859127045,
0.06178963929414749,
-0.04575423523783684,
0.0016955171013250947,
-0.03693313151597977,
0.03774764761328697,
-0.004938201047480106,
-0.0... | ||
elp you to identify the mentally demanding areas. Maintaining software is hard , things break and we would need every bit of mental effort we can save. The fewer components there are in the system, the fewer issues there will be. Debugging will also be less mentally taxing. Debugging is twice as hard as writing the cod... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.338 | 0.862 | ["war_conflict"] | 453 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.956885 | [
0.03606919199228287,
-0.017175834625959396,
0.042421624064445496,
-0.007123406045138836,
0.021315529942512512,
-0.10098802298307419,
-0.0005822704988531768,
0.12635701894760132,
-0.08143766969442368,
0.08710285276174545,
-0.0132381496950984,
0.011970567516982555,
-0.004193361848592758,
-0.... | ||
are, by definition, not smart enough to debug it. Brian Kernighan In general, the mindset "Wow, this architecture sure feels good!" is misleading. That's "a point in time" subjective feeling, and it says nothing about the reality. A far better approach is to observe the consequences in the long run: Is it easy to repro... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.361 | 0.862 | ["leadership"] | 466 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.957008 | [
-0.022881794720888138,
-0.00595101760700345,
0.036237578839063644,
-0.009450819343328476,
-0.009325096383690834,
-0.11553444713354111,
-0.03361784294247627,
0.03812563419342041,
-0.02216831035912037,
0.0170847550034523,
-0.039477236568927765,
-0.049301594495773315,
-0.07255258411169052,
-0... | ||
trying to make sense of everything in your head? Can we make changes quickly, or are there a lot of unknown unknowns, and people are afraid to touch things? Can new people add features quickly? Are there some unique mental models to learn? These questions are far harder to track, and people often don't like to answer t... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.363 | 0.878 | ["war_conflict"] | 498 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.957141 | [
0.029887037351727486,
-0.046661343425512314,
0.020186979323625565,
0.008062735199928284,
0.04110106825828552,
-0.06600183993577957,
-0.02398529089987278,
0.08195360004901886,
0.006050733849406242,
0.011939063668251038,
-0.03526439145207405,
-0.0024788291193544865,
-0.0030047609470784664,
-... | ||
ubernetes, Chrome and Redis (see comments below). You will not find anything fancy there, it's boring for the most part, and that's a good thing. Conclusion Imagine for a moment that what we inferred in the second chapter isn’t actually true. If that’s the case, then the conclusion we just negated, along with the concl... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.486 | 0.85 | [] | 428 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.957253 | [
-0.06060875579714775,
-0.04212712123990059,
0.057879600673913956,
-0.010204590857028961,
0.074763223528862,
-0.013693115673959255,
-0.0332484245300293,
0.03974185511469841,
0.07723356038331985,
0.014617501758038998,
0.0356331430375576,
0.0629921704530716,
0.07352674752473831,
0.02173686958... | ||
d, might not be correct either. 🤯 Do you feel it? Not only do you have to jump all over the article to get the meaning (shallow modules!), but the paragraph in general is difficult to understand. We have just created an unnecessary cognitive load in your head. Do not do this to your colleagues. We should reduce any co... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.383 | 0.874 | ["crisis"] | 486 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.957379 | [
-0.07280231267213821,
0.053990546613931656,
0.04520838335156441,
0.03203825652599335,
0.03439941629767418,
-0.02958565391600132,
0.020564887672662735,
0.06323344260454178,
-0.0003249079454690218,
-0.008653788827359676,
0.01841573789715767,
0.06358768045902252,
0.018402663990855217,
-0.0110... | ||
omments (6) Rob Pike (Unix, Golang) Nice article. Andrej Karpathy (ChatGPT, Tesla) Nice post on software engineering. Probably the most true, least practiced viewpoint. Elon Musk (Rockets) True. Addy Osmani (Chrome, the most complex software system in the world) I've seen countless projects where smart developers creat... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.519 | 0.85 | ["war_conflict", "management", "llm"] | 511 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.957499 | [
-0.058196619153022766,
0.0160825252532959,
0.05635908991098404,
-0.061909258365631104,
0.0007175248465500772,
-0.13039064407348633,
-0.0002238694578409195,
0.11756369471549988,
-0.010831695050001144,
0.010496756061911583,
-0.038654062896966934,
0.010522423312067986,
0.027643514797091484,
-... | ||
eks just trying to understand how everything fits together. The cognitive load was so high that productivity plummeted and bugs multiplied. The irony? Many of these complexity-inducing patterns were implemented in the name of "clean code." What really matters is reducing unnecessary cognitive burden. Sometimes this mea... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.35 | 0.688 | [] | 469 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.957612 | [
-0.04366915300488472,
0.028829993680119514,
0.057229168713092804,
0.028051087632775307,
0.021406788378953934,
-0.05126984789967537,
-0.028178326785564423,
0.009650971740484238,
0.028838634490966797,
0.07153432816267014,
0.023965127766132355,
0.05633281171321869,
-0.010895703919231892,
-0.0... | ||
ther instead of splitting it into tiny functions. And sometimes it means choosing boring, straightforward solutions over clever ones. The best code isn't the most elegant or sophisticated - it's the code that future developers (including yourself) can understand quickly. Your article really resonates with the challenge... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.366 | 0.83 | ["war_conflict", "crisis"] | 446 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.957742 | [
-0.08328218013048172,
0.06594409793615341,
0.035635966807603836,
0.026489263400435448,
0.032221075147390366,
-0.017692895606160164,
-0.04287758842110634,
0.049092840403318405,
-0.0428689606487751,
0.01923697628080845,
-0.005666142329573631,
0.07384318858385086,
-0.04375656694173813,
0.0241... | ||
rs being among the most complex software systems. Managing that complexity in Chromium is a constant challenge that aligns perfectly with many of the points you made about cognitive load. One way we try to handle this in Chromium is through careful component isolation and well-defined interfaces between subsystems (lik... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.369 | 0.848 | ["networking", "management", "crisis", "war_conflict"] | 497 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.957870 | [
-0.07117413729429245,
-0.02873973362147808,
-0.053333573043346405,
0.05726870521903038,
0.020084982737898827,
-0.08353378623723984,
-0.06752527505159378,
0.11327909678220749,
-0.023789938539266586,
-0.0558711476624012,
-0.08883414417505264,
-0.009183622896671295,
0.0035173131618648767,
0.0... | ||
unctionality behind relatively simple interfaces. For instance, our rendering pipeline handles incredible complexity (layout, compositing, GPU acceleration) but developers can interact with it through clear abstraction layers. Your points about avoiding unnecessary abstractions really hit home too. In browser developme... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.361 | 0.822 | ["family"] | 482 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.957993 | [
-0.038009628653526306,
-0.046890899538993835,
0.05453833192586899,
0.043620187789201736,
0.05107720568776131,
-0.10250956565141678,
-0.11705441027879715,
0.008222904987633228,
-0.006035336758941412,
-0.05083208531141281,
-0.058441486209630966,
-0.03340703994035721,
-0.08736006915569305,
0.... | ||
nt complexity of web standards and compatibility. Sometimes the simplest solution is the best one, even in a complex system. antirez (Redis) Totally agree about it :) Also, what I believe is missing from mentioned "A Philosophy of Software Design" is the concept of "design sacrifice". That is, sometimes you sacrifice s... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.325 | 0.84 | ["philosophy", "war_conflict"] | 440 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.958110 | [
-0.05734783411026001,
0.023966869339346886,
-0.09486279636621475,
-0.0628463625907898,
0.007671646308153868,
-0.12439889460802078,
-0.06561093777418137,
0.07062427699565887,
-0.007931643165647984,
0.017997870221734047,
-0.09902140498161316,
0.023687103763222694,
0.023903463035821915,
-0.04... | ||
s idea continuously, but often is not understood. A good example is the fact that I always refused to have hash items expires. This is a design sacrifice because if you have certain attributes only in the top-level items (the keys themselves), the design is simpler, values will just be objects. When Redis got hash expi... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.353 | 0.874 | ["ethics"] | 503 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.958235 | [
-0.04865700751543045,
0.07568726688623428,
-0.049083054065704346,
0.02725723758339882,
0.025829166173934937,
-0.048598550260066986,
-0.016949057579040527,
-0.016821827739477158,
0.05166330188512802,
0.006153154652565718,
-0.005080705042928457,
0.09215041995048523,
0.08203468471765518,
-0.0... | ||
right now, Vector Sets, the new Redis data type. I decided that Redis would not be the source of truth about vectors, but that it can just take an approximate version of them, so I was able to do on-insert normalization, quantization without trying to retain the large floats vector on disk, and so forth. Many vector DB... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.497 | 0.87 | ["decision_making", "philosophy"] | 485 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.958369 | [
-0.021327262744307518,
-0.02820010855793953,
-0.07099127769470215,
-0.0001018547045532614,
0.003263435559347272,
-0.04270319268107414,
-0.017282631248235703,
-0.04388391226530075,
-0.02160831168293953,
0.022924937307834625,
-0.009456547908484936,
0.049126483500003815,
0.005618868861347437,
... | ||
andom examples, but I apply this idea everywhere. Now the thing is: of course one must sacrifice the right things. Often, there are 5% features that account for a very large amount of complexity: that is a good thing to kill :D A developer from the internet You would not hire me... I sell myself on my track record of r... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.331 | 0.882 | ["interview"] | 492 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.958496 | [
0.027880940586328506,
0.045722875744104385,
0.027197491377592087,
-0.08539503067731857,
0.02582085318863392,
-0.033531613647937775,
0.034841734915971756,
0.030822711065411568,
-0.0031442122999578714,
0.02229558676481247,
-0.09725632518529892,
0.044849928468465805,
-0.041174862533807755,
-0... | ||
as one of the few that could well understand him. The managers loved him and he could dominate any development conversation. The people working around him said he left a trail of destruction behind him. I was told that I was the first person that could understand his projects. Maintainability matters. I care most about... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.325 | 0.888 | ["management", "philosophy"] | 512 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.958613 | [
0.0004938457859680057,
-0.005398604087531567,
-0.012101583182811737,
-0.04299139231443405,
0.004548095166683197,
-0.028856171295046806,
0.06025070697069168,
0.08090674132108688,
-0.021188369020819664,
0.024729134514927864,
-0.032514408230781555,
0.056268636137247086,
-0.0020964606665074825,
... | ||
son it took me to an article in a repository by someone that seemed random. I was thinking "what is this" and had some trouble getting to my home page, so I read it. I didn't really register it at the time, but it was amazing. Every developer should read it. It largely said that almost everything we've been told about ... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.415 | 0.858 | ["family"] | 449 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.958781 | [
-0.018230624496936798,
0.011179424822330475,
-0.0159270279109478,
0.0218922458589077,
0.0074458857998251915,
-0.021526876837015152,
0.05040530860424042,
0.10215894877910614,
-0.0202669445425272,
0.07272173464298248,
-0.0964774340391159,
0.15998640656471252,
-0.013505839742720127,
-0.031520... | ||
s are getting kicked by the intellectual demands. I've known this for a while, especially with the demands of cloud, security and DevOps. I also liked it because it described practices I have done for decades, but never much admit to because they are not popular... I write really complicated stuff and need all the help... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.456 | 0.862 | [] | 460 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.958915 | [
-0.07545816153287888,
-0.04300855100154877,
0.029223347082734108,
0.006643534172326326,
0.1055469661951065,
-0.018112098798155785,
-0.039694808423519135,
0.039868827909231186,
0.05703539401292801,
0.06117015704512596,
-0.05662678927183151,
0.15055127441883087,
0.02975340373814106,
-0.04846... | ||
e, though that developers should see it. I agree. Comments on Hacker News ( 2 ) About 🧠 Cognitive load is what matters Resources Readme License CC-BY-4.0 license Uh oh! There was an error while loading. Please reload this page . Activity Stars 12k stars Watchers 100 watching Forks 290 forks Report repository Releases ... | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.368 | 0.732 | [] | 504 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.959011 | [
-0.018591711297631264,
0.005935650318861008,
0.002204716904088855,
-0.02773754484951496,
0.04999466612935066,
-0.02156613953411579,
0.07306957244873047,
0.01785440929234028,
0.013775463216006756,
0.09554710239171982,
0.01419743150472641,
0.06432602554559708,
-0.0195977333933115,
0.03358644... | ||
an error while loading. Please reload this page . Contributors Uh oh! There was an error while loading. Please reload this page . | https://github.com/zakirullin/cognitive-load | GitHub - zakirullin/cognitive-load: 🧠 Cognitive load is what matters | github.com | unknown | false | 0.323 | 0.596 | [] | 129 | Prioritization Time Attention Management | topic | 2026-04-11T19:46:27.959091 | [
0.0057545993477106094,
-0.025727109983563423,
0.013027096167206764,
0.012830606661736965,
0.019568931311368942,
0.021481750532984734,
-0.031124768778681755,
-0.0971045047044754,
0.003418204840272665,
0.03540395572781563,
-0.005495044868439436,
0.03576148301362991,
-0.061013560742139816,
-0... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.