DarkPoolPapi @DarkPoolPapi

@ITKSpace You have NEVER provided original commentary on any player. You recycle old talking points. All your football knowledge is from playing EAFC supplemented with a ChatGPT subscription.

@ITKSpace you are completely CLUELESS about the sport. You never played it at ANY level.

@PlanAOnly_ @ITKSpace Vini does not want to pass the ball to Nono Madueke every week

TWO ENGINEERS SHOWED THE GIT TRICKS THAT MAKE PEOPLE THINK YOU'RE A WIZARD -- THE ONES 95% OF DEVELOPERS HAVE NEVER ONCE TOUCHED 42 minutes from Johan Abildskov and Jan Krag, bending git with custom configs, attributes and hooks most people don't even know exist. -> The moment it lands, git stops being four commands you repeat in fear. The same tool you've used for years turns out to have a whole layer built to bend to you. Hooks that run your checks before a bad commit ever lands. Attributes that end the "it works on my machine" merge wars. Config that makes the painful parts just stop happening. Memorizing commands was never the ceiling -> shaping git to do the work for you is. And while everyone else fights the tool by hand, the person who set it up right is shipping clean three times faster. Most people use 5% of git and call it a day. This is the other 95% nobody showed you. Bookmark it and Watch today ↓

slash1s @slash1sol

5 days ago

AN MIT RESEARCHER PROVED GIT ISN'T HARD BECAUSE YOU'RE BAD AT IT -- IT'S HARD BECAUSE IT WAS DESIGNED THAT WAY 27 minutes from a PhD researcher in MIT's Software Design Group, using actual design theory to show why the tool that confuses everyone confuses everyone for a reason.

26 57 452 136K 804

Rihanna after Germany won the World Cup in 2014

🚨💣 JUST IN: Barcelona tried to HIJACK Bernardo Silva's move to Real Madrid. 🇵🇹 They offered a TWO-YEAR Spotify subscription this time. The player still rejected. @FanbrizioRomono

keyboard_arrow_left Previous keyboard_arrow_right Next

@ITKSpace Mexico v SA will be a banger. You have no clue about the sport.

Fable 5 is state-of-the-art on nearly all tested benchmarks, with exceptional performance in software engineering, knowledge work, scientific research, and vision. The longer and more complex the task, the larger Fable 5’s lead over our other models.

@KC_267_ @iMiaSanMia Plus he’s kinda fat (?)

A Dutch computer scientist gave one lecture in 1988 arguing that programming is unlike anything humans have ever tried to do before, and the reason most software on earth is broken is that we are still teaching it as if it were a hobby. His name was Edsger Dijkstra. He won the Turing Award in 1972. He invented the shortest path algorithm that every GPS on earth still runs on. He wrote the paper that killed the goto statement in modern programming languages. He spent 50 years quietly being one of the most consequential thinkers in the entire history of computer science, and he was in a very bad mood by the time he stood up at the ACM Computer Science Conference in 1988 to deliver the lecture that almost nobody at the conference wanted to hear. The lecture was called On the Cruelty of Really Teaching Computer Science. It is now one of the most cited papers in the entire history of computing education. It was filed in his archive as EWD1036, handwritten in his careful fountain-pen calligraphy because he refused to use a typewriter and famously refused to use email for the rest of his life. The argument was simple and uncomfortable. Programming, Dijkstra said, is a radical novelty. Not a new tool. Not a new skill. Not a faster version of something humans already knew how to do. A genuinely new category of intellectual activity that has no real precedent in the entire history of the human species, and our brains have not been built to handle it. Here is what he meant by that. When a programmer writes a line of high-level code and presses run, that single line might trigger a billion operations at the level of the silicon. The ratio between the abstraction you are working in and the physical events you are actually causing is roughly one billion to one. No engineer in history before computing ever had to reason about a system spanning that kind of ratio inside their own head. A bridge builder reasons about steel beams and the physics of weight. A surgeon reasons about organs and the physics of tissue. A chemist reasons about molecules and the physics of bonds. All of them are working inside ratios of physical scale where the largest and smallest things they need to think about are within a few orders of magnitude of each other. A programmer routinely writes one line that orchestrates a billion physical events on a chip, and is expected to predict the behavior of all of them in advance. Dijkstra argued that the human brain was simply not built for this. Every intuition we have evolved over hundreds of thousands of years comes from a world of medium-sized objects behaving in continuous ways. Computing is the opposite. It is discrete, not continuous. A program that runs perfectly a billion times can crash on the billion-and-first iteration because of a single bit. A single character missing from a line of code can take down a power grid. There is no margin. There is no graceful degradation. The system either works or does not, and the only way to know is to actually run it. This was the part of the lecture where Dijkstra made everyone in the room uncomfortable. He said the way computer science was being taught in universities was a quiet disaster. Professors were teaching programming the way carpenters teach woodworking. With examples. With metaphors. With analogies to things students already understood. Files are like folders. Memory is like a desk. A function is like a recipe. Dijkstra said this was actively making it harder for students to think clearly. The whole point of a radical novelty is that there is nothing in your past experience to compare it to. The moment you start reaching for metaphors, you are smuggling in old intuitions that do not apply, and those intuitions will betray you the first time you try to reason about a system the metaphor was not built to describe. His exact line was this: the usual way in which we plan today for tomorrow is in yesterday's vocabulary. And yesterday's vocabulary, he argued, was killing the field. The reason most software is broken is downstream of this single misunderstanding. Programmers are taught to think of code as a craft. Something you get a feel for. Something you pick up through practice. Something where intuition gets sharper with experience. Dijkstra said this is exactly backwards. Programming is not a craft. It is closer to mathematics than to carpentry, and the moment you treat it as a craft, you guarantee that the software you produce will be full of the kind of bugs that craftsmanship cannot catch. The fix, in his view, was to teach programming the way mathematics is taught. You should be able to prove your program correct before you run it. You should reason about your code formally, the way a mathematician reasons about a theorem, not the way a carpenter feels their way through a joint. The students who learned this way, he said, would walk out of their classes with a kind of confidence that no amount of typing practice could produce. The lecture was published in Communications of the ACM in 1989. The field did not listen. Universities kept teaching programming the same way. Software kept getting bigger. Bugs kept compounding. By 2026, almost every piece of software on earth has known security vulnerabilities, undefined behaviors, and edge cases that nobody has ever proven safe. The doom that Dijkstra warned about in 1988 is now the default condition of the digital world we have built. The deeper lesson is the one most readers miss the first time through. Dijkstra was not just talking about software. He was making a much bigger point about how humans learn anything that is genuinely new. The instinct to translate the unfamiliar into the familiar is the most natural thing in the world. It is also the single biggest obstacle to actually understanding something that has no precedent. If you keep reaching for analogies, you will never see the new thing clearly. You will only see your old framework projected onto it. This is happening right now with AI. The same instinct that made people learn programming through metaphors of files and folders is making people understand large language models through metaphors of brains and people. Almost every framework being used to describe AI in 2026 is borrowed from a previous domain. None of them quite fit. The few people who are actually building useful intuitions about how these systems work are the ones who have done what Dijkstra recommended forty years ago. They have set down the old vocabulary. They have looked at the new thing on its own terms. They have accepted that the radical novelty is radical for a reason. You are not slow. You were taught a discipline as if it were a hobby. The cruelty is real. The fix is still available.

if you want to write an operating system from scratch this is the wiki almost everyone ends up using the OSDev community has been building it since 2004 it covers everything from the first bootloader instruction to writing filesystems memory managers and drivers the articles include real code you can compile and run yourself the Bare Bones tutorial gets you to a kernel that boots and prints to the screen in around 100 lines from there the wiki walks through every major piece of a real operating system

@iMiaSanMia Uli did say hes no maradona

@ITKSpace Why do you watch every single Bayern game?

@whoshomie @JoeBudden Anon figured you out @ThatsThatIsh

@MohammedAl1805 @PSGINT_ Accurate. I only disagree with the goalkeepers but not by much.

7 Must-Know Big-O Complexities for Coding Interviews: 1. 𝐎(1) - 𝐂𝐨𝐧𝐬𝐭𝐚𝐧𝐭 𝐭𝐢𝐦𝐞 - The runtime doesn't change regardless of the input size. - Example: Accessing an element in an array by its index. 2. 𝐎(𝐥𝐨𝐠 𝐧) - 𝐋𝐨𝐠𝐚𝐫𝐢𝐭𝐡𝐦𝐢𝐜 𝐭𝐢𝐦𝐞 - The runtime grows slowly as the input size increases. Typically seen in algorithms that divide the problem in half with each step. - Example: Binary search in a sorted array. 3. 𝐎(𝐧) - 𝐋𝐢𝐧𝐞𝐚𝐫 𝐭𝐢𝐦𝐞 - The runtime grows linearly with the input size. - Example: Finding an element in an array by iterating through each element. 4. 𝐎(𝐧 𝐥𝐨𝐠 𝐧) - 𝐋𝐢𝐧𝐞𝐚𝐫𝐢𝐭𝐡𝐦𝐢𝐜 𝐭𝐢𝐦𝐞 - The runtime grows slightly faster than linear time. It involves a logarithmic number of operations for each element in the input. - Example: Sorting an array using quick sort or merge sort. 5. 𝐎(𝐧^2) - 𝐐𝐮𝐚𝐝𝐫𝐚𝐭𝐢𝐜 𝐭𝐢𝐦𝐞 - The runtime grows proportionally to the square of the input size. - Example: Bubble sort algorithm which compares and potentially swaps every pair of elements. 6. 𝐎(2^𝐧) - 𝐄𝐱𝐩𝐨𝐧𝐞𝐧𝐭𝐢𝐚𝐥 𝐭𝐢𝐦𝐞 - The runtime doubles with each addition to the input. These algorithms become impractical for larger input sizes. - Example: Generating all subsets of a set. 7. 𝐎(𝐧!) - 𝐅𝐚𝐜𝐭𝐨𝐫𝐢𝐚𝐥 𝐭𝐢𝐦𝐞 - Runtime is proportional to the factorial of the input size. - Example: Generating all permutations of a set. ♻️ Repost to help others learn this

@Martinez_0023 @mediocentr0 The man is allergic to logic & always behind the curve

Memory Allocators 101 - Write a simple memory allocator This article is about writing a simple memory allocator in C. You will implement malloc(), calloc(), realloc() and free()

High ranked sources at PSG do not understand Bayern's complaints about the refereeing - within the Parisian club it is said that "Against Real Madrid, they [Bayern] managed to get Camavinga sent off by putting insane pressure on the referee. This time, they didn't succeed" Some at PSG also believe that without Manuel Neuer's saves, the second leg could have turned into a thrashing [@lequipe]