Mastodawn

via #AIFoundry : Build agents you can trust across any framework with open evals and a control standard

https://ift.tt/WPLrZFA
#AI #GenerativeAI #Foundry #MicrosoftFoundry #ASSERT #AC S #AgentControlSpecification #AgentGovernanceToolkit #OpenSource #PolicyDrivenEvaluation #Sa…

Build agents you can trust across any framework with open evals and a control standard | Microsoft Foundry Blog

Learn how Microsoft helps developers build trustworthy AI agents with open evaluations, portable runtime controls, production observability, and security workflows that work across frameworks.

Microsoft Foundry Blog

AIagent.at 🤖 AI News 1d ago

#Microsoft launched #ASSERT, an #opensource framework that simplifies #testing #AI behaviour for specific products or services. ASSERT uses natural-language descriptions to generate tests, score results, and record AI system paths, helping developers ensure their AI behaves as intended. This tool addresses the need for application-specific evaluations, complementing broader, more general evaluations. https://techcrunch.com/2026/06/02/new-microsoft-tool-lets-devs-spin-up-ai-behavior-tests-using-text-descriptions/?AIagents.at #AIagent #AI #ML #NLP #LLM #GenAI

New Microsoft tool lets devs spin up AI behavior tests using text descriptions | TechCrunch

Microsoft on Tuesday took the wraps off Adaptive Spec-driven Scoring for Evaluation and Regression Testing, an open source framework for spinning up AI evaluations.

TechCrunch

Osna.FM 1d ago

Annalena Baerbock, the President of the UN General Assembly, is calling for significant structural reforms to the UN Security Council. Speaking to Politico, she... https://news.osna.fm/?p=49011 | #news #assert #baerbock #calls #combat

Baerbock Calls for UN Security Council Reform to Combat Gridlock and Assert Global Credibility - Osna.FM

Annalena Baerbock calls for urgent UN Security Council reform. Discover her demands for a more representative and effective global body.

Osna.FM

Show thread

leonardo m.6d ago

Solution to my BP 59: the left boxes represent 15 puzzle states that can be solved. The configurations in the boxes on the right can't be solved.

The 15 puzzle moves invariant:

"The invariant is the parity of the permutation of all 16 squares plus the parity of the taxicab distance (number of rows plus number of columns) of the empty square from the lower right corner. This is an invariant because each move changes both the parity of the permutation and the parity of the taxicab distance."

I've found the parity with a little Python function:

def permutation_parity(perm):
n = len(perm)
#assert sorted(perm) == list(range(1, n + 1))
n_inversions = 0
for i in range(n):
for j in range(i + 1, n):
if perm[i] > perm[j]:
n_inversions += 1
return 'even' if n_inversions % 2 == 0 else 'odd'

Detailed box contents:

State of Box 2:
(3, 11, 1, 15)
(7, 6, 4, 9)
(8, 12, 0, 2)
(13, 14, 10, 5)
permutation = odd
taxicab_distance = 1 + 1 = 2 = even
odd + even = odd

State of Box 8:
(5, 12, 11, 15)
(13, 4, 7, 1)
(2, 0, 14, 6)
(3, 9, 10, 8)
permutation = odd
taxicab_distance = 2 + 1 = 3
odd + odd = even

#bongardproblem #mathpuzzle #puzzle #visualmath

15 puzzle - Wikipedia

Osna.FM May 14

The Karlspreis (Karl Prize) was presented on Thursday in the Aachen Town Hall's coronation hall to Mario Draghi, the former President of the European Central Ba... https://news.osna.fm/?p=45946 | #news #assert #calls #draghi #euro

Draghi Honored for Euro Stability as Merz Calls on Europe to Assert Global Power - Osna.FM

Read how Mario Draghi received the Karlspreis and what CDU's Friedrich Merz said about strengthening Europe's power and stabilizing the Euro.

Osna.FM

N-gated Hacker News Mar 28

🚀 New #C++26 feature: a user-friendly #assert macro! Because, obviously, developers have been desperately waiting for a fluffy, hand-holding version of assert to validate the runtime conditions of their existential dread. 🙄 So, next time your code implodes, at least it will do so with a polite apology. 🤦‍♂️
https://www.sandordargo.com/blog/2026/03/25/cpp26-user-friendly-assert #macro #newfeature #developerhumor #programminglife #runtimevalidation #HackerNews #ngated

C++26: A User-Friendly assert() macro

C++26 is bringing some long-overdue changes to assert(). But why are those changes needed? And when do we actually use assert, anyway? At its core, assert() exists to validate runtime conditions. If the given expression evaluates to false, the program aborts. I’m almost certain you’ve used it before — at work, in personal projects, or at the very least in examples and code snippets. So what’s the problem? The macro nobody treats like a macro assert() is a macro — and a slightly sneaky one at that. Its name is written in lowercase, so it doesn’t follow the usual SCREAMING_SNAKE_CASE convention we associate with macros. There’s a good chance you’ve been using it for years without ever thinking about its macro nature. Macros, of course, aren’t particularly popular among modern C++ developers. But the issue here isn’t the usual - but valid - “macros are evil” argument. The real problem is more specific: The preprocessor only understands parentheses for grouping. It does not understand other C++ syntax such as template angle brackets or brace-initialization. As a result, several otherwise perfectly valid-looking assertions fail to compile: 1 2 3 4 5 6 7 // https://godbolt.org/z/9sqM7PvWh using Int = int; int x = 1, y = 2; assert(std::is_same<int, Int>::value); assert([x, y]() { return x < y; }() == 1); assert(std::vector<int>{1, 2, 3}.size() == 3); Each of these breaks for essentially the same reason: the macro argument parsing gets confused by commas or braces that aren’t wrapped in an extra pair of parentheses. You can fix each of them, of course, by adding an extra pair of parentheses. For example the last assertion would become assert((std::vector<int>{1, 2, 3}.size() == 3)); - you can play with the examples here. But let’s be honest: this is ugly, easy to forget, and not exactly beginner-friendly. Sure, after hitting the problem once or twice, most people internalize the workaround — just like with the most vexing parse. Still, it’s unnecessary friction for such a fundamental utility. P2264R7: Making assert less fragile This is where Peter Sommerlad’s proposal, P2264R7, comes in. The proposal fixes the assert macro by redefining it as a variadic macro using __VA_ARGS__. Instead of accepting a single parenthesized expression, assert now takes (...) as its parameter. That small change makes all the previously broken examples just work — no extra parentheses required. What about diagnostic messages? Originally, the proposal allowed users to attach diagnostic text via the comma operator, similar to static_assert. That idea didn’t survive the review phase. Instead, there is a mechanism to prevent the use of the comma operator on a top level, so you cannot accidentally create always true assertions like this: 1 assert(x > 0 , "x was not greater than zero"); Something that you could very easily create from an existing static_assert. So if we want to have some diagnostics, we still have to use the && operator instead: 1 assert(x > 0 && "x was not greater than zero"); This keeps the semantics clear and avoids subtle bugs. But aren’t contracts coming? One common objection addressed in the proposal is the claim that assert is obsolete in a future with contracts. Contracts will be great. But they won’t make assert disappear overnight. Just as concepts didn’t eliminate SFINAE or older template techniques — they simply gave us better tools — contracts won’t erase assert either. Assertions will continue to exist in real-world codebases, whether directly or wrapped inside higher-level precondition utilities. Improving assert is still valuable, especially when the changes are small, simple, and easy to backport. If you’re curious, the paper discusses several other potential concerns in detail; you can find them in the section on potential liabilities of the proposed change. Compatibility and availability Importantly, this change does not break existing code. All previously valid usage patterns remain valid — the proposal merely enables new, less fragile ones. At the time of writing, (February 2026), none of the major compilers support this feature yet. As with many C++26 improvements, it will take some time before it becomes widely available. Conclusion The C++26 update to assert() is a great example of incremental language evolution done right. It doesn’t reinvent assertions, replace them with something flashier, or force new programming models on existing code. Instead, it quietly removes a long-standing sharp edge. By making assert variadic, the language eliminates a class of surprising compilation failures, improves readability, and reduces the cognitive overhead of using a tool that every C++ developer relies on. It’s a small change — but one that makes everyday C++ just a little bit nicer to work with. Sometimes, that’s exactly the kind of progress we need. Connect deeper If you liked this article, please hit on the like button, subscribe to my newsletter and let’s connect on Twitter!

Sandor Dargo’s Blog

Hacker News Mar 28

C++26: A User-Friednly assert() macro

https://www.sandordargo.com/blog/2026/03/25/cpp26-user-friendly-assert

#HackerNews #C++26 #UserFriendly #assert #Macro #Cpp26 #HackerNews #Programming

C++26: A User-Friendly assert() macro

C++26 is bringing some long-overdue changes to assert(). But why are those changes needed? And when do we actually use assert, anyway? At its core, assert() exists to validate runtime conditions. If the given expression evaluates to false, the program aborts. I’m almost certain you’ve used it before — at work, in personal projects, or at the very least in examples and code snippets. So what’s the problem? The macro nobody treats like a macro assert() is a macro — and a slightly sneaky one at that. Its name is written in lowercase, so it doesn’t follow the usual SCREAMING_SNAKE_CASE convention we associate with macros. There’s a good chance you’ve been using it for years without ever thinking about its macro nature. Macros, of course, aren’t particularly popular among modern C++ developers. But the issue here isn’t the usual - but valid - “macros are evil” argument. The real problem is more specific: The preprocessor only understands parentheses for grouping. It does not understand other C++ syntax such as template angle brackets or brace-initialization. As a result, several otherwise perfectly valid-looking assertions fail to compile: 1 2 3 4 5 6 7 // https://godbolt.org/z/9sqM7PvWh using Int = int; int x = 1, y = 2; assert(std::is_same<int, Int>::value); assert([x, y]() { return x < y; }() == 1); assert(std::vector<int>{1, 2, 3}.size() == 3); Each of these breaks for essentially the same reason: the macro argument parsing gets confused by commas or braces that aren’t wrapped in an extra pair of parentheses. You can fix each of them, of course, by adding an extra pair of parentheses. For example the last assertion would become assert((std::vector<int>{1, 2, 3}.size() == 3)); - you can play with the examples here. But let’s be honest: this is ugly, easy to forget, and not exactly beginner-friendly. Sure, after hitting the problem once or twice, most people internalize the workaround — just like with the most vexing parse. Still, it’s unnecessary friction for such a fundamental utility. P2264R7: Making assert less fragile This is where Peter Sommerlad’s proposal, P2264R7, comes in. The proposal fixes the assert macro by redefining it as a variadic macro using __VA_ARGS__. Instead of accepting a single parenthesized expression, assert now takes (...) as its parameter. That small change makes all the previously broken examples just work — no extra parentheses required. What about diagnostic messages? Originally, the proposal allowed users to attach diagnostic text via the comma operator, similar to static_assert. That idea didn’t survive the review phase. Instead, there is a mechanism to prevent the use of the comma operator on a top level, so you cannot accidentally create always true assertions like this: 1 assert(x > 0 , "x was not greater than zero"); Something that you could very easily create from an existing static_assert. So if we want to have some diagnostics, we still have to use the && operator instead: 1 assert(x > 0 && "x was not greater than zero"); This keeps the semantics clear and avoids subtle bugs. But aren’t contracts coming? One common objection addressed in the proposal is the claim that assert is obsolete in a future with contracts. Contracts will be great. But they won’t make assert disappear overnight. Just as concepts didn’t eliminate SFINAE or older template techniques — they simply gave us better tools — contracts won’t erase assert either. Assertions will continue to exist in real-world codebases, whether directly or wrapped inside higher-level precondition utilities. Improving assert is still valuable, especially when the changes are small, simple, and easy to backport. If you’re curious, the paper discusses several other potential concerns in detail; you can find them in the section on potential liabilities of the proposed change. Compatibility and availability Importantly, this change does not break existing code. All previously valid usage patterns remain valid — the proposal merely enables new, less fragile ones. At the time of writing, (February 2026), none of the major compilers support this feature yet. As with many C++26 improvements, it will take some time before it becomes widely available. Conclusion The C++26 update to assert() is a great example of incremental language evolution done right. It doesn’t reinvent assertions, replace them with something flashier, or force new programming models on existing code. Instead, it quietly removes a long-standing sharp edge. By making assert variadic, the language eliminates a class of surprising compilation failures, improves readability, and reduces the cognitive overhead of using a tool that every C++ developer relies on. It’s a small change — but one that makes everyday C++ just a little bit nicer to work with. Sometimes, that’s exactly the kind of progress we need. Connect deeper If you liked this article, please hit on the like button, subscribe to my newsletter and let’s connect on Twitter!

Sandor Dargo’s Blog

Turbo Learn PHP Mar 5

How to Stop assert From Becoming eval in Production

assert with string runs eval. One debug leftover and your server is owned. PHP 7.2 changed it.

#php #assert #eval #security #howto #production

https://www.youtube.com/watch?v=XAO0esf0L78

How to Stop assert From Becoming eval in Production #assert

YouTube

Osna.FM Feb 15

Franziska Brantner, co‑chair of the Greens, urged Europe to increase its pace and confidence in dealings with U.S. President Donald Trump on digital independenc... https://news.osna.fm/?p=34572 | #news #amid #assert #digital #europe

German Greens Urge Europe to Assert Digital Independence Amid Trump's Rising Threats - Osna.FM

Green Party urges European self‑confidence against Trump, calling for faster digital independence under leader Franziska Brantner.

Osna.FM

Mathias Hasselmann Feb 4

Careful when using Python's `assert` statement: Normally you can use parentheses to wrap long lines in Python without using backslashes. For `assert` it doesn't work:

assert(some_condition,
"Some description")

This never fails, as Python's `assert` seens an `assert statement with a tuple as condition. This really has to be written like this:

assert some_condition, \
"Some description"

I just fell into that trap for you.

#Python #Assert #Mistakes