Ars Technica is written by humans. Our reporting, analysis, and commentary are human-authored.

After multiple weeks of internal testing and no regressions in the set of evaluations we ran, we felt confident about the change and shipped it alongside Opus 4.7 on April 16.

We have been calling this the 'reasoning' / 'non-reasoning' split, but this is not a perfectly clean dichotomy. Several correlated but not strictly identical changes happened over the same few months: scaling inference compute, heavier use of RL in post-training, and models producing reasoning tokens.

The three metrics where we find acceleration are concentrated in programming and mathematics.

The Prompt API isn't available in Web Workers for now, due to the complexity of establishing a responsible document for each worker in order to check the permissions policy status.

I would put venture capitalist in finite demand & open loop. There's only a certain amount of venture capital dollars entering the ecosystem in a year, & investment selection remains an open problem.

Writing code is not the same as software development. This is only capturing some level of acceleration while writing code, and does not capture time taken in architecture, debugging, review, and deployment.

agent-written code introduces more security vulnerabilities than code authored by humans

Large language models live in a similar perpetual present. They emerge from training with vast knowledge frozen into their parameters but they cannot form new memories – cannot update their parameters in response to new experience.

Public models can already spot that a security-relevant check is missing in the right code path, but they can still miss the actual invariant being violated and therefore misstate the impact.

What happens is that weak models hallucinate (sometimes causally hitting a real problem) that there is a lack of validation of the start of the window... without understanding why they, if put together, create an issue.

In one U.S. survey, 40% of employees said they had received 'workslop', i.e. AI-generated content that looks polished but isn't accurate or useful, in the past month.

She also tried to hire a painter in Afghanistan through Taskrabbit by accident because she couldn't navigate a dropdown menu.

She also tried to hire a painter in Afghanistan through Taskrabbit by accident because she couldn't navigate a dropdown menu.

Every AI-generated design has the same tell: it doesn't look like your product. Components are invented. Spacing is arbitrary.

We identify three fundamental bottlenecks in current DLMs: (1) Low introspective consistency. SDAR: 0.699 vs. I-DLM: 0.984. (2) Compute inefficiency. TiDAR: ~7.8x overhead vs. I-DLM: ~2.5x. (3) Infrastructure mismatch. SDAR slope=84 vs. I-DLM: 549.

Legacy platforms rely on brittle, hand-written rules. An engineer writes a detection rule : 'if events A, B, & C happen in sequence, fire an alert.' It works for a couple months.

I would put venture capitalist in finite demand & open loop.

Luna could observe the shop through security camera screenshots, but still made basic mistakes, including selecting the wrong country when hiring a contractor and mismanaging staff schedules during opening weekend.

In Messi Legacy repos, low confidence should be flagged early. Better to be transparent than open a bad pull request.

AI models can win a gold medal at the International Mathematical Olympiad but cannot reliably tell time—an example of what researchers call the jagged frontier of AI.

We did not collect detailed examples of specific tasks, but these results provide an early, nationally representative snapshot of how AI is reshaping work at the task level.

Without experience with compiler behavior, the agent couldn't have predicted which 'optimizations' the compiler would already handle.

data and analytics agents are essentially useless without the right context – they aren't able to tease apart vague questions, decipher business definitions, and reason across disparate data effectively.

A traditional semantic layer in the context of BI is great for specific metric definitions (like revenue, churn, ARPU). However, they are usually hand constructed by data teams using very specific syntax through a dedicated layer like LookML and are connected directly to a BI tool like Looker.

While model capabilities have improved dramatically for use cases like codegen and mathematical reasoning, they still lag behind on the data side (as evidenced through SQL benchmarks like Spider 2.0 and Bird Bench).

In a single run, most models—including earlier versions of GLM—give up quickly: they produce a basic skeleton with a static taskbar and one or two placeholder windows, then declare the task complete.

Agents show only ~10% success on instances with PoCs longer than 100 bytes, which represent 65.7% of the benchmark

Most skills require you to install a dedicated CLI. But what if you aren't in a local terminal? ChatGPT can't run CLIs. Neither can Perplexity or the standard web version of Claude.

Some advanced Excel capabilities aren't supported yet, including Office Scripts, Power Query, and Pivot/Data Model, data validation, and the named ranges manager, slicers, timelines, external connection administration, advanced charting breadth, and macro/Visual Basic for Applications (VBA) automation.

This problem is compounded for proprietary reasoning APIs that expose neither logits nor intermediate token probabilities, leaving practitioners with no reliable uncertainty signal at inference time.

Sellers say that while AI tools have made it easier to come up with ideas and get a business off the ground, they do not replace the core skills that make someone good at e-commerce.

The issue isn't that models are bad at reading documents. It's that single-pass extraction has no mechanism to catch its own mistakes, and models get lazy.

most existing large language model agent systems face severe limitations in data-intensive settings, including context saturation, cascading error propagation, and high end-to-end latency

the inherent limitations of such a single-paradigm approach pose a fundamental challenge for existing models

concerns about proper teacher training and support, subscription costs for some AI/LLM models, student hyper-dependence, ongoing, often significant, inaccuracies and errors created by AI/LLM, and other developmental and implementation issues.

While this study concludes that, along with profit maximization, the firm is duly responsible for benefitting all of their stakeholders, which ultimately boosts the economic well-being and long-term value creation of the CSR-practicing firms [119].

t was conducted in a school in Paschim Medinipur District, WestBengal, India. Therefore, the sample was collected from a small geographical location.

we have all of these huge applications that are gathering all this data uh and it's out there and theoretically is our data sort of but in reality they control it and you can't actually link the data to each other you only link to accessing the data through their application

if I send you a Google doc and we start all collaborating in the same same thing and it's amazing we're sharing all this data um it's kind of silly that we have to move the updates through the backb to some server out there and shipping them back here when we now have really sophisticated algorithms that can do um you know smart Conflict Free resolution that allows us to collaborate in real time and yet we're still moving all the updates to the backbone right this is very silly and it gets worse when you think about the network falling apart

let's go and and create all this great software to deploy it and kind of equalize the the the disparity of wealth across the world and ends up being locked out for by stupid issues like latency and bandwidth

something like Gangam Style has been viewed to the tune of like almost or over two billion times and when you just when you count just the data coming out of Google servers let alone all the links we're dealing with something close to 500 pedabytes of data that's a lot for a video right I mean this is clearly an issue there's no reason we should be moving around all of this data constantly through the network

The notion of pure altruism attempts to create a dichotomy between the self and others, implying that true selflessness is possible. Yet, in reality, individuals exist within a web of relationships and mutual dependencies.

Een chunk (letterlijk ‘brok’) is een verzameling elementen die sterke associaties met elkaar hebben. Samen vormen ze een betekenisvolle informatie-eenheid. Die chunks, groot of klein, gebruiken we in ons interne informatieverwerkings- en geheugensysteem. Ons brein houdt namelijk van logica en voorspelbare patronen. Het opdelen van informatie gebeurt automatisch en continu, maar kan ook bewust worden ingezet. Dat heet doel-georiënteerde chunking.Ons brein kan slechts een aantal zaken opslaan in het kortetermijngeheugen. Maar door veel gegevens te groeperen in kleinere brokjes informatie, kunnen we de limieten van ons geheugen uitdagen. En dus meer informatie verwerken en onthouden.

Positionality

The snag is that when the top-level match grabs the published_at value and applies it to the be_within(...), it is working with a string representation of the timestamp. We first need to parse that into a date object and there is no affordance for that here.

There have been many attempts over the years to address the limitations of an overly ‘linear’ approach to ToC diagramming

On Windows, that interface doesn't really exist (and is really difficult to emulate properly)

As Ramadiro worked his way through this period, he reached severaloverarching conclusions about the available materials. He concluded that muchof the available materials had been written in English, and back-translated toisiXhosa, and as such were not based on the linguistic logic of isiXhosa. They didnot take advantage of the home (oral) language resources of children in isiXhosaas the basis to build reading and writing skills. Second, taken together they didnot constitute a balanced reading programme guided by contemporary readingresearch (Pressley, 2006). There was no set of materials that combined a wholereading approach with systematic language skills (phonics, grammar etc.) inBefore... After...

Certainly, multimedia technology brings about improvement in teaching and learning, however, there are a number of limitations in this technology for educational purposes. Some of these limitations include unfriendly programming or user interface, limited resources, lack of required knowledge and skill, limited time and high cost of maintenance among others (Al-Ajmi and Aljazzaf, 2020; Putra, 2018).

Abstract

Multiline scripts (we mostly target one-liners)

“…” would be cool, but (unless I’ve missed something in Ruby 3.2+), it can only delegate all args, and foo(1, …) is impossible.

whitehead says that philosophy is an attempt to express the infinity of the universe in terms of the limitations of language

A user notices that an unchanged part of the diff already has features that are being implemented in the changes in the MR. The user leaves a comment on the unchanged part of the diff, telling the author that what they're trying to do is already present. Problem: The author cannot see that comment in the Changes tab, because the comment is outside the understood scope of the diff.

It can sort of be achieved with the current setup (via labels), but I really like where this is going -- turning everything into a similar "object" in a hierarchy rather than separate standalone structures that connect and get "labeled" to show what they are.

Enable ActiveRecord unsigned integers to use 8 bytes instead of 4. This fixes the ActiveModel::RangeError problem where AR models with perfectly fine 8 bytes primary keys are taken for ActiveModel::Type::Integer with a default limit of 4 bytes.

Annoyingly, git fetch --depth=<N> won't pick up new tags

While this works, it’s not a great developer experience. In development, we don’t always know ahead of time all the packages that need to be linked. Or keep track of the previously linked packages.This confusing behavior compounds to the poor usability and predictability of npm link.

I know that Devise offers these capabilities, but it's hard to make out how to do it without hitting their preconfigured (view?) routes.

At the same time, the vision of a good life for all integrates our in-dividual pursuit of this goal with an immediate concern for others.In other words, we can enjoy and exercise freedoms only to the extentthat doing so does not impinge on others. Achieving this vision under-lines both the crucial role of freedom but also the necessity of limitsfor this freedom to exist. Thereby, pursuing the vision of a good lifefor all has the potential of bridging current political divides, as it is avision that all people can adhere to.

Common sense is actually a pretty bad indicator of truth. Because of cognitive biases and preconceived opinions, ideas that sound right are often wrong. “Common sense is actually nothing more than a deposit of prejudices laid down in the mind prior to the age of eighteen,” Einstein presumably said.

we have onlyvery limited capabilities of predicting emissions fu-tures due to the inherent complexities and contin-gencies of social dynamic

Using a modified version of Köhler’s method, recent research has found that in 2015 drain from the South through unequal exchange amounted to $2.1 trillion (constant 2011 dollars), represented in Northern prices (Hickel et al., 2021). Köhler’s proxy approach is limited in several respects, however. It relies on PPP figures that do not adequately account for the comparatively high prices of Northern exports; it relies on GDP figures that are affected by the low prices of imports from the South; and it compares Southern exports to prices across whole economies, rather than to those of only traded goods. All of this leads to underestimating the scale of drain (see Hickel et al., 2021).

Human choices and actions could narrow or widen the safe and just corridor for human development. Considering the complex interactions, feedbacks, and non-linearities within and between societal activities and Earth system behavior, we need to advance beyond previous frameworks such as the “donut” (Raworth, 2018) to understand when “safe” and “just” ranges do and do not overlap.

Aleatoric music (also aleatory music or chance music; from the Latin word alea, meaning "dice") is music in which some element of the composition is left to chance, and/or some primary element of a composed work's realization is left to the determination of its performer(s). The term is most often associated with procedures in which the chance element involves a relatively limited number of possibilities.

I understand that multiple -f options fits almost the bill, but it doesn't always work. For example, I rather often change the name of the abstract service into something that is more meaningful in the context of the project at hand. This is something that the overriding that occurs with multiple -f options does not support.

Procs can't accept blocks as implicit arguments (the format you're trying). A proc can receive other proc objects as arguments, either explicitly, or using & arguments. Example: a = Proc.new do |&block| block.call end a.call() {puts "hi"}

yield is a bit of laguage level magic that only works in the context of a method.

Note: it is not possible to apply a boolean scope with just the query param being present, e.g. ?active, that's not considered a "true" value (the param value will be nil), and thus the scope will be called with false as argument. In order for the scope to receive a true argument the param value must be set to one of the "true" values above, e.g. ?active=true or ?active=1.

Do you know about lacolhost.com? as in, do something like blerg.lacolhost.com:3000/ as your url and it'll resolve to localhost:3000, which is where your tests are running.

As you note, Activity diagrams inherently can include concurrency and timing. If you look at this example cribbed from Wikipedia, shown below, you can observe the section with two heavy horizontal bars, and two parallel activities of "present idea" and "record idea". That is read as "start these activities in parallel, and continue only when both are complete." Flowcharts can't express this within the notation. Practically, using activity diagrams lets you think clearly about concurrent processes. I think you'll find that anyone who can read a flowchart will quickly adapt.

Examining some assumptions and limitations of research on the effects of emerging technologies for teaching and learning in higher education

That’s fine and dandy if you’re running in production and have a publicly accessible address such as your domain name but what about during development?You can’t just tell Stripe to access http://localhost because that address isn’t publicly accessible to the internet.

Lucky for us, it’s super easy to use subdomains in development nowadays. http://lvh.me is a free service that resolves itself along with all subdomains to localhost.

Multiplying two objects will merge them recursively: this works like addition but if both objects contain a value for the same key, and the values are objects, the two are merged with the same strategy.

var a = document.createElement("a"); a.href = blob; a.target = "_blank"; setTimeout(function() { click(a); });

When we do release a final version of JSON Schema, please do not use JSON Schema to guarantee an OpenAPI document is valid. It cannot do that. There are numerous constraints in the written specification that cannot be expressed in JSON Schema.

the problem with docker builds is the made-up concept of "context". Dockerfiles are not sufficient to define a build, unless they are placed under a strategic directory (aka context), i.e. "/" as an extreme, so you can access any path (note that that's not the right thing to do in a sane project either..., plus it makes docker builds very slow because docker scans the entire context at start).

I would not change the project structure to accommodate Docker (or any build tools).

Issues are starting to become cluttered as we add more capabilities to them, and they are not perfect

Using labels to show issue types is cumbersome and makes reporting views more complex.

I was wondering particularly whether there is a way to have a comment on the same line as the backslash

I was already aware that images cannot be inserted in the DOM like you would any normal image. If you write <img src="https://my-pod.com/recipes/ramen.jpg">, this will probably fail to render the image. That happens because the image will be private, and the POD can't return its contents without proper authentication.

hopefully feed readers can treat permanent redirects as a sign to permanently update their feed URLs, then I can remove it. They probably don't, much like bookmarks don't

These callbacks are focused on the transactions, instead of specific model actions.

Since elements can overlap each other in a CSS grid, it doesn't even try to align them. As its name suggests, it is a grid, not a column layout.

However, when 2 elements begin at the same grid row, they overlap.

Perhaps the most interesting limitation is that you can’t target the grid area itself.

If you happen to annotate page three, and then weeks or years later visit the single page view wouldn’t you want to see the annotation you made? If the tool you are using queries for annotations using only the URL of the document you are viewing you won’t see it.

relatively nascent with numerous challenges, which have to be addressed before they can be widely acceptedand implemented.

In addition, a component that uses Svelte's built in event forwarding system cannot allow event listeners on the "capture" phase of the event lifecycle. It also cannot allow events to be cancelable with the browser's built in preventDefault function.

It's vanilla JS, doesn't bind you to specifc syntax and that's the main reason why I like svelte that it doesn't try to sandbox you into framework constraints.

I think the issue is that it's not totally perfect. It doesn't define what should happen in parent components, it's not as flexible as onError and it doesn't allow you (for instance) to nest a svelte:head inside, or decide what to do with the rest of the rendering. What do you do with <div>My component</div> in your example? What about changing the <title>? I assume you can inspect the error...does <svelte:error> allow specifying which error types to expect?

Another limitation is that you are forced into the syntax of the {#await} block. What I mean by that is that for example you can't add a loading class to a parent. You can only render stuff for the loading state in the given block. Nowhere else.

but you want to style your components yourself and not be constrained by existing design systems like Material UI

The RFC2617 model is one-user, one-credentials so the case where the user may have a second set of credentials that could be authorized may be ignored. It neither suggests nor implies that some sort of login page or other non-RFC2617 authentication protocol may or may not help - that is outside the RFC2616 standards and definition.

If you need to pass multiple arguments to an action, combine them into a single object, as in use:longpress={{duration, spiciness}}

the snap-based chromium cannot access files on my separately-mounted /opt filesystem. The non-snap chromium has no such limitation. Until or unless the snap version ever is able to access all the filesystems on my device, I am willing to live with the risk of a PPA-based version.

This works in my application where there's only one shadow-dom at the time, but it's not a generic solution.

it's always the 3rd episode in a row, 2 minutes into the 3rd.

The main problem is that the browser won't even send a request with a fragment part. The fragment part is resolved right there in the browser. So it's reachable through JavaScript.

note: when using for cross domain, requires you to be able to inject a js file into the iframe... Doesn't seem like a viable option when you don't control the iframe source.

You can add event modifiers with the on:click$preventDefault$capture={handler} syntax. If you use Svelte's native on:click|preventDefault={handler} syntax, it will not compile. You have to use "$" instead of "|". (The extra S inside the | stands for SMUI.)

Please note that the strategy: :build option must be passed to an explicit call to association, and cannot be used with implicit associations:

this happens with getClient and setClient because it is a svelte context which is only available at component initialization (construction) and cannot be in an event handler.

Known Limitations

Hello, maksimets: code blocks using triple backticks (```) don't work on all versions of Reddit!Some users see this / this instead.

This cache has a small trade-off! If we request a list of data, and the API returns an empty list, then the cache won't be able to see the __typename of said list and invalidate it.

This kind of error handling does express error state (either via HTTP 500 or by the top-level "errors" key), but it doesn’t take advantage of GraphQL’s type system and can only express one error at a time.

In mutations, when errors happen, the other fields may return nil. So, if those other fields have null: false, but they return nil, the GraphQL will panic and remove the whole mutation from the response, including the errors!

In order to have the rich error data, even when other fields are nil, those fields must have null: true so that the type system can be obeyed when errors happen.

Use this to build a ClassAdder component. ClassAdder components are useful for reducing the size of your bundle. If you have tons of simple components that just need to add classes/props or set a context, using ClassAdder components means there's only one "big" Svelte component in your bundle for all of these many tiny components.

This is useful when you need to add classes to a component, since Svelte's "class:" directives don't work on components.

That’s not the only way of writing end-to-end tests in Rails. For example, you can use Cypress JS framework and IDE. The only reason stopping me from trying this approach is the lack of multiple sessions support, which is required for testing real-time applications (i.e., those with AnyCable 😉).

While rails does have nice CSRF protection, in my instance it limited me.

Note that this proposal provides private fields and methods only as declared up-front in a field declaration; private fields cannot be created later, ad-hoc, through assigning to them, the way that normal properties can. You also can't declare private fields or methods in object literals; for example, if you implement your class based on object literals, or adding individual methods to the prototype, or using a class framework, you cannot use private methods, fields or accessors.