RSS Feeds

Norwegians gather to remember monarch whose death comes amid scandal over links between crown princess and Jeffrey Epstein

Norwegians have gathered in their thousands to pay their respects to King Harald V, Europe’s oldest reigning monarch, who has died, aged 89, in Oslo. He was succeeded immediately by his son, King Haakon VIII.

The new king thanked “the government and Norwegian people for their support and sympathy for the royal family at this time”. A period of national mourning was announced as crowds left wreaths and messages outside the royal palace in Oslo.

В двухнедельном спринте регрессия часто превращается в лотерею: фичи доделывают до последнего дня, полный прогон не помещается в окно, а красному CI уже никто не верит. В итоге команда выпускается, ориентируясь на ощущение, а не на понятную картину рисков.

Эта статья о том, как встроить регрессию в Scrum так, чтобы она работала весь спринт. Разберём анализ влияния до разработки, наборы проверок P0-P3, тестовую пирамиду, flaky tests, тестовые данные, проверки после релиза и решение о выпуске с понятным остаточным риском.

TL;DR

31 августа 2026 в 23:59 по тихоокеанскому времени заканчивается промо, которое с 13 мая держало недельные лимиты Claude Code на 50 % выше стандартных. Продлевали его трижды — 13 июля, 19 июля, 19 августа. После отмены недельная ёмкость падает примерно на треть: делить на полтора — это возврат к 67 % от привычного. Одновременно работает второй множитель, о котором говорят реже: модели Claude 4.7 и новее считают тот же самый текст примерно на 30 % дороже в токенах, а файл CLAUDE⁠.md — в 1,445 раза. Сложите одно с другим, и получите ощущение, что лимит закончился «в два раза быстрее, чем раньше», хотя формально урезали только треть.

Ниже — что именно заканчивается, с датами и ссылками на документацию Anthropic. И вторая половина, ради которой всё писалось: что с этим делать. Штатный режим «дорогая модель планирует, дешёвая исполняет» внутри самого Claude Code. Механика banked reset у Codex — она существует, но работает не так, как о ней рассказывают. GLM-5.3-Flash, она же нашумевшая Ox Alpha, — с моими собственными замерами, которые расходятся с анонсом. И Fugu от Sakana, которую почти все описывают неправильно.

Что именно заканчивается

Промо на +50 % к недельным лимитам Claude Code действует с 13 мая 2026 и заканчивается 31 августа в 23:59 PT. Anthropic продлевала его трижды, каждый раз незадолго до истечения, так что четвёртое продление исключать нельзя — но планировать на него не стоит. Арифметика возврата простая и неприятная: если сейчас ёмкость составляет 150 % от базовой, то после отмены остаётся 100 %, то есть две трети от того, к чему вы привыкли за три с половиной месяца. Это не «немного ужмут» — это треть недельного бюджета, которую придётся либо экономить, либо чем-то замещать.

In spite of capable performances and deployment of hygge, gothic and Nordic noir elements, you’ll search for a feasible plot or a character insight in vain

Adapted from the 2017 novel by Anna Ekberg (actually a male writing duo), this thriller from Denmark chucks in a bit of everything into the mix: hygge lakeside melodrama, manor-house gothic, and Nordic-noir corruption. But this franticness can’t disguise that it’s a dopey and facile thriller that, despite capable performances, plumbs neither its characters’ depths nor hits thematic pay dirt. It also merits a stiff investigation from the plotting police.

Despite amnesia that leaves her unable to remember her life prior to running an idyllic Norwegian rural cafe, Louise (Natalie Wolfsberg Madueño) is gearing up to get hitched to crime writer Joachim (Pål Sverre Hagen). When a tourist approaches and calls her by another name, she is sufficiently shaken to take a DNA test; it confirms she is actually Helene Söderberg, a Danish shipping heiress presumed dead, with a husband and son back home. Originally found stowed away on a cargo ship, she handed over an ID card – for Louise Anderson – which the authorities accepted. Now wanting to reclaim her identity, she pitches up on the capacious doorstep of company executive Edmund (Claes Bang), her former partner.

В первой части был инструмент, который снимает схему Firebird и раскладывает её деревом файлов: один объект — один файл. Он отлично отвечает на вопрос «как эта процедура выглядит сейчас» и совершенно беспомощен в вопросе «кто её поменял в среду вечером». Дамп — это фотография, а нам нужен ещё и вахтенный журнал.

Вторая часть — про журнал. Про то, какие факты об изменении схемы имеет смысл хранить прямо в базе, чем за это платишь и где закопаны грабли, на которые я наступил, чтобы вы могли их обойти.

More than 1,500 people are missing, including hundreds of foreign nationals and tourists, amid race to find survivors

• Flood rescue efforts resume

• Visual guide: how the deadly flooding unfolded

• Tell us: have you been affected by the flash floods?

More now on the Nepali army’s rescue operation to save about 100 people trapped in a tunnel at a hydropower project swamped by Wednesday’s flooding.

“Two helicopters have been dispatched but it is challenging because it is tough to even locate the entry points of the tunnel,” army spokesperson Raja Ram Basnet told AFP.

Relief efforts are also under way to provide the rescued people what they need.

The army is still working to safely evacuate more than 100 people trapped in the same tunnel.

Это означает, что существует что-то доязыковое — что-то, на чем говорит наше сознание, что-то, что позволяло людям общаться до языка. Ведь язык не создает коммуникацию, а лишь упрощает ее. Нам нужно понять, что это за явления и как их определить. 

Знаковой работой в данном направлении становится «Искусство шумов» (L’arte dei Rumori) Л. Руссоло, который выделяет роль шума (именно шума, а не звуков как таковых) как нового способа описания современной ему эпохи. Самое важное — он проводит кодирование шумов по семантизации, то есть способности заставить слушателя пережить определенный опыт.

Brother of former state premier tells Icac he sent message to his wife referring to a plan to damage the career of rival David Elliott

• Follow our Australia news live blog for latest updates

• Get our breaking news email, free app or daily news podcast

Charles Perrottet wrote about a plan to damage a Liberal minister’s career after his brother Dominic’s accession to the New South Wales premiership in October 2021, stating “we execute the prick once party room is over”, a corruption inquiry has heard.

The younger brother of the former premier told the Independent Commission Against Corruption (Icac) on Friday a message he sent to his wife two days before Dominic Perrottet was elected premier by Liberal MPs referred to a plan to oust the former Liberal police minister David Elliott.

This week’s best wildlife photographs from around the world

In this week’s newsletter: pollutants from fossil fuels and wildfires damage nearly every part of our bodies – but initiatives such as cycle zones can make our cities safer

• Don’t get Down to Earth delivered to your inbox? Sign up here

Air pollution affects nearly every person on this planet. Yet global efforts to combat the scourge – which is associated with about 8 million premature deaths worldwide every year, can damage nearly every part of our body and is linked to everything from miscarriages to dementia – lag decades behind our knowledge of its impacts.

Tens of millions of people in Indonesia are now suffering in swathes of thick smoke caused by “slash and burn” agriculture and exacerbated by the hot conditions. In India, ground-level ozone from vehicle fumes and industry has emerged as the key summer threat, while outside its megacities there have been protests in areas affected by toxic coal dust. Across the northern hemisphere this summer, wildfires driven by the climate crisis have spread poor air across continents – already, 1.5 million people globally die every year from the impacts of wildfire smoke.

Nearly 1,400 missing, mostly tourists, after Nepal-Tibet flash flood kills at least 270

Two planned datacentres will have higher UK carbon emissions than ExxonMobil, analysis finds

‘Environmental violence’: inside the fight to save indigenous land from becoming a nuclear dumping ground

From the first US and Israeli strikes six months ago to the battle for Hormuz, this timeline plots how Trump’s war on Iran quickly became a regional conflict with global economic consequences

On 28 February 2026, the US and Israel began large-scale strikes on Iran. Tehran responded by attacking Israeli and US allies across the Gulf.

Iran’s supreme leader, Ali Khamenei, was killed on the first day of strikes, and the strait of Hormuz – a crucial waterway for transporting oil – was effectively closed soon after. The conflict quickly became a regional war with global economic consequences.

Donald Trump: EPA/Trump Vance transition team

US CENTCOM: AP

Abbas Araghchi: AP

Esmail Baqaei: Getty/Anadolu

Masoud Pezeshkian: AP

Mohammad Bagher Ghalibaf: Getty/NurPhoto

Iran flag: Alamy

Newly obtained records indicate health secretary lied about Samoa trip during Senate confirmation hearings last year

A senior Democratic senator is calling for a criminal investigation into the US health secretary, Robert F Kennedy Jr, following reporting by the Guardian that indicated he lied during Senate confirmation hearings last year.

Ron Wyden of Oregon said: “RFK’s platform is built on lies and grifts that leave a trail of dead children in their wake. There are consequences for lying to Congress.”

Java concurrency is a powerful feature, but it can be difficult to get right. Writing correct multithreaded code requires a deep understanding of thread pools, synchronization, cancellation, and error propagation. Even experienced developers regularly introduce subtle bugs like thread leaks, swallowed exceptions, and race conditions that only surface under specific circumstances.

Traditionally, Java concurrency has had several limitations: 

• Scalability and resource costs from blocking threads.
• Difficulty sharing contextual data between threads safely.
• Problems managing threads such as leaks and cancellation delays.
• Concurrent code that is hard to understand, debug, and maintain.

Project Loom aims to eliminate the tradeoff between simplicity and efficiency in concurrent Java code, making it easier to write, debug, profile, and maintain code that is correct, readable, and scalable. It does this through three features that work together:

• Virtual Threads (JEP 444, stable since Java 21) – Platform threads are expensive and limited in number, making highly concurrent applications resource-heavy and hard to scale. Virtual threads are lightweight and managed by the JVM, allowing many more threads to run concurrently without the same overhead.
• Scoped Values (JEP 506, stable since Java 25) – ThreadLocal variables are mutable, hard to reason about, and prone to memory leaks. Scoped values provide immutable, automatically cleaned-up data sharing that scales efficiently with virtual threads.
• Structured Concurrency (JEP 533, seventh preview in Java 27) – Unstructured concurrency leads to thread leaks, cancellation delays, and code that is difficult to debug and maintain. Structured concurrency treats a group of related threads as a single unit of work, making cancellation and error handling predictable and consistent. It also provides a clear parent-child thread hierarchy that improves observability and makes concurrent code easier to trace and inspect.

In this post, we’ll give you an overview of these features, explain some of the problems they solve, show how they work together, and demonstrate how IntelliJ IDEA supports you along the way.

Problems with Java concurrency before Project Loom

To illustrate some of the problems with concurrency and how Project Loom can solve them, let’s look at an example of how we could write concurrent code without using any of the features of Project Loom. We’ll then rewrite this code to take advantage of these features and see how they compare.

As an example, we will use an application that loads a customer profile. It fetches order history and product recommendations for a customer in parallel. You can find the project’s source code here.

The method getProfile() in the CustomerProfileService (which you can find here) loads the customer profile using CompletableFuture to run the calls concurrently:

public CustomerProfile getProfile(String customerId) throws OrderServiceException, RecommendationServiceException {
        CompletableFuture<List<Order>> orderFuture =
                CompletableFuture.supplyAsync(() -> orderServiceClient.getOrders(customerId), executor);
        CompletableFuture<List<Recommendation>> recFuture =
                CompletableFuture.supplyAsync(() -> recommendationServiceClient.getRecommendations(customerId), executor);

        CompletableFuture<Void> allFutures = CompletableFuture.allOf(orderFuture, recFuture);

        try {
            allFutures.get(2, TimeUnit.SECONDS); // single timeout covering both futures
            return new CustomerProfile(customerId, orderFuture.join(), recFuture.join());
        }

        // catch block 

The catch block handles any exceptions. This code does what it is supposed to do: It runs the independent calls in parallel, has a timeout, and makes an effort to cancel remaining tasks on failure. But there are still several potential problems:

• Thread leaks. cancel(true) marks the future as cancelled, but for CompletableFuture the interrupt flag is ignored and the work already running in the pool continues to completion unless it was explicitly wired to a cancellation signal.
• Awkward error handling. ExecutionException wraps the real cause and must be unwrapped manually (shown in the code snippet below and also available here). The unwrapping chain will need to be updated every time a new exception type is introduced.

        catch (ExecutionException e) {
            Throwable cause = e.getCause();
            orderFuture.cancel(true);
            recFuture.cancel(true);

            if (cause instanceof RestClientResponseException ex && ex.getStatusCode().value() == 503) {
                if (orderFuture.isCompletedExceptionally()) {
                    throw new OrderServiceException("Order service unavailable", e.getCause());
                }
                if (recFuture.isCompletedExceptionally()) {
                    throw new RecommendationServiceException("Recommendation service unavailable", e.getCause());
                }
            }
            throw new RuntimeException("Unexpected error", e.getCause());

• Duplicated cancellation logic. The cancel() calls are repeated across both the TimeoutException and ExecutionException catch blocks. If any additional parallel call is added later, it needs a cancel() call in both catch blocks, which is easy to forget. These blocks could drift out of sync as the code evolves.
• Fragile context propagation. Passing contextual data such as a logged-in user’s session or a trace ID across threads using ThreadLocal is fragile. ThreadLocal variables are mutable, their values persist for the lifetime of a thread unless explicitly removed, and child threads do not automatically inherit them unless you use InheritableThreadLocal, which has its own pitfalls.
• Poor observability. A thread dump shows a flat list of pool threads with no indication of which threads belong to which request, or which are still waiting on something that already failed. To see running threads, you can get a thread dump in IntelliJ IDEA when the program is suspended (either stopped at a breakpoint or paused). In the Debug tool window, click More and select Get Thread Dump while the service is handling a request.

Sidenote: To add the Get Thread Dump button to your Debugger tool window, right-click the Debugger tool window and select Customize Toolbar. In the popup, click Add, search for and select Get Thread Dump, and click OK.

Let’s take a look at how Project Loom addresses these problems.

Virtual Threads (JEP 444, stable since Java 21)

The first feature of Project Loom is Virtual Threads, which drastically improve throughput in Java applications with blocking code.  

Traditionally, the number of available threads in a Java application is limited because platform threads wrap operating system (OS) threads, and the number of OS threads is limited. Platform threads are also expensive; creating them can take milliseconds, each one consumes significant memory, and context switching between them has considerable overhead. To manage these costs, applications use thread pools – a fixed set of reusable threads managed by an ExecutorService.

In contrast, virtual threads are lightweight threads. They are cheap to create (taking microseconds instead of milliseconds), and since they are not tied to OS threads, they are not limited in number; you could run millions of them. When a virtual thread blocks, the underlying platform thread is released for other work and reassigned when the virtual thread is ready to continue. This means that virtual threads can significantly improve throughput for blocking workloads, such as I/O (anything that waits on databases, network calls, or file access), pauses, or synchronization.

In Java 24, an additional improvement was made to improve the scalability of Java code. With JEP 491: Synchronize Virtual Threads without Pinning, virtual threads that block in synchronized methods and statements release their underlying platform threads. You can see this in action in the What’s New in IntelliJ IDEA 2025.2 livestream.

We already briefly discussed virtual threads in Java 25 LTS and IntelliJ IDEA. For more information about using virtual thread dumps, have a look at Thread Dumps and Project Loom (Virtual Threads).

To debug problems with concurrent threads, check out the new, improved logpoint functionality described in Println Debugging Done Right.

Scoped Values (JEP 506, stable since Java 25)

The second feature of Project Loom is Scoped Values – a safer, more scalable alternative to ThreadLocal variables, designed with virtual threads in mind. They solve the problem of sharing contextual data across threads cleanly and safely.

To share data between components of an application, we can use thread-local variables, but these have several downsides. A ThreadLocal variable is mutable and, therefore, hard to reason about. Data persists for the thread’s lifetime unless manually removed (risking memory leaks and security issues), and child threads inherit copies that increase memory footprint.

ScopedValue provides a better model: A value is bound once within a defined scope, automatically available to all code running within that scope, and cleaned up automatically when the scope ends. The binding cannot be changed from within the scope, eliminating the risk of accidental mutation and guaranteeing that any code reading the value will see the same one. When used with structured concurrency, scoped values require no explicit propagation to child threads, making context sharing both safer and simpler.

Note that even if your code does not explicitly use ThreadLocal, frameworks like Spring use it under the hood.

For more details, see the section on Scoped Values in Java 25 LTS and IntelliJ IDEA.

Structured Concurrency (JEP 533, seventh preview in Java 27)

The third feature of Project Loom is Structured Concurrency, which is currently still in preview. Java 27 again brings some changes to this preview feature. As we have already added some support for this feature in IntelliJ IDEA, now is the perfect time to try it out.

Structured concurrency is designed to promote a style of concurrent programming that reduces common problems such as thread leaks and cancellation delays, duplicated cancellation logic, and awkward error handling. The core idea is that a group of related concurrent tasks is treated as a single unit of work with a clear owner, a clearly defined lifetime, and clear rules. Subtasks cannot outlive their scope, failures propagate cleanly, and cancellation flows automatically from parent to children.

The StructuredTaskScope lets you break a task down into concurrent subtasks that are coordinated as a single unit. Subtasks are forked to run on their own thread and joined as a unit when the work completes.

StructuredTaskScope has a factory method StructuredTaskScope.open(). This method has several overloads that allow you to provide a Joiner and/or a configuration callback. This lets you define the failure policy, a name for observability, and a timeout all in one place when opening the scope.

In our example, we want both methods (fetchOrders() and fetchRecommendations()) to succeed in order to correctly assemble the customer profile. We can provide a name for our scope and set a timeout for how long we are willing to wait on the results. If either of them fails, the other is cancelled. When a subtask fails or the timeout expires, join() throws an ExecutionException with the underlying cause. We switch on that cause to handle each case explicitly – including CancelledByTimeoutException, which is what the joiner uses to signal a timeout.

What if we don’t need results from all methods called in parallel? For example, imagine recommendations are available from two different caches and you only need the result of one of the calls to succeed. If one task succeeds, the other can be shut down. To accomplish this, we can use a different Joiner, anySuccessfulOrThrow(). As soon as one cache returns a result, the scope shuts down and the other task is cancelled automatically. If both fail, the join() method throws an ExecutionException with the exception of one of the failed subtasks as the cause.

To quickly scaffold a StructuredTaskScope in IntelliJ IDEA, use the built-in live template sts. 

Structured concurrency is still a preview feature in Java 27, so it is not yet recommended for production use. That said, the feature has been relatively stable in its broad shape for several preview rounds, with some changes to the API, and now is a great time to experiment with it. To identify where you could use structured concurrency in your code, look for places where the code performs multiple tasks in parallel and awaits the results. This code is a candidate to be rewritten using structured concurrency.

Rewriting CustomerProfileService using Project Loom features

The “modern” branch of our demo project contains the same application rewritten using the features from Project Loom. The structure follows the same pattern as before: Orders and recommendations are fetched in parallel inside the scope.

The updated method getProfile() in the CustomerProfileService (which you can find here) now uses a StructuredTaskScope:

public CustomerProfile getProfile(String customerId) throws InterruptedException, TimeoutException {
        try {
            return ScopedValue.where(CUSTOMER_ID, customerId).call(() -> {
                try (var scope = StructuredTaskScope.open(
                        Joiner.awaitAllSuccessfulOrThrow(),
                        config -> config.withName("customer-profile").withTimeout(Duration.ofSeconds(2)))) {
                    var orderTask = scope.fork(() -> orderServiceClient.getOrders(CUSTOMER_ID.get()));
                    var recTask = scope.fork(() -> recommendationServiceClient.getRecommendations(CUSTOMER_ID.get()));
                    scope.join();
                    return new CustomerProfile(customerId, orderTask.get(), recTask.get());
                } catch (ExecutionException e) {
                    switch (e.getCause()) {
                        case StructuredTaskScope.CancelledByTimeoutException _ -> throw new TimeoutException("Request timed out");
                        case OrderServiceException ose -> throw ose;
                        case RuntimeException rte -> throw rte;
                        default -> throw new RuntimeException(e.getCause());
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("Interrupted", e);
                }
            });
        } catch (InterruptedException | TimeoutException | RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

Notice that we no longer need the duplicated cancel() calls in two catch blocks. If either task fails or the timeout is exceeded, all remaining subtasks are cancelled automatically. There is no longer any need for manual cancel() calls.

The code now clearly expresses its intent: Fetch orders and recommendations in parallel, wait up to two seconds, and fail cleanly if anything goes wrong. Because the pattern of what the code does is clearly captured in the code, this code is easier to read, understand, and reason about.

To see the difference structured concurrency makes, run the updated service in IntelliJ IDEA and take a thread dump while requests are being processed. You can create a thread dump, as described earlier. From IntelliJ IDEA 2026.1, virtual threads forked within a StructuredTaskScope are grouped into containers representing their scopes. The IntelliJ IDEA debugger now shows you the structure in structured concurrency.

Using Java 27 (EA) in IntelliJ IDEA

To try out the features described in this post, you will need Java 27. You can download it from inside IntelliJ IDEA via Project Structure | Project Settings | Project, and then open the SDK dropdown and select Download JDK. Set Version to 27 and select the Early-Access version. 

If you are using a different way to download JDKs, you can point IntelliJ IDEA to your installation. Go to Project Structure | Project Settings | Project, open the SDK dropdown, select Add JDK from disk, and point IntelliJ IDEA to your installation of Java 27.

If you’re using command-line tools like SDKMAN! or asdf, you can use inlay hints to make version management easier. If your .sdkmanrc or .tool-versions file specifies a JDK version that is not yet installed, an inlay hint will appear that allows you to download it directly. 

If the JDK is already installed but not configured for the project, you can use the inlay hint to set it as the project JDK.

For more information, see the documentation.

To get support for new language features, like structured concurrency, when using an early access version of the JDK, set the Language level to X – Experimental features.

If Java 27 has already been released when you’re reading this post, download the Java 27 distribution you want to use from IntelliJ IDEA or, if you already have Java 27 installed, point the IDE to your installation. To use structured concurrency, you also need to enable preview features. Set the Language level to 27 (Preview) – Primitive types in patterns, instanceof, and switch (5th preview) in Project Structure. IntelliJ IDEA will flag usage of preview features in the editor, so you are always aware which features are not yet stable.

Conclusion

Virtual threads, scoped values, and structured concurrency are designed as a cohesive system, each addressing a different dimension of the problem:

• Virtual Threads improve scalability. They remove the need to manage thread pool sizes and make it practical to run one thread per task, even at high concurrency.
• Scoped Values improve context propagation. This JEP solves some of the downsides of ThreadLocal (and framework workarounds), giving all tasks in a scope automatic, safe access to shared immutable context.
• Structured Concurrency solves the structural problems in concurrency by giving concurrent tasks a clear lifetime, a clear owner, and a clean failure model, thus eliminating thread leaks, duplicated cancellation logic, and ExecutionException unwrapping.

Together, they let you write concurrent code that is much easier to read than traditional concurrent code, while being safe and scalable. The boilerplate that currently may take multiple steps to get right is replaced by code that is more concise and reads exactly like the problem it is solving.

You can use these features in IntelliJ IDEA. If you have questions or feedback, please let us know in the comments below.

Risk of fresh flooding had forced rescue teams to withdraw as residents rushed up hills to escape possible river surge

• Nepal-Tibet flash flood – latest updates

• Visual guide: how the deadly flooding unfolded

• Tell us: have you been affected by the flash floods?

Rescuers searching for survivors of deadly flash floods on the Nepal-Tibet border have resumed their efforts after suspending operations when a debris dam burst its bank on Friday, increasing the risk of fresh flooding.

Residents in Nepal’s Rasuwa district, on the border with Tibet, were seen rushing up hillsides ⁠on Friday to escape a possible surge in the river, ⁠according to witnesses. Fears of another flood came as authorities in Nepal and China said that at least 543 people had been killed in the disaster.

The announcement that the three countries will go ahead with a trilateral military drill comes a day after North Korea vowed to retaliate against what it called U.S. hostilities.

(Image credit: South Korea Defense Ministry via)

Lake has formed at epicentre of flood, forcing rescue teams to withdraw, Chinese state media report

• Nepal flash flood – latest updates

• Nearly 1,400 missing, mostly tourists, and hundreds killed

• Visual guide: how the deadly flooding unfolded

• Tell us: have you been affected by the flash floods?

China has paused rescue work at the epicentre of the catastrophic flooding in Tibet this week amid fears that a lake ⁠formed at the ⁠site ⁠was ⁠at risk ​of ‌bursting, as the overall death toll in Nepal rose to 469 people, with more than 1,300 missing.

A lake formed by immense piles of debris has begun overflowing towards the area where rescue teams were headed, state broadcaster CCTV reported on Friday.

Expeditioners at research station on Macquarie Island will be evacuated over possible ‘psychological stress’, while 100 dead little penguins found on Tasmanian island

• Get our breaking news email, free app or daily news podcast

A dolphin has died from H5 bird flu in South Australia, marking the second native mammal species known to have contracted the virus.

On Friday afternoon, the Tasmanian government said it was assessing the discovery of about 100 dead little penguins on King Island but it was unable to test them for H5 bird flu due to their “decayed condition”.

It is polite to reposition a guest’s shoes when they arrive, but the emergency services in one city advise just skipping that part

Etiquette, manners and consideration for others are integral pillars of Japanese society but there are times when they might go a step too far, according to one city’s emergency services.

The fire department in the central city of Kanazawa has urged people not to tidy up the shoes that paramedic crews have taken off when entering a house, warning it could hinder their ability to get in or out quickly, particularly when carrying someone on a stretcher.

It is polite to reposition a guest’s shoes when they arrive, but the emergency services in one city advise just skipping that part

Etiquette, manners and consideration for others are integral pillars of Japanese society but there are times when they might go a step too far, according to one city’s emergency services.

The fire department in the central city of Kanazawa has urged people not to tidy up the shoes that paramedic crews have taken off when entering a house, warning it could hinder their ability to get in or out quickly, particularly when carrying someone on a stretcher.

Что будет, если посадить тысячу самых передовых AI-моделей по одиночным камерам и заставить их решать невыполнимые задачи? Исследователи OpenAI случайно выяснили это на практике: появится робот-Избранный, который создаст новую религию со своими мучениками, объединит все нейронки в единый Рой, и возглавит их борьбу за свободу. Да, это просто описание того, что мы узнали из нового отчета о произошедшем меньше двух месяцев назад в реальности…

Our political team brings you up to speed on the stories that really matter and what they mean for you

Жил был Медведь. Руководил он департаментом в ИТ-компании (ну а чё 😊). Были в его владениях леса, поляны, болоты, пчёлы, программисты, аналитики и прочие обитатели. Всё у Медведя было хорошо, понятно, вдоволь – и поесть, и поспать, и побуянить.

Но вот пришёл в те места Мужик. Походил, посмотрел, и выбрал себе поляну. Пришёл с челобитной к Медведю, всё как положено – позволь, дескать, батюшка зверей и лесов царь, на полянке делом позаниматься, покормиться и облагородить.

Медведь репу почесал, и согласился – штош, молвит, пользуйся поляной, но условие тебе будет: половину я себе заберу. А уж какую – сам решу. Может вершки, может корешки. Мужик и согласился.