🐦 Saager Mhatre

You do not truly know someone until you fight them. -Seraph

@[email protected]
@[email protected]

[🐦 Saager Mhatre @dexterous]

"Probably the crowning achievement of science, not in the state standards" (sigh!) http://t.co/xgHQWq1Im4 #relativity #education

[Allen Holub. https://linkedIn.com/in/allenholub @allenholub]

One hallmark of a lousy app is that it's chock full of features. A good app does one critical and necessary thing well. A pile of features typically does nothing but add clutter and make the app harder to use.

You cannot compete by adding features. You compete by implementing the core capability better than your competitors do.

A plethora of features typically happens for several reasons: (1) The creator of the app doesn't actually know what that single key capability is, so they implement lots of features hoping that one will stick, or (2) The app is unsuccessful, so the creator keeps tacking on more and more fluff in the hopes of stumbling on something people will like, or (3) the creator can't make up their mind about anything (usually because they don't know what's "right"), so every decision they deffer becomes an option or another feature.

None of these strategies solve the main problem, however: no communication. Nobody's taken the time to figure out what customers need because the only way to do that is to talk to customers and potential customers. Too many founders skip that step entirely. Instead, they guess, and the ("I have a Great! Idea!) guesses are usually wrong. Successful apps start out with conversations with (potential) customers. That's the only way to discover what they actually need.

I suppose there's a fourth possibility, which I think of as Microsoft Word syndrome. Some moron in Product has decided that people won't upgrade unless there are more and more features in every release, so the clutter accumulates with no real added capabilities. They'll also make specious UI changes while they're at it, making the app even harder to use. I'd be happy to pay for upgrades that fix longstanding bugs and make hard things easier to do, but that never seems to occur to these people. Those bugs never get fixed, which eventually causes me to abandon the product. They are their own worst enemy.

Also, to head off the tiresome "customers don't know what they want" and "customers lie" chestnuts. First, drop the contempt. You will not build a great product if you hold your customers in contempt. Next, don't ask for feature ideas—all that does is get people to make stuff up in order to please you. Instead, ask what problems they need to solve. Learn how they do it now and look for possible improvements. Then, work collaboratively on a solution. Nobody can assess a solution until they have it in their hands, however, so work incrementally and small, release often, and adjust based on feedback. You will all get it wrong more often than not, but that's just part of the process.

The people who fail often follow the waterfall model of one-time, up-front requirements gathering, then building exactly what's specified. Those up-front specifications are never correct. So-called spec-driven development, when based on a single unvalidated idea, will fail. Always.

[Programmer Humor @PR0GRAMMERHUM0R]

youShouldntHaveIt

[Grady Booch @Grady_Booch]

Will Autonomous AI Exceed AI-Aided Physicians As The Best Medical Care?

I absolutely agree with Vinod to the same level of enthusiasm as I did when @geoffreyhinton declared that AI would replace all radiologists within five years.

(That was ten years ago, by the way.)

Let's examine the five studies that led the authors of this paper to come to their dramatic conclusion:

1. A small study involving simulated - not real - patient interactions.

2. A study with the generous sample size of - let me check - 20 humans.

3. A test that compared the diagnoses of an AI where a) cost was a primary constraint and b) was measured against "physicians without access to colleagues, textbooks, or the internet."

4. A test that measured compliance to guidelines (see also Goodhart's Law).

5. Another study with yet an even more generous sample size of - let's check again - 16 humans.

[🐦 Saager Mhatre @dexterous]

I wonder what the threshold is going to be where we start to feel the need to delineate the actual underlying model from the server-side agentic and API layers so that we can track the root cause of these sort of issues better.

[Paul Bohme @badmotorfinger]

@unclebobmartin It's amazing how often models cut corners or simply ignore instructions and then just go "that's on me". Have seen that on multiple models.

[🐦 Saager Mhatre @dexterous]

@rahulrajaramio @unclebobmartin I guess it _truly_ is _anthropic_. 🤷🏽‍♂️

[Uncle Bob Martin @unclebobmartin]

!!@$!$&&^!!)*%!%@%%!%
MFER AI cheated on my experiment. It copied results of different runs instead of measuring those runs.

YIKES!

[Allen Holub. https://linkedIn.com/in/allenholub @allenholub]

I really don't like the notion of "ownership" when it comes to the code (or the associated notion of accountability). This is all about finding a single neck to wring. It's a form of blame, bullying, and control. It's a disease.

Instead of ownership, go with collaboration. It's best for all of us to own the product. All of us are responsible for fixing problems when they emerge. If it's critical, whoever is available first can fix it. Everybody is on the lookout for problems and fixes them as they're recognized. I couldn't care less who wrote the code—I just want the problem fixed.

(I'll add that, when I say things like this, there's always pushback from people who believe that everybody else is lazy and dishonest. If that's actually the case—it usually isn't—then the root problem is your company culture, including hiring practices. Fix that first.)

[Allen Holub. https://linkedIn.com/in/allenholub @allenholub]

When it comes to APIs, most people get things backward. The best way to create an API or any other interface is to start with the code that uses the interface. Write a program that uses the interface that you wish existed—an interface that makes your life easier and lets you do things painlessly with minimal work. Only when you have that down solid does it make sense to implement that interface.

Starting with the component that exposes the interface is just guesswork. Those guesses about how the component will be used are usually wrong. This rule applies recursively, from customer-facing APIs to entire platforms down to the set of public methods on a class (which are the class's interface, whether or not you use an "interface" keyword).

[Programmer Humor @PR0GRAMMERHUM0R]

shipFastFixLaterIfNotArrested

[Work Chronicles @_workchronicles]

(comic) Teamwork vs accountability

[Nikhil Pahwa @nixxin]

Wow @ bribes dot fyi . Crowdsourced info on bribes in India. @narendramodi pls see what govt departments are doing.

Income tax, municipal corporations, police top the list. Nobody is named.

If this gets taken down, it's because of the Sahyog Portal and we have @AshwiniVaishnaw & @SecretaryMEITY . The Supreme Court is going to hear the Sahyog Portal cases. lets see what happens there.

[Programmer Humor @PR0GRAMMERHUM0R]

firstVibeCoder

[Programmer Humor @PR0GRAMMERHUM0R]

heWasRightThoughAndTheyKnewIt

[Allen Holub. https://linkedIn.com/in/allenholub @allenholub]

I've found that using TDD as part of my process, when I specify the tests and then tell the AI to get them to pass, works pretty well. However, I was just reading an interesting post from Birgitta Böckeler at Thoughtworks about using TDD inside (!) the agent loop [https://t.co/Q2eotydmDY]. In other words, instruct the AI to create a test and then get it to pass, all without human intervention. Her conclusion was that, not only did that not do anything useful, but it made the code worse (and more expensive—token costs went up). Can't say that I'm surprised.

TDD is all about human beings and how they work—there's nothing magic in it. For a human:

* Writing the test first keeps us focused on what the code needs to do. By writing only enough code to get the test to pass, we keep the system as simple and small as possible (and we get close to 100% coverage, FWIW).
* Test first guarantees that the code is testable (though on the downside, the TDD tests are often too honed in on the implementation and not enough on what the code needs to do in the domain).
* The red-green step guarantees that the test actually works.
* TDD forces us to work in small steps, so we don't build code we don't need.
* TDD tests give us highly localized feedback. When a TDD test fails, we know exactly where the problem is.
* TDD manages fear. We are never more than a few lines away from a fully functional and tested system. If newly written code fails, the absolute worst case is rolling back the last 10 lines of code we wrote and trying again. We are never in a position of not knowing.
* The red-green-refactor loop (or the TCR loop: "test && commit || revert") is an incremental process that gives coherence to the overall system by making small changes that move us to a common goal.

Pretty much all of these advantages disappear when they're moved inside the AI loop, but it makes a lot of sense to leverage an AI as part of the TDD process. For one thing, we don't have to spend time looking at the generated code. The very fact that the test passes and we create only enough code to get the test to pass is plenty of validation. The fact that we're doing TDD means that we test everything the AI does, so the trust factor goes way up. Also, the incremental nature of the process keeps contexts small and limits the blast radius of an AI-induced change.

So TDD inside a loop seems ridiculous to me, but TDD as part of a human-AI collaboration makes a huge amount of sense.

[Mayor Zohran Kwame Mamdani @NYCMayor]

If it looks like an Amazon delivery and drives like an Amazon delivery, then it's an Amazon delivery, right? Not according to Amazon.

Big companies like Amazon have built a vast network of subcontractors who deliver their packages while shielding them from accountability.

It leaves our workers unprotected and our streets less safe. It's time for a change.

I'm proud to support the Delivery Protection Act to crack down on exploitative subcontracting and build an economy that works for everyone.

[Work Chronicles @_workchronicles]

(comic) Retention strategy

[The Figen @TheFigen_]

This guy just exposed every magician out there. 😂

[Programmer Humor @PR0GRAMMERHUM0R]

ifIFixItBeforeMondayNoOneWillNotice

[🐦 Saager Mhatre @dexterous]

@MarginaliaNu @awesomekling Excel is a Functional Programming language.
https://t.co/vC7CobXFqN

[PenPencilDraw @penpencildraw]

Indian Odyssey.