It's that you could LIST. Then move cursor up and edit and press enter. (Not found in ZX, but still ok).

Next, you could list, and draw CIRCLE over the program listing. It was live, like smalltalk, but simpler.

Reproducing language variants without immersion described above is not full story.

Yes, it was kinda refactoring for bigger client and his use case with bigger data. I implemented slightly different order in input data, so it now does work more serially than parallel, yes, it takes less memory, and is more cache-friendly. But that's not all.

I also moved it from row-oriented CSV to column oriented. You say good refactor! Yeah, i think so, too. Yes, that uses Clickhouse as a DB. Native Clickhouse column-oriented wire format vs any human oriented format. Yes, I gave it Clickhouse C++ source, because format however stable, is not documented in the "documentation". Yes, it created custom-tailored serializer and de-serializer, including dictionaries (low cardinality columns). Yes, i explained what I expect from it.

Yes, I asked LLM to not implement data transfer objects. Instead, it reads directly from Clickhouse native wire format, without allocations, and writes Clickhouse native wire format, without allocations. It allocates slightly when processing data itself, but I optimized it too.

Code did few passes on data, I asked LLM to perform loop fusion and do all in one pass, because, as a human, that would complicate code, and was not done before, but the client is important, you know.

It contained some suboptimal data layout IN ITS CORE, too. I played and measured several layouts, by just changing it (adding/removing few indirections here and there), all code using this CORE DATA was adapted automatically, so I did quite a few iterations evaluating best one during that morning.

Already efficient code became 20 times faster. Not because it was not efficient. But because it was legacy, human oriented, well designed, and it worked, it was java, even with fast parser/processor optimizations, reduced allocations etc - it was long maintained, it was an asset.

I just applied some transformations to it, in mostly automatic way. Yes, I can do that again.

This is called supercompilation, guys. It can be automated these days. Legacy is original generic program. Like they synthesized rocket engine using AI (see news and pictures circa year ago), we can synthesize supercompiled programs from single legacy source, given various boundary conditions.

My congratulations!

NB Supercompilation is not a cool word, it's quite old concept in IT, for example see https://sites.google.com/site/keldyshscp/Home/supercompilerconcept

PS on the "this code is liability now". Nope. Cost of maintaining this code TODAY is radically lower than ever before.

Comments URL: https://news.ycombinator.com/item?id=47497411

Points: 1

# Comments: 0

  q)x:1000
  q)\t:1000 sum (til x)=/:(til x)
  889
  q)\t:1000 sum (til x)=/:(til x)
  871
  q)\t:1000 sum (2#x)#1,x#0
  602
  q)\t:1000 sum (2#x)#1,x#0
  599

not only for mac users.

PROFIT!

- Running build pipelines: make cli tool to initiate them, monitor them and notify you on completion/error (audio). Allows to chain multiple things. Run in background terminal.

- Learning about changed process and people via zoom calls, teams chat and emails: pass logs of chats and emails to LLM with particular focus. Demand zoom calls transcripts published for that purposes (we use meet)

- Raising incident tickets for issues outside of my control: automate this with agent: allow it to access as much as needed, and guide it with short guidance - all doable via claude code + custom MCP

- Submitting forms, attending reviews and chasing approvals - best thing to automate. They want forms? They will have forms. Chasing approvals - fire and forget + queue management, same.

- Reaching out to people for dependencies, following up: LLM as personal assistant is classic job. Code this away.

- Finding and reading up some obscure and conflicting internal wiki page, which is likely to be outdated: index all data and put it into RAG, let agent dig deeper.

Most of the time you spend is on scheduling micro-tasks, switching between them and maintaining unspoken queue of checking various saas frontends. Formalize micro-task management, automate endpoints, and delegate it to your own selfware (ad-hoc tools chain you vibe coded for yourself only, tailored for particular working environment).

I do this all (almost) to automate away non-coding tasks. Life is fun again.

Hope this helps.

https://old.reddit.com/r/ChatGPTCoding/comments/1lusr07/self...

Gonna be lots of posts of selfware like that soon.

Enjoyed it.

Before, I felt mute during Zoom meetings. Now I can explain things with paper and pen. Mouse drawing was never my thing.

My friends couldn’t do the same—it’s a native app for newer Macs only. They all use different OSes or older hardware.

Spent half a day vibe coding a public version. Enjoy. Free as in beer.

Make sure to enable webcam permissions on the page.

Explanation:

=============

This tool displays a live, perspective-corrected view of your camera pointed at a sheet of paper—like a whiteboard for your meetings. Next, you share that browser tab to your colleagues.

Limitations:

===========

1. On Windows, stop using the camera in your meeting app (e.g., Zoom) to allow browser access. Not needed on Mac; possibly not needed on Linux.

2. You must tilt your laptop lid down ~45° during setup and use.

3. TODO: Allow setting up paper corners falling outside of the camera view.

Usage:

==========

• You can share the browser tab in your meeting.

• If Windows+Zoom => stop camera in zoom

• Ensure webcam feed is visible on this app/page.

• Tilt the lid, aim the camera at your paper.

(One-time setup for your paper type)

• With the lid tilted, press spacebar to hold a snapshot.

• Return the lid to upright position.

• Adjust the trapezoid corners to fit your paper.

• Press spacebar again to release the video.

• Tilt the lid again and place your paper within the trapezoid.

(End setup)

• With the lid tilted, press Enter to enter presentation mode.

Comments URL: https://news.ycombinator.com/item?id=44163482

Points: 2

# Comments: 1

Furthermore, the mechanisms that ensure the mathematical expectation of electoral outcomes to hover around a fifty-fifty split — a phenomenon observable in many nations — are fundamentally economic in nature. Both factions commit resources to the electoral contest to secure a mere one percent advantage, as such is the foundational principle of democracy: a majority of fifty-one percent prevails.

Thus, economic factors — for an electoral campaign is, in essence, a contest of capital—having, in effect, subverted the very system of democratic elections, inevitably lead to the decay of nations that religiously adhere to the mathematics of a single percentage point as the sole criterion of legitimacy. In optimizing for democratic representation, social stability and equilibrium have been forfeited.

It is akin to the psychological paradox: "I am correct, and all acknowledge it, yet why do I not experience contentment?" It is because one has optimized for correctness — or in the context of elections, for fairness and representativeness — rather than for overall well-being. Such is the predicament inherent in the pursuit of a mere fifty-one percent majority.