A research team led by Prof. Li Chao from East China Normal University has uncovered the origin of voltage decay in P2-type layered oxide cathodes. Using electron paramagnetic resonance (EPR) spectroscopy at the Steady-State Strong Magnetic Field Facility (SHMFF), the Hefei Institutes of Physical Science of the Chinese Academy of Science, the team tracked the dynamic evolution of oxygen species and clarified their direct role in structural degradation.

The findings, published in Advanced Energy Materials, provide new guidance for designing more stable sodium-ion cathodes.

P2-type sodium layered oxides (Na_xA_yTM_1-yO₂) are long considered stable for anion redox reactions compared to Li-rich O₃-type counterparts, with suppressed voltage decay. However, the team observed significant voltage decay in the high Na-content P2-type Na_0.8Li_0.26Mn_0.74O₂ during cycling—an anomaly unexplainable by existing theories.

The researchers identified a clear sequence of oxygen transformations upon charging, eventually leading to the formation of molecular O₂. While early cycles showed that this oxygen could still be reduced during discharge, with continued cycling a growing fraction of O₂ remained trapped in the discharged state. This irreversible accumulation was pinpointed as the primary driver of voltage decay and capacity loss.

In this study, EPR proved critical as it enabled noninvasive monitoring of oxygen redox behavior and revealed how reactive oxygen intermediates gradually evolve and accumulate during cycling.

EPR further exposed local structural changes: signals associated with spin interactions between manganese and oxidized oxygen became more pronounced with cycling, consistent with the development of Mn-rich and Li-rich domains. These segregation effects, exacerbated by unreduced O₂, aggravated the performance degradation.

Importantly, the team also explained why high sodium-content cathodes behave differently from their low sodium-content counterparts. In high-Na materials, insufficient interlayer spacing allows migration and vacancy growth, making them vulnerable to oxygen trapping.

By contrast, low-Na cathodes with larger spacing remain stable and show no evidence of trapped oxygen.

This study highlights the unique value of EPR in battery research and suggests that bulk modification strategies are key to mitigating voltage decay and developing high-performance cathodes for next-generation batteries, according to the team.

Provided by
Hefei Institutes of Physical Science, Chinese Academy of Sciences

Diagnostic testing is big business. The global market for testing semiconductors for defects is estimated at $39 billion in 2025. For medical lab tests, the market is even bigger: $125 billion.

Both kinds of tests have something in common, says Rohan Ghuge, assistant professor of decision science in the information, risk, and operations management department at Texas McCombs. They involve complex systems with vast numbers of components, whether they’re evaluating computer chips or human bodies.

New research from Texas McCombs suggests a new approach to testing complex systems that might save time by eliminating some unnecessary and expensive steps. “Nonadaptive Stochastic Score Classification and Explainable Half-Space Evaluation” is published in Operations Research.

Currently, a common shortcut is to conduct sequences of tests. Instead of testing every component—which isn’t practical for complex systems—a clinician might test certain components first. Each round rules out some possible problems and sets up a new round of tests.

That approach has time-consuming drawbacks, Ghuge says. “First, you might check the vital signs. Then, you come back the next day and do an ECG [electrocardiogram], then we do blood work, step by step. That’s going to take a lot of time, which we don’t really want to waste for a patient.”

What if, he wondered, a single round of tests could provide the most critical information in a fraction of the time? What if the same protocol could prove useful for chips or in clinics?

“We want something that’s highly scalable, deployable, and uniform,” he says. “You need to have it in a way that can be deployed on thousands of kinds of chips, or a first step that you give to clinicians for every patient of that kind.”

Merging success and failure

The key, Ghuge theorized, was to choose a small number of tests that could quickly classify a system’s risk level: low, medium, or high. With Anupam Gupta of New York University and Viswanath Nagarajan of the University of Michigan, he set out to design such a protocol.

Their solution was to combine two sets of tests with opposite goals. One set diagnoses whether a system is working, while the other diagnoses whether it’s failing. Together, they can provide a snapshot of risk.

“You create two lists, say, a success list and a failure list,” Ghuge says. “You combine a fraction of the first list and a fraction of the second list. You want to come up with a single batch of tests that tell you at the same time whether the system is working or failing.”

An existing medical example, he says, is the HEART Score. It rates five factors, such as age and ECG results, to quickly assess the risk that a patient with chest pain will have a major cardiac event within six weeks.

In simulations, Ghuge tested his algorithm against a sequential one on the same sets of data. His got results over 100 times as fast as the sequential algorithm, at a cost that averaged 22% higher.

“The tests are a bit more costly,” he says. “The trade-off is that you can get them done a lot faster.”

But he also notes that a single batch of tests might reduce setup costs, he says, compared with the expenses of setting up one test after another.

A next step, Ghuge hopes, is to try out his algorithm on real-life testing. A broadband internet network, such as Google Fiber or Spectrum, might use it for daily testing, to rapidly diagnose whether a system or subsystem is working.

“I come from a more theoretical background that focuses on the right model,” he says. “There’s a gap between that and applying it in practice. I’m excited to speak with people, to talk to practitioners and see if these can be applied.”

Coding with large language models (LLMs) holds huge promise, but it also exposes some long-standing flaws in software: code that’s messy, hard to change safely, and often opaque about what’s really happening under the hood. Researchers at MIT’s Computer Science and Artificial Intelligence Laboratory (CSAIL) are charting a more “modular” path ahead.

Their new approach breaks systems into “concepts,” separate pieces of a system, each designed to do one job well, and “synchronizations,” explicit rules that describe exactly how those pieces fit together. The result is software that’s more modular, transparent, and easier to understand.

A small domain-specific language (DSL) makes it possible to express synchronizations simply, in a form that LLMs can reliably generate. In a real-world case study, the team showed how this method can bring together features that would otherwise be scattered across multiple services. The paper is published in the Proceedings of the 2025 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software.

The team, including Daniel Jackson, an MIT professor of electrical engineering and computer science (EECS) and CSAIL associate director, and Eagon Meng, an EECS Ph.D. student, CSAIL affiliate, and designer of the new synchronization DSL, explore this approach in their paper “What You See Is What It Does: A Structural Pattern for Legible Software,” which they presented at the Splash Conference in Singapore in October.

The challenge, they explain, is that in most modern systems, a single feature is never fully self-contained. Adding a “share” button to a social platform like Instagram, for example, doesn’t live in just one service. Its functionality is split across code that handles posting, notification, authenticating users, and more. All these pieces, despite being scattered across the code, must be carefully aligned, and any change risks unintended side effects elsewhere.

Jackson calls this “feature fragmentation,” a central obstacle to software reliability. “The way we build software today, the functionality is not localized. You want to understand how ‘sharing’ works, but you have to hunt for it in three or four different places, and when you find it, the connections are buried in low-level code,” says Jackson.

Concepts and synchronizations are meant to tackle this problem. A concept bundles up a single, coherent piece of functionality, like sharing, liking, or following, along with its state and the actions it can take. Synchronizations, on the other hand, describe at a higher level how those concepts interact.

Rather than writing messy low-level integration code, developers can use a small domain-specific language to spell out these connections directly. In this DSL, the rules are simple and clear: one concept’s action can trigger another, so that a change in one piece of state can be kept in sync with another.

“Think of concepts as modules that are completely clean and independent. Synchronizations then act like contracts—they say exactly how concepts are supposed to interact. That’s powerful because it makes the system both easier for humans to understand and easier for tools like LLMs to generate correctly,” says Jackson.

“Why can’t we read code like a book? We believe that software should be legible and written in terms of our understanding: our hope is that concepts map to familiar phenomena, and synchronizations represent our intuition about what happens when they come together,” says Meng.

The benefits extend beyond clarity. Because synchronizations are explicit and declarative, they can be analyzed, verified, and of course generated by an LLM. This opens the door to safer, more automated software development, where AI assistants can propose new features without introducing hidden side effects.

In their case study, the researchers assigned features like liking, commenting, and sharing each to a single concept—like a microservices architecture, but more modular. Without this pattern, these features were spread across many services, making them hard to locate and test. Using the concepts-and-synchronizations approach, each feature became centralized and legible, while the synchronizations spelled out exactly how the concepts interacted.

The study also showed how synchronizations can factor out common concerns like error handling, response formatting, or persistent storage. Instead of embedding these details in every service, synchronization can handle them once, ensuring consistency across the system.

More advanced directions are also possible. Synchronizations could coordinate distributed systems, keeping replicas on different servers in step, or allow shared databases to interact cleanly. Weakening synchronization semantics could enable eventual consistency while still preserving clarity at the architectural level.

Jackson sees potential for a broader cultural shift in software development. One idea is the creation of “concept catalogs,” shared libraries of well-tested, domain-specific concepts. Application development could then become less about stitching code together from scratch and more about selecting the right concepts and writing the synchronizations between them.

“Concepts could become a new kind of high-level programming language, with synchronizations as the programs written in that language. It’s a way of making the connections in software visible,” says Jackson. “Today, we hide those connections in code. But if you can see them explicitly, you can reason about the software at a much higher level. You still have to deal with the inherent complexity of features interacting. But now it’s out in the open, not scattered and obscured.”

“Building software for human use on abstractions from underlying computing machines has burdened the world with software that is all too often costly, frustrating, even dangerous, to understand and use,” says University of Virginia Associate Professor Kevin Sullivan, who wasn’t involved in the research.

“The impacts (such as in health care) have been devastating. Meng and Jackson flip the script and insist on building interactive software on abstractions from human understanding, which they call ‘concepts.’ They combine expressive mathematical logic and natural language to specify such purposeful abstractions, providing a basis for verifying their meanings, composing them into systems, and refining them into programs fit for human use. It’s a new and important direction in the theory and practice of software design that bears watching.”

“It’s been clear for many years that we need better ways to describe and specify what we want software to do,” adds Thomas Ball, Lancaster University honorary professor and University of Washington affiliate faculty, who also wasn’t involved in the research. “LLMs’ ability to generate code has only added fuel to the specification fire. Meng and Jackson’s work on concept design provides a promising way to describe what we want from software in a modular manner. Their concepts and specifications are well-suited to be paired with LLMs to achieve the designer’s intent.”

Looking ahead, the researchers hope their work can influence how both industry and academia think about software architecture in the age of AI. “If software is to become more trustworthy, we need ways of writing it that make its intentions transparent,” says Jackson. “Concepts and synchronizations are one step toward that goal.”