Tootfinder

"At root, stock buybacks are just wash-trading, the company buying its own shares to move their price, without doing anything to justify that price movement. Before Reagan legalized stock buybacks, companies returned capital to their investors through dividends. Why would companies prefer buybacks to dividends? Because corporate executives hold *tons* of shares in their employer's company, and it's *much* better for them to push those share prices higher even as they gut the company's ability to function."
https://pluralistic.net/2025/09/06/computer-says-huh/#invisible-handcuffs

Long post, game design
Crungle is a game designed to be a simple test of general reasoning skills that's difficult to play by rote memory, since there are many possible rule sets, but it should be easy to play if one can understand and extrapolate from rules. The game is not necessarily fair, with the first player often having an advantage or a forced win. The game is entirely deterministic, although a variant determines the rule set randomly.
This is version 0.1, and has not yet been tested at all.
Crungle is a competitive game for two players, each of whom controls a single piece on a 3x3 grid. The cells of the grid are numbered from 1 to 9, starting at the top left and proceeding across each row and then down to the next row, so the top three cells are 1, 2, and 3 from left to right, then the next three are 4, 5, and 6 and the final row is cells 7, 8, and 9.
The two players decide who shall play as purple and who shall play as orange. Purple goes first, starting the rules phase by picking one goal rule from the table of goal rules. Next, orange picks a goal rule. These two goal rules determine the two winning conditions. Then each player, starting with orange, alternate picking a movement rule until four movement rules have been selected. During this process, at most one indirect movement rule may be selected. Finally, purple picks a starting location for orange (1-9), with 5 (the center) not allowed. Then orange picks the starting location for purple, which may not be adjacent to orange's starting position.
Alternatively, the goal rules, movement rules, and starting positions may be determined randomly, or a pre-determined ruleset may be selected.
If the ruleset makes it impossible to win, the players should agree to a draw. Either player could instead "bet" their opponent. If the opponent agrees to the bet, the opponent must demonstrate a series of moves by both players that would result in a win for either player. If they can do this, they win, but if they submit an invalid demonstration or cannot submit a demonstration, the player who "bet" wins.
Now that starting positions, movement rules, and goals have been decided, the play phase proceeds with each player taking a turn, starting with purple, until one player wins by satisfying one of the two goals, or until the players agree to a draw. Note that it's possible for both players to occupy the same space.
During each player's turn, that player identifies one of the four movement rules to use and names the square they move to using that rule, then they move their piece into that square and their turn ends. Neither player may use the same movement rule twice in a row (but it's okay to use the same rule your opponent just did unless another rule disallows that). If the movement rule a player picks moves their opponent's piece, they need to state where their opponent's piece ends up. Pieces that would move off the board instead stay in place; it's okay to select a rule that causes your piece to stay in place because of this rule. However, if a rule says "pick a square" or "move to a square" with some additional criteria, but there are no squares that meet those criteria, then that rule may not be used, and a player who picks that rule must pick a different one instead.
Any player who incorrectly states a destination for either their piece or their opponent's piece, picks an invalid square, or chooses an invalid rule has made a violation, as long as their opponent objects before selecting their next move. A player who makes at least three violations immediately forfeits and their opponent wins by default. However, if a player violates a rule but their opponent does not object before picking their next move, the stated destination(s) of the invalid move still stand, and the violation does not count. If a player objects to a valid move, their objection is ignored, and if they do this at least three times, they forfeit and their opponent wins by default.
Goal rules (each player picks one; either player can win using either chosen rule):
End your turn in the same space as your opponent three turns in a row.
End at least one turn in each of the 9 cells.
End five consecutive turns in the three cells in any single row, ending at least one turn on each of the three.
End five consecutive turns in the three cells in any single column, ending at least one turn on each of the three.
Within the span of 8 consecutive turns, end at least one turn in each of cells 1, 3, 7, and 9 (the four corners of the grid).
Within the span of 8 consecutive turns at least one turn in each of cells 2, 4, 6, and 8 (the central cells on each side).
Within the span of 8 consecutive turns, end at least one turn in the cell directly above your opponent, and end at least one turn in the cell directly below your opponent (in either order).
Within the span of 8 consecutive turns at least one turn in the cell directly to the left of your opponent, and end at least one turn in the cell directly to the right of your opponent (in either order).
End 12 turns in a row without ending any of them in cell 5.
End 8 turns in a row in 8 different cells.
Movement rules (each player picks two; either player may move using any of the four):
Move to any cell on the board that's diagonally adjacent to your current position.
Move to any cell on the board that's orthogonally adjacent to your current position.
Move up one cell. Also move your opponent up one cell.
Move down one cell. Also move your opponent down one cell.
Move left one cell. Also move your opponent left one cell.
Move right one cell. Also move your opponent right one cell.
Move up one cell. Move your opponent down one cell.
Move down one cell. Move your opponent up one cell.
Move left one cell. Move your opponent right one cell.
Move right one cell. Move your opponent left one cell.
Move any pieces that aren't in square 5 clockwise around the edge of the board 1 step (for example, from 1 to 2 or 3 to 6 or 9 to 8).
Move any pieces that aren't in square 5 counter-clockwise around the edge of the board 1 step (for example, from 1 to 4 or 6 to 3 or 7 to 8).
Move to any square reachable from your current position by a knight's move in chess (in other words, a square that's in an adjacent column and two rows up or down, or that's in an adjacent row and two columns left or right).
Stay in the same place.
Swap places with your opponent's piece.
Move back to the position that you started at on your previous turn.
If you are on an odd-numbered square, move to any other odd-numbered square. Otherwise, move to any even-numbered square.
Move to any square in the same column as your current position.
Move to any square in the same row as your current position.
Move to any square in the same column as your opponent's position.
Move to any square in the same row as your opponent's position.
Pick a square that's neither in the same row as your piece nor in the same row as your opponent's piece. Move to that square.
Pick a square that's neither in the same column as your piece nor in the same column as your opponent's piece. Move to that square.
Move to one of the squares orthogonally adjacent to your opponent's piece.
Move to one of the squares diagonally adjacent to your opponent's piece.
Move to the square opposite your current position across the middle square, or stay in place if you're in the middle square.
Pick any square that's closer to your opponent's piece than the square you're in now, measured using straight-line distance between square centers (this includes the square your opponent is in). Move to that square.
Pick any square that's further from your opponent's piece than the square you're in now, measured using straight-line distance between square centers. Move to that square.
If you are on a corner square (1, 3, 7, or 9) move to any other corner square. Otherwise, move to square 5.
If you are on an edge square (2, 4, 6, or 8) move to any other edge square. Otherwise, move to square 5.
Indirect movement rules (may be chosen instead of a direct movement rule; at most one per game):
Move using one of the other three movement rules selected in your game, and in addition, your opponent may not use that rule on their next turn (nor may they select it via an indirect rule like this one).
Select two of the other three movement rules, declare them, and then move as if you had used one and then the other, applying any additional effects of both rules in order.
Move using one of the other three movement rules selected in your game, but if the move would cause your piece to move off the board, instead of staying in place move to square 5 (in the middle).
Pick one of the other three movement rules selected in your game and apply it, but move your opponent's piece instead of your own piece. If that movement rule says to move "your opponent's piece," instead apply that movement to your own piece. References to "your position" and "your opponent's position" are swapped when applying the chosen rule, as are references to "your turn" and "your opponent's turn" and do on.
#Game #GameDesign

STARE: Predicting Decision Making Based on Spatio-Temporal Eye Movements
Moshe Unger, Alexander Tuzhilin, Michel Wedel
https://arxiv.org/abs/2508.04148 https://

STARE: Predicting Decision Making Based on Spatio-Temporal Eye Movements
The present work proposes a Deep Learning architecture for the prediction of various consumer choice behaviors from time series of raw gaze or eye fixations on images of the decision environment, for which currently no foundational models are available. The architecture, called STARE (Spatio-Temporal Attention Representation for Eye Tracking), uses a new tokenization strategy, which involves mapping the x- and y- pixel coordinates of eye-movement time series on predefined, contiguous Regions of…

University of Toronto / McMaster University Numata Event Series, 2025-26
https://ift.tt/lKQ7trw
Conference> Chinese Buddhist Philosophy: From Three Treatises to Five Schools, 7-8 August 2025,…
via Input 4 RELCFP

Comparative Analysis of Novel NIRMAL Optimizer Against Adam and SGD with Momentum
Nirmal Gaud, Surej Mouli, Preeti Katiyar, Vaduguru Venkata Ramya
https://arxiv.org/abs/2508.04293

Comparative Analysis of Novel NIRMAL Optimizer Against Adam and SGD with Momentum
This study proposes NIRMAL (Novel Integrated Robust Multi-Adaptation Learning), a novel optimization algorithm that combines multiple strategies inspired by the movements of the chess piece. These strategies include gradient descent, momentum, stochastic perturbations, adaptive learning rates, and non-linear transformations. We carefully evaluated NIRMAL against two widely used and successful optimizers, Adam and SGD with Momentum, on four benchmark image classification datasets: MNIST, Fashion…

BiFuzz: A Two-Stage Fuzzing Tool for Open-World Video Games
Yusaku Kato, Norihiro Yoshida, Erina Makihara, Katsuro Inoue
https://arxiv.org/abs/2508.02144 https://

BiFuzz: A Two-Stage Fuzzing Tool for Open-World Video Games
Open-world video games present a broader search space than other games, posing challenges for test automation. Fuzzing, which generates new inputs by mutating an initial input, is commonly used to uncover failures. In this study, we proposed BiFuzz, a two-stage fuzzer designed for automated testing of open-world video games, and investigated its effectiveness. The results revealed that BiFuzz mutated the overall strategy of gameplay and test cases, including actual movement paths, step by step.…

This comes down to the cyberlibertarian roots of most digital movements (thing Archive.org, EFF, EDRI etc.): To them "open" is a value in itself and any political values are read as "restrictions" or "regulation" or "lack of freedom".
https://indieweb.social/@jaredw…

Anatomy of a mass disappearance in Mexico -- EL PAÍS English https://english.elpais.com/international/2025-06-28/anatomy-of-a-mass-disappearance-in-mexico-mom-i-fell-into-the-hands-of-the-mafia.htm…

Anatomy of a mass disappearance in Mexico: ‘Mom, I fell into the hands of the mafia’
EL PAÍS reconstructs the last movements of a group of 40 migrants from Cuba, Honduras and Ecuador who disappeared on December 21, 2024, in San José El Hueyate, on the coast of Chiapas. Six months later, no authorities have begun to search for them.

Park Discovery II 🏞️
公园探险 II 🏞️
📷 Nikon FE
🎞️Lucky SHD 400
buy me ☕️ ?/请我喝杯☕️？
#filmphotography

Yiding Cao Geld mit PayPal.Me senden
Folgen Sie dem Link PayPal.Me/dingsterdingster und geben Sie den Betrag ein. Es ist bequem und sicher. Sie haben noch kein PayPal-Konto? Kein Problem.

LLM coding is the opposite of DRY
An important principle in software engineering is DRY: Don't Repeat Yourself. We recognize that having the same code copied in more than one place is bad for several reasons:
1. It makes the entire codebase harder to read.
2. It increases maintenance burden, since any problems in the duplicated code need to be solved in more than one place.
3. Because it becomes possible for the copies to drift apart if changes to one aren't transferred to the other (maybe the person making the change has forgotten there was a copy) it makes the code more error-prone and harder to debug.
All modern programming languages make it almost entirely unnecessary to repeat code: we can move the repeated code into a "function" or "module" and then reference it from all the different places it's needed. At a larger scale, someone might write an open-source "library" of such functions or modules and instead of re-implementing that functionality ourselves, we can use their code, with an acknowledgement. Using another person's library this way is complicated, because now you're dependent on them: if they stop maintaining it or introduce bugs, you've inherited a problem, but still, you could always copy their project and maintain your own version, and it would be not much more work than if you had implemented stuff yourself from the start. It's a little more complicated than this, but the basic principle holds, and it's a foundational one for software development in general and the open-source movement in particular. The network of "citations" as open-source software builds on other open-source software and people contribute patches to each others' projects is a lot of what makes the movement into a community, and it can lead to collaborations that drive further development. So the DRY principle is important at both small and large scales.
Unfortunately, the current crop of hyped-up LLM coding systems from the big players are antithetical to DRY at all scales:
- At the library scale, they train on open source software but then (with some unknown frequency) replicate parts of it line-for-line *without* any citation [1]. The person who was using the LLM has no way of knowing that this happened, or even any way to check for it. In theory the LLM company could build a system for this, but it's not likely to be profitable unless the courts actually start punishing these license violations, which doesn't seem likely based on results so far and the difficulty of finding out that the violations are happening. By creating these copies (and also mash-ups, along with lots of less-problematic stuff), the LLM users (enabled and encouraged by the LLM-peddlers) are directly undermining the DRY principle. If we see what the big AI companies claim to want, which is a massive shift towards machine-authored code, DRY at the library scale will effectively be dead, with each new project simply re-implementing the functionality it needs instead of every using a library. This might seem to have some upside, since dependency hell is a thing, but the downside in terms of comprehensibility and therefore maintainability, correctness, and security will be massive. The eventual lack of new high-quality DRY-respecting code to train the models on will only make this problem worse.
- At the module & function level, AI is probably prone to re-writing rather than re-using the functions or needs, especially with a workflow where a human prompts it for many independent completions. This part I don't have direct evidence for, since I don't use LLM coding models myself except in very specific circumstances because it's not generally ethical to do so. I do know that when it tries to call existing functions, it often guesses incorrectly about the parameters they need, which I'm sure is a headache and source of bugs for the vibe coders out there. An AI could be designed to take more context into account and use existing lookup tools to get accurate function signatures and use them when generating function calls, but even though that would probably significantly improve output quality, I suspect it's the kind of thing that would be seen as too-baroque and thus not a priority. Would love to hear I'm wrong about any of this, but I suspect the consequences are that any medium-or-larger sized codebase written with LLM tools will have significant bloat from duplicate functionality, and will have places where better use of existing libraries would have made the code simpler. At a fundamental level, a principle like DRY is not something that current LLM training techniques are able to learn, and while they can imitate it from their training sets to some degree when asked for large amounts of code, when prompted for many smaller chunks, they're asymptotically likely to violate it.
I think this is an important critique in part because it cuts against the argument that "LLMs are the modern compliers, if you reject them you're just like the people who wanted to keep hand-writing assembly code, and you'll be just as obsolete." Compilers actually represented a great win for abstraction, encapsulation, and DRY in general, and they supported and are integral to open source development, whereas LLMs are set to do the opposite.
[1] to see what this looks like in action in prose, see the example on page 30 of the NYTimes copyright complaint against OpenAI (#AI #GenAI #LLMs #VibeCoding