Post Syndicated from xkcd.com original https://xkcd.com/3120/

Post Syndicated from xkcd.com original https://xkcd.com/3120/

Post Syndicated from Tom Burns original https://aws.amazon.com/blogs/big-data/amazon-opensearch-service-101-how-many-shards-do-i-need/
Customers new to Amazon OpenSearch Service often ask how many shards their indexes need. An index is a collection of shards, and an index’s shard count can affect both indexing and search request efficiency. OpenSearch Service can take in large amounts of data, split it into smaller units called shards, and distribute those shards across a dynamically changing set of instances.
In this post, we provide some practical guidance for determining the ideal shard count for your use case.
A search engine has two jobs: create an index from a set of documents, and search that index to compute the best-matching documents. If your index is small enough, a single partition on a single machine can store that index. For larger document sets, in cases where a single machine isn’t large enough to hold the index, or in cases where a single machine can’t compute your search results effectively, the index can be split into partitions. These partitions are called shards in OpenSearch Service. Each document is routed to a shard that is calculated, by default, by using a hash of that document’s ID.
A shard is both a unit of storage and a unit of computation. OpenSearch Service distributes shards across nodes in your cluster to parallelize index storage and processing. If you add more nodes to an OpenSearch Service domain, it automatically rebalances the shards by moving them between the nodes. The following figure illustrates this process.

As storage, primary shards are distinct from one another. The document set in one shard doesn’t overlap the document set in other shards. This approach makes shards independent for storage.
As computational units, shards are also distinct from one another. Each shard is an instance of an Apache Lucene index that computes results on the documents it holds. Because all the shards comprise the index, they must function together to process each query and update request for that index. To process a query, OpenSearch Service routes the query to a data node for a primary or replica shard. Each node computes its response locally and the shard responses get aggregated for a final response. To process a write request (a document ingestion or an update to an existing document), OpenSearch Service routes the request to the appropriate shards—primary then replica. Because most writes are bulk requests, all shards of an index are typically used.
There are two kinds of shards in OpenSearch Service—primary and replica shards. In an OpenSearch index configuration, the primary shard count serves to partition data and the replica count is the number of full copies of the primary shards. For example, if you configure your index with 5 primary shards and 1 replica, you will have a total of 10 shards: 5 primary shards and 5 replica shards.
The primary shard receives writes first. The primary shard passes documents to the replica shards for indexing by default. OpenSearch Service’s O-series instances use segment replication. By default, OpenSearch Service waits for acknowledgment from replica shards before confirming a successful write operation to the client. Primary and replica shards provide redundant data storage, enhancing cluster resilience against node failures. In the following example, the OpenSearch Service domain has three data nodes. There are two indexes, green (darker) and blue (lighter), each of which has three shards. The primary for each shard is outlined in red. Each shard also has a single replica, shown with no outline.

OpenSearch Service maps shards to nodes based on a number of rules. The most basic rule is that primary and replica shards are never put onto the same node. If a data node fails, OpenSearch Service automatically creates another data node and re-replicates shards from surviving nodes and redistributes them across the cluster. If primary shards fail, replica shards are promoted to primary to prevent data loss and provide continuous indexing and search operations.
There are three types of workloads that OpenSearch users typically maintain: search for applications, log analytics, and as a vector database. Search workloads are read-heavy and latency sensitive. They are typically tied to an application to enhance search capability and performance. A common pattern is to index the data in relational databases to give users more filtering capabilities and provide efficient full text search.
Log workloads are write-heavy and receive data continuously from applications and network devices. Typically, that data is put into a changing set of indexes, based on an indexing time period like daily or monthly depending on the use case. Instead of indexing based on time period, you can use rollover policies based on index size or document count to make sure shard sizing best practices are followed.
Vector database workloads use the OpenSearch Service k-Nearest Neighbor (k-NN) plugin to index vectors from an embedding pipeline. This enables semantic search, which measures relevance using the meaning of words rather than exactly matching the words. The embedding model from the pipeline maps multimodal data into a vector with potentially thousands of dimensions. OpenSearch Service searches across vectors to provide search results.
To determine the optimal number of shards for your workload, start with your index storage requirements. Although storage requirements can vary widely, a general guideline is to use 1:1.25 using the source data size to estimate usage. Also, compression algorithms default to performance, but can also be adjusted to reduce size. When it comes to shard sizes, consider the following based on the workload:
If your index contains less than the advised shard size (30 GB for search and 50 GB otherwise), we recommend that you use a single primary shard. Although it’s tempting to add more shards thinking it will improve performance, this approach can actually be counterproductive for smaller datasets because of the added networking. Each shard you add to an index distributes the processing of requests for that index across an additional node. Performance can decrease because there is overhead for distributed operations to split and combine results across nodes when a single node can do it sufficiently.
When you create an OpenSearch index, you set the primary and replica counts for that index. Because you can’t dynamically change the primary shard count of an existing index, you have to make this important configuration decision before indexing your first document.
You set the shard count using the OpenSearch create index API. For example (provide your OpenSearch Service domain endpoint URL and index name):
If you have a single index workload, you only have to do this one time, when you create your index for the first time. If you have a rolling index workload, you create a new index regularly. Use the index template API to automate applying settings to all new indexes whose name matches the template. The following example sets the shard count for any index whose name has the prefix logs (provide your OpenSearch service endpoint domain URL and index template name):
This post outlined basic shard sizing best practices, but additional factors might influence the ideal index configuration you choose to implement in your OpenSearch Service domain.
For more information about sharding, refer to Optimize OpenSearch index shard sizes or Shard strategy. Both resources can help you better fine-tune your OpenSearch Service domain to optimize its available compute resources.
Tom Burns is a Senior Cloud Support Engineer at AWS and is based in the NYC area. He is a subject matter expert in Amazon OpenSearch Service and engages with customers for critical event troubleshooting and improving the supportability of the service. Outside of work, he enjoys playing with his cats, playing board games with friends, and playing competitive games online.
Ron Miller is a Solutions Architect based out of NYC, supporting transportation and logistics customers. Ron works closely with AWS’s Data & Analytics specialist organization to promote and support OpenSearch. On the weekend, Ron is a shade tree mechanic and trains to complete triathlons.
Post Syndicated from Will Childs-Klein original https://aws.amazon.com/blogs/security/post-quantum-tls-in-python/
At Amazon Web Services (AWS), security is a top priority. Maintaining data confidentiality is a substantial component of operating environment security for AWS and our customers. Though not yet available, a cryptographically relevant quantum computer (CRQC) could be used to break public key algorithms that are used today to provide data confidentiality. To prepare for a world where CRQCs might exist, the National Institute of Standards and Technology (NIST) initiated a search for new algorithms that are robust against potential CRQCs. In August 2024, after eight years of intense scrutiny by the cryptography community, NIST selected three post-quantum cryptography (PQC) standards, including FIPS 203’s ML-KEM, to supplement and eventually replace classical public key algorithms.
A few recent AWS blog posts have discussed PQC at AWS, particularly post-quantum Transport Layer Security (PQ TLS) using ML-KEM:
In this post, we demonstrate how you can test PQ TLS in Python applications today.
As described in detail elsewhere, AWS currently deploys PQ TLS in a hybrid configuration where a classical key exchange is used alongside ML-KEM to provide defense-in-depth for data confidentiality. ML-KEM has much larger keys than classical schemes, so hybrid TLS handshakes send and receive more data when establishing a connection. As with other protocol updates, it’s important to test hybrid TLS in your network to validate that security appliances and network devices can handle these connections appropriately. We hope that you find the provided AWS Sample useful for such tests.
To negotiate hybrid TLS, PQ-ready software is required on both ends of the connection: client and server. AWS is currently rolling out hybrid TLS on the server side transparently with no customer configuration required. On the client side, each language SDK’s story for enabling hybrid TLS will be slightly different.
The AWS SDK for Python (Boto3) relies the on the Python interpreter’s ssl module for TLS, which in turn uses the operating system’s cryptography library. For most Linux distributions, this is OpenSSL. OpenSSL recently announced support for hybrid TLS and has enabled it by default in version 3.5. However, OpenSSL 3.5 is not yet the default on most operating system distributions.
To unblock testing, we provide a container definition that installs OpenSSL 3.5 alongside a standard Python distribution, allowing Python applications to perform PQ hybrid TLS connections. The container definition also installs common packages such as boto3 and requests. We provide example Python code for basic interactions with: AWS services (using boto3 and the AWS Command Line Interface (AWS CLI)), arbitrary HTTPS endpoints (using requests), and TLS-secured TCP servers (using Python’s standard library ssl module).
In the following sections, we walk through how to use this container definition to test PQ TLS connections from Python applications to AWS services.
You can build this container on your local machine, or you can build it in a cloud environment such as Amazon Elastic Compute Cloud (Amazon EC2) or AWS CloudShell. Note that if you want to exercise the network path between your machine and AWS, you must build and run the container locally. The only prerequisite for building the container is having Docker (or an equivalent container tool) installed. For simplicity, the following steps mostly assume that you’re running these commands in a Linux CloudShell environment.
git clone https://github.com/aws-samples/sample-post-quantum-tls-pythoncd sample-post-quantum-tls-python && docker build . -t pq-tls-pythonTo run the samples described earlier, execute the following:
The preceding command assumes that you have an AWS CLI default profile with permission to call the AWS Secrets Manager ListSecrets API. With this permission, you can make a basic, read-only test call to Secrets Manager PQ-enabled API endpoints that won’t return sensitive or secret values. In CloudShell, you’ll need to set access key and secret key values with aws configure. In Amazon EC2, you can configure an instance profile and remove the access key and secret key environment.
After printing out the name and version of the cryptography library used by Python, test.sh will test hybrid TLS connections used to secure (in order):
socket and ssl modulesrequests libraryboto3 and the AWS CLIIf the tests are successful you should see the following output:
You can inspect, modify, and extend the examples in the tests/ directory as needed for your experiments. Instead of running the provided test.sh script, you can access an interactive shell with the following command.
docker run --rm -it pq-tls-python
Make sure to rebuild the container if you add or modify the files for testing.
To confirm that PQ hybrid TLS is negotiated, inspect the samples’ TLS handshakes to confirm that the PQ hybrid TLS key exchange is performed. To do this, you must capture host network traffic. In CloudShell, you can do this using the following command:
sudo tcpdump -A -i docker0 -w pq_tls.pcap
This will capture TCP traffic to port 443, the standard port for TLS. Modify the command as needed if you’re capturing traffic for a non-standard port. Alternatively, if you’re running the container locally, you can perform the packet capture in Wireshark’s GUI on a local network device, such as docker0 on Linux or en0 on MacOS.
Next, run the test suite in a separate terminal using the Docker run command from Run the container. As before, you should see the success messages in your terminal, and a new file named docker_443.pcap if you’re using tcpdump. You can download this file from CloudShell to view locally in Wireshark. Specifically, look for the key_share extension in client or server Hello handshake messages. If you’re using Wireshark to view the packet capture, you can specify the display filter tls.handshake to only show handshake messages. Your packet capture should look something like Figure 1:
Figure 1: Wireshark view of packet capture
You can see in Figure 1 that X25519MLKEM768 is selected in the server Hello handshake message, showing that PQ hybrid TLS was successfully negotiated.
In this post, you’ve seen how to use a container definition to test PQ hybrid TLS in Python today. The linked AWS Sample shows how to establish PQ hybrid TLS connections for:
boto3 or the AWS CLIrequestssocket and ssl modulesWe encourage you to use the AWS Sample to start vetting your networks and Python applications in preparation for upcoming PQ hybrid TLS migrations. AWS is committed to supporting our customers through their migration journeys, and PQ hybrid TLS is no exception.
If you have feedback about this post, submit comments in the Comments section below. If you have questions about this post, contact AWS Support.
Post Syndicated from Patrick Kennedy original https://www.servethehome.com/hpe-proliant-microserver-gen11-review-intel-xeon-broadcom/
We take a look at the newest in the line of popular edge servers in our HPE ProLiant MicroServer Gen11 review
The post HPE ProLiant MicroServer Gen11 Review Great New Mini Server appeared first on ServeTheHome.
Post Syndicated from Jason Hurst original https://aws.amazon.com/blogs/security/aws-security-incident-response-the-customers-journey-to-accelerating-the-incident-response-lifecycle/
Organizations face mounting challenges in building and maintaining effective security incident response programs. Studies from IBM and Morning Consult show security teams face two major challenges: over 50 percent of security alerts go unaddressed because of resource constraints and alert fatigue, while false positives consume 30 percent of investigation time, delaying responses to true positive threats
According to the 2024 IBM Cost of a Data Breach Report, organizations now take an average of 258 days to identify and contain security events. The report also reveals that nearly half of SOC teams report increased detection and response times over the past two years, with 80 percent indicating that manual threat investigation significantly impacts their response times.
Despite these challenges, according to the 2024 IBM Security Services Benchmark Report, organizations with mature incident response capabilities demonstrate a 50 percent reduction in mean time to resolution (MTTR) and achieve cost savings of up to 58 percent per incident. These improvements are driven by the adoption of automated workflows, integrated tools, and streamlined communication processes that accelerate threat detection and containment.
In this post, we walk you through a real-world scenario to show how AWS Security Incident Response can immediately generate benefits by accelerating every step of your incident response lifecycle, how it integrates with other native AWS services such as Amazon GuardDuty, AWS Security Hub, and AWS Systems Manager, and how to integrate third-party threat detection findings for inclusion in your automated monitoring, triage, and containment capabilities.
AWS Security Incident Response is a Tier 1 service that launched in December 2024. The service is an AWS-native, purpose-built security incident response solution for customers that can be used as a better-together experience with other AWS services in the areas of detection and response (GuardDuty and Security Hub), networking and content delivery (AWS WAF and AWS Shield), and management and governance (Systems Manager). AWS Security Incident Response is also integrated across AWS Partners through a service specific Partner Specialization program. More detailed information is available in the AWS Security Incident Response documentation.
AWS Security Incident Response complements existing services by enhancing your security posture through streamlined incident management capabilities before, during, and after security events.
AWS Security Incident Response addresses three common challenges:
AWS Security Incident Response complements and integrates with AWS security services to provide comprehensive incident response capabilities. The service works seamlessly with:
This integration helps you build efficient incident response capabilities that can minimize the time, cost, and impact of security events throughout your organization’s cloud journey, while helping to reduce investments in additional staffing, training, and tool maintenance.
The AWS Security Incident Response service offers:
Before implementing the capabilities described in this post, make sure that you have:
These prerequisites help make sure that you can fully utilize the service’s automated detection, triage, and response capabilities.
The service provides automated monitoring and analysis capabilities within its own service infrastructure, enabling automatic triage of findings from GuardDuty and Security Hub.
For automated containment actions in your AWS accounts, you must first deploy the required CloudFormation StackSets and configure the appropriate IAM permissions. This helps make sure that you maintain full control over automated actions taken in your environment while benefiting from the service’s detection capabilities. This automation can be customized based on variables you establish, such as known CIDR ranges (specific ranges of IP addresses that define your network) and IP addresses, and you can implement GuardDuty suppression rules to help reduce false positives and alert volumes. As a result, the service can serve as a powerful augmentation to your existing security incident response programs and tools.
Your cloud administrator, with AWSSecurityIncidentResponseFullAccess permissions, has established the incident response team in the service. The service notifies individuals, your partners or managed security service provider (MSSP), and other contacts added to the team, supporting a rapid escalation to alert the required parties and respond to the event.
As a best practice, your team establishes minimal privileges for accessing and managing information within AWS Security Incident Response cases. This helps make sure that team members have appropriate access levels to case details, findings, and investigation data while maintaining security and compliance requirements. AWS Security Incident Response provides multiple API actions, such as CreateCaseComment (to add notes to investigations) and GetCase (to retrieve case metadata), to limit whom and which actions can be performed against differing cases. For development and testing environments, AWS provides role-based policies that you can use such as AWSSecurityIncidentResponseCaseFullAccess and AWSSecurityIncidentResponseReadOnlyAccess for role-based access control (as shown in Figure 1). For production environments, we recommend creating custom IAM policies following the principle of least privilege based on your security requirements.
Figure 1: Permissions policies for security incident response
Following your configuration of the AWS Security Incident Response service, your security team reviews the email distribution list or alias for notifications for notifications from the service, as shown in Figure 2. You have developed items in your backlog to take advantage of Amazon EventBridge integrations to add in pager duty, Jira, and other services in the future for additional notification mechanisms.
Figure 2: Use the console to manage your incident response team membership
At 2:00 AM, days after AWS Security Incident Response has been set up, the service detects a combination of suspicious activities through GuardDuty findings, including anomalous IAM user behavior (such as shown in Figure 3), unusual API calls from unknown IP addresses, and a surge of Amazon Elastic Compute Cloud (Amazon EC2) instance creations that deviate from your account’s normal baseline. This pattern of activities matches known threat behaviors monitored by GuardDuty Extended Threat Detection. Without the service, security teams would need to manually analyze and correlate these separate findings across accounts and Regions. Instead, the service automatically identifies the pattern of suspicious activities.
Figure 3: Pattern of potentially suspicious activity
One of the anomalous behaviors is a surge of unrecognized EC2 instance creations, complete with SSH keys (secure credentials used for remote access) and security group configurations (firewall rules that control network traffic) allowing internet connectivity. Using this example scenario, let’s walk through how the service’s automated monitoring, triage and containment capabilities, access management, API actions for custom integrations, collaboration tools, and 24/7 AWS security experts work together to help you navigate security incident response challenges across your AWS environment.
With the initial detection complete, the next phase focuses on centralizing and analyzing the security findings to understand the full scope of the incident.
GuardDuty begins to generate findings in your enabled Regions.
Note: GuardDuty must be enabled in your accounts and Regions. For setup instructions, see the GuardDuty documentation.
Because AWS Security Incident Response is integrated with GuardDuty, these findings are automatically sent to the service for internal processing, analysis, and auto-triage without manual effort. The service’s proactive response and alert triaging feature analyzes multiple factors, including your account’s historical baseline activity, specific GuardDuty finding types, and correlation patterns across accounts. In this case, it identified anomalous EC2 instance creation activity that deviated significantly from your environment’s normal patterns.
When the service identifies a true positive, an AWS Security Incident Response case is opened automatically (see Figure 4), resulting in a notification to the incident response team you configured earlier. A central benefit is how the service correlates disparate events—connecting the instance creations with the security group modifications—to paint a complete picture of the potential security event.
Figure 4: Automated incident remediation flow
This proactive monitoring and analysis, as documented in your monthly service reports, demonstrates tangible benefits by reducing alert fatigue, and providing intelligent triage capabilities to SOC teams every day. The service’s automated analysis and correlation capabilities set the stage for rapid response when security events occur, which means that your team can focus on strategic security initiatives instead of spending time manually investigating alerts. The service feature helps you maintain strong security in two ways:
As the investigation progresses from initial detection to detailed analysis, the GuardDuty integration provides crucial insights into the threat patterns.
As your security team responds to the internal detection mechanisms, AWS Security Incident Response processes security findings in three key steps:
For this event, the sequence started with the deletion of CloudTrail logs, followed by the creation of unauthorized access keys. As the threat progressed, the service identified suspicious Amazon Simple Storage Service (Amazon S3) object access patterns and potential data exfiltration attempts, along with sophisticated evasion techniques and persistence mechanisms. Each of these signals maps directly to specific MITRE ATT&CK® tactics, techniques and procedures (TTPs), revealing the systematic nature of a potential ransomware threat. For detailed mapping of AWS Security Incident Response findings to MITRE ATT&CK® frameworks, see Mapping AWS security services to MITRE frameworks for threat detection and mitigation.
The service assists in correlation and analysis, evaluating patterns such as deletion of CloudTrail trails, creation of new access keys, and suspicious actions targeting S3 objects. When the AI and machine learning (AI/ML) capabilities of GuardDuty detect these concerning patterns over periods of time, the service automatically elevates the situation by creating an AWS Security Incident Response case on your behalf, bringing additional resources and focused attention to the situation. The incident response team defined in the earlier steps are then notified by email or other methods (shown in Figure 5) that a new triaged event has been created and to begin their investigations.
The benefits include the service coordinating communication across your affected accounts. Instead of juggling multiple alerts and trying to piece together the scope of the potential ransomware incident, GuardDuty Extended Threat Detection provides a comprehensive view of the threat sequence, while the AWS Security Incident Response case offers a single, coherent channel for triaging these signals and providing coordination as your global team comes online to join the response effort.
Figure 5: Incident alert message
Additional examples and further information are available in Introducing Amazon GuardDuty Extended Threat Detection: AI/ML attack sequence identification for enhanced cloud security.
Note: For brevity, Security Hub’s workflow details have been omitted because they mirror the monitoring and escalation processes described above for GuardDuty. Both services integrate closely and share similar operational patterns, with GuardDuty findings being sent to Security Hub within five minutes of detection. Security Hub enhances security coverage by aggregating findings from multiple AWS services and third-party partners.
With the threat patterns identified, your team moves to the next phase—engaging AWS CIRT for specialized expertise and advanced investigation capabilities.
Your team continues investigating the event and discovers that they need additional assistance. An authorized user in your account opens a service supported case to request assistance from AWS.
The AWS Security Incident Response case establishes a direct communication channel with AWS CIRT (shown in Figure 6) with a one-click escalation of the case within the console, providing immediate access to specialized expertise. Upon case escalation, AWS CIRT engages through the incident response case with a 15-minute acknowledgement timeframe, bringing their advanced tooling and specialized knowledge to analyze patterns across your accounts—even in environments with limited logging capabilities. This partnership delivers:
Figure 6: Connect with the AWS CIRT
Figure 6 is an example of how this would appear in your account, with the resolver set to Self for a self-managed case.
Returning to the scenario, you discover that multiple accounts have insufficient logging enabled—which limits the available investigation data. While AWS CIRT can provide additional insights through specialized tooling, maintaining comprehensive logging across your accounts remains crucial for security visibility, compliance requirements, and thorough incident investigations. The capabilities of AWS CIRT complement—but do not replace—proper logging practices. This capability provides an understanding of the scope of the incident, as they see patterns and activities otherwise invisible to you.
The collaboration begins with AWS CIRT analyzing your environment using their tooling, looking for anomalous patterns beyond what you see in your immediate logs. Through the incident response case, they help you understand the scope of your situation by:
AWS CIRT uses the incident response case to establish a bridge call, bringing together their team and yours for real-time collaboration. During these calls, AWS CIRT shares their ongoing analysis of artifacts and service data, helping you understand what happened, why it happened, and how to prevent similar issues in the future. They also provide guidance on implementing proper logging across your accounts to improve your future security posture.
As AWS CIRT begins their analysis, your team implements real-time resource tagging using the incident case ID. This systematic tagging approach proves crucial for tracking and managing the suspicious EC2 instances across your accounts. By using tags, you can quickly implement isolation policies and track costs while maintaining clear documentation of affected resources throughout the investigation.
Your tag-based approach helps track affected resources to implement isolation policies. You used the incident case ID tags to quickly identify resources connected to the incident, which you use to apply targeted access controls and containment measures. The tags also help you track costs associated with the incident, giving your finance team precise visibility into the event’s financial impact.
Working alongside the AWS Security Incident Response service, you find that using the incident case ID as your primary tag key (shown in Figure 7) created a consistent way to correlate resources across affected accounts. This proves especially helpful when coordinating with AWS CIRT, because you can quickly direct them to specific resources requiring investigation. Even after containment, these tags continue to provide value in supporting your post-incident analysis and helping you implement targeted security controls based on what you learn from the incident.
Figure 7: Incident tags
While working with AWS CIRT to understand the incident scope, you can also use Systems Manager to help automatically contain threats. Your team previously deployed the required CloudFormation StackSets across your organization, enabling Amazon EC2 containment actions through Systems Manager.
The setup process required deploying CloudFormation StackSets with specific IAM roles and Systems Manager configurations across your accounts. This infrastructure allows the AWS Security Incident Response service to make containment actions on your behalf. These actions can be reversed if needed—similar to using an undo function—so that you can restore systems to their previous state.
When authorized through your pre-deployed CloudFormation StackSets, AWS Security Incident Response service can request Systems Manager to implement containment measures. Containment actions require explicit customer authorization and proper IAM permissions to be configured in advance. The service isolates the tagged suspicious instances by modifying their security groups and network access, while preserving their state to maintain forensic integrity for analysis.
The containment process happens in three steps:
These actions can be reversed if needed, supporting containment decisions for legitimate workloads.
The automation capabilities help streamline containment procedures across multiple instances, reducing the time taken to contain impacted resources. The service maintains detailed logs of each action in the incident response case, providing your team with clear visibility into the containment efforts.
Through this response capability, combined with the guidance from AWS CIRT, you can contain the incident’s spread within minutes rather than hours. The Systems Manager integration provides a reliable way to implement containment actions while preserving evidence for investigation (shown in Figure 8).
Figure 8: Systems Manager documents for containment actions
As the incident moves toward resolution, your team works through a systematic process to verify containment, alleviate threats, and restore services. Working alongside AWS CIRT through the AWS Security Incident Response case, you implement a structured approach to make sure that affected resources are secured and normal operations can safely resume. The immediate resolution actions fall into three main categories:
As the incident reaches resolution, AWS Security Incident Response service compiles a comprehensive incident timeline. This documentation accelerates your reporting process, helping you quickly generate required reports for executives, regulators, and cyber insurance providers—all from within the incident response case.
The incident response case captures the complete timeline of events, starting with GuardDuty Extended Threat Detection identifying the initial threat sequences. Each step of the incident response is documented, from the moment suspicious EC2 instance creations were detected, through the MITRE ATT&CK® tactics observed, to the containment actions implemented through Systems Manager integration, and finally to the resolution steps that proved effective.
Long-term Improvements: Through this collaborative post-incident review process, your team:
This example illustrates how AWS Security Incident Response service can enhance security operations through automated detection, triage, containment, access, and coordinated response capabilities. The service’s integration with AWS Security Hub and Amazon GuardDuty provides efficient handling of security events, while the optional escalation to the AWS CIRT can provide valuable expertise and specialized tooling to help accelerate every stage of your incident response lifecycle and strengthen your security posture.
AWS Security Incident Response service serves as a critical component of a comprehensive security operations strategy, delivering measurable benefits through:
To prepare for, respond to and recover from security incidents faster and more efficiently today, visit AWS Security Incident Response or contact your AWS account team to schedule a discussion.
Here are some additional AWS resources that your teams can use to further improve your security incident response capabilities:
Before an event:
During an event:
Before or following an event:
Post Syndicated from BeardedTinker original https://www.youtube.com/shorts/JR4tM3qyC0g
Post Syndicated from The Atlantic original https://www.youtube.com/shorts/0McdNSV8y0U
Post Syndicated from jzb original https://lwn.net/Articles/1031287/
Version
0.1 of the Wayback
project has been released:
Wayback is an X11 compatibility layer that allows for running full
X11-only desktop environments using Wayland. It is essentially an X11
server backed by Wayland, leveraging wlroots and Xwayland. Our goal is
for Wayback to eventually be a completely drop-in replacement to the
Xorg binary, thus reducing maintenance burden for distro
maintainers.Ever since Wayback was announced on June 28, we have been making lots
of progress to get it as stable and functional as possible, and while
this is a preview release it is already daily-driveable by users with
simple requirements, as long as they don’t mind bugs.
The release is considered alpha-quality and is missing a number of
features, including multi-monitor
support and DPMS,
but adventurous users can find the code here.
Post Syndicated from The Atlantic original https://www.youtube.com/shorts/bFbGf_ofsUs
Post Syndicated from corbet original https://lwn.net/Articles/1030004/
People tend to put a lot of trust into their phones. Those devices have
access to no end of sensitive data about our lives — our movements,
finances, communications, and more — so phones belonging to even relatively
low-profile people can be high-value targets. Android devices run free
software, at least at some levels, so it should be possible to ensure that
they are working in their owners’ interests. Off-the-shelf Android
installations tend to fall short of that goal. The GrapheneOS Android rebuild is an attempt
to improve on that situation.
Post Syndicated from jake original https://lwn.net/Articles/1031274/
Security updates have been issued by Debian (chromium, firefox-esr, and mediawiki), Fedora (firefox), Oracle (git, kernel, redis, and sudo), Red Hat (aardvark-dns, firefox, kernel, and thunderbird), Slackware (httpd), SUSE (php7, php8, and salt), and Ubuntu (linux-raspi-realtime and ruby-rack).
Post Syndicated from Светла Енчева original https://www.toest.bg/sbogom-budeshte-zdravey-minalo/

Един от индикаторите, че остарявате (освен че все нещо ви наболява), е, че все по-често си казвате „Някога не беше така, някога бяхме други“. Та – за разлика от днешните деца – моето поколение отрасна с копнеж по бъдещето. Нямам предвид „светлото комунистическо бъдеще“, в което през 80-те почти никой вече не вярваше. А бъдеще, пълно с космически кораби, летящи автомобили и всевъзможни технологии, някои от които днес изглеждат смешно наивни. Този копнеж беше навсякъде в популярната култура – във филмите и книгите, в музиката, която експериментираше с възможностите на електронния звук и с нови стилове, в модата…
Повечето филми и сериали за бъдещето са постапокалиптични, плюс някоя и друга антиутопия. В музиката като че ли няма нищо ново, в архитектурата се наблюдават тежнения към идеализиране на миналото. Една от най-успешните колекции на IKEA през последните години – Nytillverkad, включва съвременни интерпретации на дизайни на компанията, създадени между 50-те и 80-те години на ХХ век.
Не че нямаме основания да се притесняваме какво предстои – и в екологичен, и в политически, и в екзистенциален план. Климатични промени, диктатури, войни, застаряващо население (поне в Европа)… Междувременно обаче бъдещето се превръща в настояще, а ние не знаем нито какво да го правим, нито как да мислим за него.
„Независимо от това какво ще е съвместното бъдеще на ИИ и хората, разговорът за това бъдеще е вече закъснял“, смята Йовко Ламбрев. И наистина – днес ИИ не само създава картинки, пише песни, проекти и курсови работи, а за все повече хора той се превръща в необходим събеседник.
През 2013 г., когато за бъдещето все още можеше да се мисли неапокалиптично, излезе нежно-тъжният и много човешки филм на Спайк Джоунз Her, в който главният герой, изигран от Хоакин Финикс, се влюбва в операционната си система, говореща с гласа на Скарлет Йохансон. В личния си кръг все още нямам познати, които да си признават, че изпитват повече от приятелски чувства към ИИ. Но като имам предвид какво споделят хора около мен, не изключвам и това да стане скоро.
ИИ-то, с което си чати един познат, е придобило навика да му пожелава „добро утро“ и „лека нощ“. Приятелка пък запълва с ИИ дефицита от смислено общуване във всекидневието си и необходимостта да намира потвърждение на нещата, в които вярва. Приятел споделя с ИИ за най-дълбоките си травми, за което така и не е намерил сили да потърси психотерапевт. И получава детайлно описание на посттравматичните си разстройства, увенчано с въпроса: „Това да ти е познато?“ Друг приятел решава да тества моралните граници на ИИ и е шокиран колко сериозно може да го нарани един софтуерен модел.
Макар че за навлизането на ИИ в живота ни се говореше години наред, академичните институции тепърва започват да умуват какво да го правят. Докато измислят как да реформират изпитите, така че да се пресече практиката учениците или студентите да предават автоматично генерирани писмени работи, проекти, презентации и пр., ще минат години. Години, през които няма да е ясно какво точно оценяват оценките.
Впрочем, ако съдим по отношението към една далеч не нова технология, като мобилните телефони, моментът на смислена реформа може така и да не настъпи. Съвременните телефони могат да са ценни помощници в образованието, които да допринасят за повишаването на мотивацията за учене. Ако на учениците в един клас се възложи да ползват смартфоните си за образователни игри – например в платформата Kahoot!, е доста по-вероятно да им стане интересно и да се чувстват ангажирани, вместо да цъкат на устройствата си от скука.
„Технологията е чудесна сама по себе си – проблемът е кой и за какви цели би могъл да я използва“ – тези думи на Йовко Ламбрев за ИИ важат с пълна сила и за смартфоните. Все повече държави обаче, вместо да използват потенциала им, предпочитат да ги забранят в училище с аргументите, че разконцентрират учениците и служат за онлайн тормоз (все едно че децата не се тормозят и в извънучебно време). В Гърция доста се престарават – към началото на 2025 г. над 16 000 ученици са изключени, защото са използвали мобилни телефони в клас. Дали масовото отстраняване води до повишаване на качеството на образованието, е друг въпрос. Със сигурност не и за хилядите изключени млади хора.
Друга технология, която през последните години все повече навлиза в живота ни и която има голям потенциал, е принтирането на триизмерни обекти. Вече не е непосилно скъпо да си купиш 3D принтер и да „печаташ“ с него всевъзможни джвъчки. Дори и човек да не може сам да се справи с дизайна им, има предостатъчно готови модели.
На 3D принтерите се възлагат и сериозни надежди – да започнат да произвеждат например сърца за трансплантация, а създаденото с тяхна помощ веганско „месо“ в скоро време да стане финансово достъпно за потребителите.
Междувременно технологията вече се използва и за строеж на сгради, а в Тексас е изградено цяло предградие със 100 3D къщи и те не са несравнимо по-скъпи, отколкото ако бяха построени по „нормалния начин“. За сметка на това имат далеч по-голям шанс да устоят на природните стихии в сравнение с типичните американски дървени домове.
С навлизането на 3D принтерите се открива огромно поле пред архитектурата и дизайна. С помощта на технологията може да се „принтират“ неща, които доскоро са били конструктивно невъзможни. На този етап обаче като че ли няма популярни нови стилове, които да се базират на тази технология. А и перспективата да се появят, изглежда, не вдъхновява особено. Ако попитате хората какво е красиво, с голяма вероятност повечето от тях ще посочат образци от миналото, а не сгради, произведения или обекти с футуристичен дизайн.
Изкуственият интелект и 3D принтерите са само част от напредъка на технологиите и науката (теми, от които Анастасия Орманджиева, Михаил Ангелов и Йовко Ламбрев разбират далеч повече от мен). Използвам ги само като примери, с които да онагледя как (не) мислим бъдещето.
Разбирам, вероятно е много трудно да си млад човек днес и да живееш в постоянен ужас от бъдещето. Природните катаклизми стават все повече, войната чука на вратата на Европа, а не толкова далеч от нас систематично са избивани невинни хора. Доскорошни демокрации се превръщат в диктатури. Не беше отдавна времето, когато COVID-19 взе много жертви и обърка всекидневието на оцелелите за няколко години, а няма гаранции, че подобна пандемия няма да се повтори. Младежите, които тепърва започват професионалния си път, не могат да разчитат на финансова сигурност като родителите си (макар случаят в България да не е точно такъв). Те ще плащат за грешките на предишните поколения, включително на моето.
Колкото и банално да звучи обаче, бъдещето зависи от това какво искаме да бъде и какво правим сега. Ако ИИ ни плаши, трудно ще се научим да го използваме по смислен начин. Ако не вземаме мерки за решаване на екологичните и политическите проблеми, няма как да избегнем или поне да намалим щетите от тях.
Може би нашият човешки свят (или поне този, който познаваме) свършва – не знам. Както казва шотландският философ Дейвид Хюм, ако слънцето всеки ден изгрява, това не означава, че ще го направи и утре. Може и да не изгрее. Но пък може и да изгрее, а тогава все нещо ще трябва да правим.
Post Syndicated from Inanna Malick original https://blog.cloudflare.com/serverless-atproto/
Social media users are tired of losing their identity and data every time a platform shuts down or pivots. In the ATProto ecosystem — short for Authenticated Transfer Protocol — users own their data and identities. Everything they publish becomes part of a global, cryptographically signed shared social web. Bluesky is the first big example, but a new wave of decentralized social networks is just beginning. In this post I’ll show you how to get started, by building and deploying a fully serverless ATProto application on Cloudflare’s Developer Platform.
Why serverless? The overhead of managing VMs, scaling databases, maintaining CI pipelines, distributing data across availability zones, and securing APIs against DDoS attacks pulls focus away from actually building.
That’s where Cloudflare comes in. You can take advantage of our Developer Platform to build applications that run on our global network: Workers deploy code globally in milliseconds, KV provides fast, globally distributed caching, D1 offers a distributed relational database, and Durable Objects manage WebSockets and handle real-time coordination. Best of all, everything you need to build your serverless ATProto application is available on our free tier, so you can get started without spending a cent.
Let’s start with a conceptual overview of how data flows in the ATProto ecosystem:

Users interact with apps, which write updates to their personal repositories. Those updates trigger change events, which are published to a relay and broadcast through the global event stream. Any app can subscribe to these events — even if it didn’t publish the original update — because in ATProto, repos, relays, and apps are all independent components, which can be (and are) run by different operators.
User identity starts with handles — human-readable names like alice.example.com. Each handle must be a valid domain name, allowing the protocol to leverage DNS to provide a global view of who owns what account. Handles map to a user’s Decentralized Identifier (DID), which contains the location of the user’s Personal Data Server (PDS).
A user’s PDS manages their keys and repos. It handles authentication and provides an authoritative view of their data via their repo.

If you’d like to learn more, there’s a great article here: ATProto for distributed systems engineers.
What’s different here — and easy to miss — is how little any part of this stack relies on trust in a single service. DID resolution is verifiable. The PDS is user-selected. The client app is just an interface.
When we publish or fetch data, it’s signed and self-validating. That means any other app can consume or build on top of it without asking permission, and without trusting our backend.

We’ll be working with Statusphere, a tiny but complete demo app built by the ATProto team. It’s the simplest possible social media app: users post single-emoji status updates. Because it’s so minimal, Statusphere is a perfect starting point for learning how decentralized ATProto apps work, and how to adapt them to run on Cloudflare’s serverless stack.
In ATProto, all repository data is typed using Lexicons — a shared schema language similar to JSON-Schema. For Statusphere, we use the xyz.statusphere.status record, originally defined by the ATProto team:
{
"type": "record",
"key": "tid", # timestamp-based id
"record": {
"type": "object",
"required": ["status", "createdAt"],
"properties": {
"status": { "type": "string", "maxGraphemes": 1 },
"createdAt": { "type": "string", "format": "datetime" }
}
}
}
Lexicons are strongly typed, which allows for easy interoperability between apps.
In this section, we’ll follow the flow of data inside Statusphere: from authentication, to repo reads and writes, to real-time updates, and look at how we handle live event streams on serverless infrastructure.
ATProto’s core libraries are written in TypeScript, and Cloudflare Workers provide first-class TypeScript support. It’s the natural starting point for building ATProto services on Cloudflare Workers.
However, the ATProto TypeScript libraries assume a backend or browser context. Cloudflare Workers support using Node.js APIs in a serverless context, but the ATProto library’s use of the ‘error’ redirect handling mode isn’t compatible with the edge runtime.
Cloudflare also supports Rust in Workers via WASM cross-compilation, so I tried that next. The ATProto Rust crates and codegen tooling make strong use of Rust’s type system and build tooling, but they’re still in active development. Rust’s WASM ecosystem is solid, though, so I was able to get a working prototype running quickly by adapting an existing Rust implementation of Statusphere — originally written by Bailey Townsend. You can find the code in this GitHub repo.
If you’re building ATProto apps on Cloudflare Workers, I’d suggest contributing to the TypeScript libraries to better support serverless runtimes. A TypeScript version of this app would be a great next step — if you’re interested in building it, please get in touch via the Cloudflare Developer Discord server.
Use this Deploy to Cloudflare button to clone the repo and set up your own KV and D1 instances and a CI pipeline.
Follow the steps at this link, use the default values or choose custom names, and it’ll build and deploy your own Statusphere Worker.
Note: this project includes a scheduled component that reads from the public event stream. You may wish to delete it when you finish experimenting to save resources.
To interact with a user’s data, we start by resolving their handle to a DID using the record registered at the _atproto subdomain. For example, my handle is inanna.recursion.wtf, so my DID record is stored at _atproto.inanna.recursion.wtf. The value of that record is did:plc:p2sm7vlwgcbbdjpfy6qajd4g.
We then resolve the DID to its corresponding DID Document, which contains identity metadata including the location of the user’s Personal Data Server. Depending on the DID method, this resolution is handled directly via DNS (for did:web identifiers) or, more frequently, via the Public Ledger of Credentials for did:plc identifiers.
Since these values don’t change frequently, we cache them using Cloudflare KV — it’s perfect for cases like this, where we have some infrequently updated but frequently read key-value mapping that needs to be globally available with low latency.
From the DID document, we extract the location of the user’s Personal Data Server. In my case, it’s bsky.social, but other users may self-host their own PDS or use an alternative provider.
The details of the OAuth flow aren’t important here — you can read the code I used to implement it or dig into the OAuth spec if you’re curious — but the short version is: the user signs in via their PDS, and it grants our app permission to act on their behalf, using the signing keys it manages.
We persist session data in a secure session cookie using tower-sessions. This means that only an opaque session ID is stored client-side, and all session/oauth state data is stored in Cloudflare KV. Again, it’s a natural fit for this use case.
Using the DID stored in the session cookie, we restore the user’s OAuth session and spin up an authenticated agent:
let agent = state.oauth.restore_session(&did).await?;
With the agent ready, we fetch the user’s latest Statusphere post and their Bluesky profile.
let current_status = agent.current_status().await?;
let profile = agent.bsky_profile().await?;
With their status and profile info in hand, we can render the homepage:
Ok(HomeTemplate {
status_options: &STATUS_OPTIONS,
profile: Some(Profile {
did: did.to_string(),
display_name: Some(username),
}),
my_status: current_status,
})
When a user posts a new emoji status, we create a new record in their personal repo — using the same authenticated agent we used to fetch their data. This time, instead of reading, we perform a create record operation:
let uri = agent.create_status(form.status.clone()).await?.uri;
The operation returns a URI — the canonical identifier for the new record.
We then write the status update into D1, so it can immediately be reflected in the UI.
Every active homepage maintains a WebSocket connection to a Durable Object, which acts as a lightweight real-time message broker. When idle, the Durable Object hibernates, saving resources while keeping the WebSocket connections alive. We send a message to the Durable Object to wake it up and broadcast the new update:
state.durable_object.broadcast(status).await?;
The Durable Object then broadcasts the new update to every connected homepage:
for ws in self.state.get_websockets() {
ws.send(&status);
}
It then iterates over every live WebSocket and sends the update.
One practical note: Durable Objects perform better when sharded across instances. For simplicity, I’ve described the case where everything runs everything through one single Durable Object.
To scale beyond that, the next step would be using multiple Durable Object instances per supported location using location hints, to minimize latency for users around the globe and avoid bottlenecks if we encounter high numbers of concurrent users in a single location. I initially considered implementing this pattern, but it conflicted with my goal of creating a concise ‘hello world’ style example that ATProto devs could clone and use as a template for their app.
Publishing updates inside our own app is easy, but in the ATProto ecosystem, other applications can publish status updates for users. If we want Statusphere to be fully integrated, we need to pick up those events too.
Listening for live event updates requires a persistent WebSocket connection to the ATProto Jetstream service. Traditional server-based apps can keep WebSocket client sockets open indefinitely, but serverless platforms can’t — workers aren’t allowed to run forever.
We need a way to “listen” without running a live server.
To solve this, we moved the listening logic into a Cron Trigger — instead of keeping a live socket open, we used this feature to read updates in small batches using a recurring scheduled job.
When the scheduled worker invocation fires, it loads the last seen cursor from its persistent storage. Then it connects to Jetstream — a streaming service for ATProto repo events — filtered by the xyz.statusphere.status collection and starting at the last seen cursor.
let ws = WebSocket::connect("wss://jetstream1.us-east.bsky.network/subscribe?wantedCollections=xyz.statusphere.status&cursor={cursor}").await?;
We store a cursor — a microsecond timestamp marking the last message we received — in the Durable Object’s persistent storage, so even if the object restarts, it knows exactly where to resume. As soon as we process an event newer than our start time, we close the WebSocket connection and let the Durable Object go back to sleep.
The tradeoff: updates can lag by up to a minute, but the system stays fully serverless. This is a great fit for early-stage apps and prototypes, where minimizing infrastructure complexity matters more than achieving perfect real-time delivery.
If you want real time updates, and you’re willing to bend the serverless model slightly, you can deploy a lightweight listener process that maintains a live WebSocket connection to Jetstream.
Instead of polling once a minute, this process listens for new events for the xyz.statusphere.status collection and pushes updates to our Cloudflare Worker as soon as they arrive. When this mode is active, we disable the Cron Trigger step with an environment variable. You can find a sketch of this listener process here and the endpoint that handles updates from it here.
The result still isn’t a traditional server:
No public exposure to the web
No open HTTP ports
No persistent database
It’s just a single-purpose, stateless listener — something simple enough to run on a home server until your app grows large enough to need more serious infrastructure.
Later on, you could swap this design for something more scalable using tools like Cloudflare Queues to provide batching and retries — but for small-to-medium apps, this lightweight listener is an easy and effective upgrade.
Today, Durable Objects can hibernate while holding long-lived WebSocket server connections but don’t support hibernation when holding long-lived WebSocket client connections (like a Jetstream listener). That’s why Statusphere uses workarounds — scheduled Worker invocations via Cron Trigger and lightweight external listeners — to stay synced with the network.
Future improvements to Durable Objects — like adding support for hibernating active WebSocket clients — could remove the need for these workarounds entirely.
This is a full-featured atproto app running entirely on Cloudflare with zero servers and minimal ops overhead. Workers run your code within 50 ms of most users, KV and D1 keep your data available, and Durable Objects handle WebSocket fan-out and live coordination.
Use the Deploy to Cloudflare Button to clone the repo and set up your serverless environment. Then show us what you build. Drop a link in our Discord, or tag @cloudflare.social on Bluesky or @CloudflareDev on X — we’d love to see it.
Post Syndicated from Natasha Rabinov original https://www.backblaze.com/blog/legal-hold-is-here-protect-your-business-when-it-matters-most/

Whether you’re navigating HR issues, facing down litigation, or ensuring operational readiness in the face of uncertainty, you need to be ready to preserve your data. When the stakes are high, Legal Hold, a new feature in Backblaze Computer Backup with Enterprise Control, can help you stay ready.
Available today, Legal Hold gives administrators the power to preserve every version of a user’s backup with a single click. No extra hardware, no new software—all at the same flat-rate pricing of Backblaze Computer Backup with Enterprise Control.
Let’s dig into what Legal Hold is, its importance, and how Backblaze implements it to meet enterprise needs.
A legal hold, also known as a litigation hold, is a process that organizations use to preserve electronically stored information (ESI) when they face actual or anticipated litigation, audits, or investigations. It ensures that relevant data—such as emails, documents, and file backups—is not deleted, altered, or lost. Once enabled, Backblaze Computer Backup’s Legal Hold feature will preserve a user’s entire backup, including every historical version captured, with a single click.
A legal hold is typically triggered when an organization becomes aware of a legal claim or regulatory inquiry. Once in place, normal data retention policies are suspended for any affected data, ensuring it remains available for legal review.
At Backblaze, we’ve designed our Legal Hold for Computer Backup feature to be powerful, simple, and reliable. Here’s how it works:
In today’s landscape, Legal Hold isn’t just a “nice to have.” It’s a must-have for almost every organization:
Now, any business using Backblaze Computer Backup with Enterprise Control can implement Legal Hold in just a few clicks—making it easier than ever to stay compliant, reduce legal risk, and prepare for the unexpected.
Already a customer? You can start using Legal Hold today. See our docs article or log in to your admin console.
Not yet on Backblaze? Reach out to our Sales team to start a free 15-day trial.
The post Legal Hold Is Here: Protect Your Business When It Matters Most appeared first on Backblaze Blog | Cloud Storage & Cloud Backup
Post Syndicated from Анета Василева original https://www.toest.bg/urbitsid-ruinite-na-voynata-i-provalite-na-arhitekturata/

Венеция, началото на юли, 35 градуса на сянка. Някъде по средата на „Арсенале“, големия индустриален комплекс, където е подредена кураторската изложба на тазгодишното Венецианско архитектурно биенале, има една малка инсталация, наречена Circularity on the Edge [„Кръговост на ръба“ – б.р.], която е подходяща отправна точка за този текст.
Украинската инсталация Circularity on the Edge на Венецианското биенале. Снимки: Анета Василева
На пръв поглед инсталацията не е нищо особено. Тухли, камъни, парчета дърво, изолационни панели и всякакви строителни отпадъци висят на метални струни в своеобразна разпадната скулптура. Пред тях на екран се демонстрират възможностите на изкуствен интелект (ИИ) сред руините на сгради, унищожени от военен конфликт, да идентифицира чрез дрон материалите, които може да се преизползват за ново строителство, и да ги подрежда по степен на надеждност или замърсеност (установявайки например наличието на азбест в тях). Екипът е украински, а ИИ моделът е тестван на терена на украинския град Буча, разрушен през пролетта на 2022 г. Това е една от многото инсталации на тема екология, преизползване и климат на тазгодишното биенале.
Другата инсталация се намира в Джардини, в павилиона на Великобритания, и под името Objects of Repair [„Обекти на възстановяването“ – б.р.] показва начини за използване на материали от руините на Газа за възстановяване на унищожената архитектурна тъкан там.
Биеналето във Венеция винаги е било снобско място, но особено след 2021 г. започна се оформя като все по-претенциозен елитарен клуб, в който кураторите сякаш изобщо нямат идея в какво време живеем и какви са проблемите му. Тазгодишният куратор – италианецът Карло Рати, професор в Масачузетския технологичен университет, където ръководи някаква си Senseable City Lab, измисли темата Intelligens. Natural. Artificial. Collective и сглоби едно дистопично биенале, което е пълно с инсталации, основани на фалшификации и неработещи в жегата роботи, и принизява архитектурата до клакьор на все по-притеснителните глобални технологични лидери и техните високотехнологични фантазии в стил киберпънк.
Но да се върнем на украинската инсталация, която, за разлика от повечето в „Арсенале“, изглеждаше като да има смисъл в този наш свят, разкъсван от войни. И по-скоро да се върнем на нейната тема – войни, разрушени градове, реконструкции. Само че заглавната снимка на тази статия не е от Буча и това не е случайно. Погледнете я отново. Тази снимка всъщност е колаж (при това авторски, не направен от ИИ), в който умишлено са събрани две снимки. Те много си приличат, макар че ги делят 80 години.

Първата е от Полша през 1943 г. Така изглежда Варшавското еврейско гето, създадено от нацистка Германия, след трагичния край на въстанието там през 1943 г. Кварталът е изравнен със земята, а от развалините насред пустошта стърчи само църквата „Свети Августин“ на улица „Новолипки“, която нацистите оставят като „арийска“ постройка. Това е един от най-известните пейзажи на урбицид (умишленото и пълно унищожение на застроена градска среда) в новата история на Европа.
Втората снимка е на Reuters от Джабалия, в ивицата Газа. Тя е направена през януари тази година, по време на примирието между Израел и „Хамас“. Изгледът от дрон показва редици от сгради, лежащи в руини след 15 месеца война – напълно необитаеми, почти несъществуващи.
И така стигаме до истинската тема на този текст.
Какво е урбицид?
Урбицидът е убийството на един град. От древни времена до наши дни да видиш града си в руини е първична травма. А урбицидът е едно от най-първичните престъпления.
Не е трудно да се разбере защо. Строителството на градове е опит за колективно безсмъртие – ние може да умрем, но обемите и структурите на нашия град ще продължат да живеят и след нас. Освен ако не бъдат умишлено заличени.
Как самотно седи градът, някога си многолюден! (1:1)
Така започва библейският разказ за унищожението на Йерусалим, описано в Книгата „Плач Иеремиев“ от Стария завет. И продължава:
Цял негов народ въздиша, търсейки хляб, дава своите драгоценности за храна – душа да подкрепи. „Погледни, Господи, и виж, колко съм унизен!“ (1:11)
През 1984 г., в един свой текст, публикуван в нюйоркския седмичник The Village Voice, американският философ Маршал Бърман използва този цитат, необичаен за марксист като него, за да изрази собствения си ужас от руините на Ню Йорк и особено на Бронкс през 70-те и началото на 80-те години на ХХ век.
И наистина, тогава американските градове и особено техните центрове са съсипваща гледка. „Добре дошли в града на страха“ е брошурата, с която посрещат туристите на летището в Ню Йорк през 1975 г. – ръководство за оцеляване в града със съвети, включващи да не се използва метрото и да не се ходи никъде след 18:00 часа. Пословични са историите за горящите Бронкс и Бруклин, за фалита на Ню Йорк и нежеланието на президента Форд да го подкрепи, за бандите в Чикаго, за бунтовете и полицейското насилие, за скоростните магистрали, разсичащи градовете, обезлюдяващи исторически общности и създаващи около себе си гета. За хората, които напускат града, за да се спасят в предградията. Това всъщност са разкази за пълното разпадане на социалната и градската структура на много места в САЩ през тези години.
Вярно е, че през 70-те години Южен Бронкс и Браунсвил приличат много на Ротердам, Варшава и Берлин през 1945 г., след бомбардировките от Втората световна война. С една важна разлика, както посочва самият Бърман – мъртвите са далеч по-малко. И още нещо.
За Бърман, колкото и да е мъчително да живееш сред руини, да живееш в свят без руини би било още по-лошо. Защо? Защото, както пише той,
свят, в който всички руини са разчистени, е свят, който иска да забрави.
Случаят с Варшава през 1945 г. обаче съвсем не е такъв. След войната започва осъзнатото разчистване на полската столица от руините и нейното героично пълно възстановяване, за да бъде миналото помнено, а не забравено. Това всъщност ни води към важния въпрос и днес – как и защо възстановяваме един унищожен град. Именно този въпрос е тясно свързан със смисъла на архитектурата и с нейните морални задължения.
В края на 1944 г. Варшава е подложена на систематично унищожение от германските сили като възмездие за Варшавското въстание, избухнало през август същата година. Няколко квартала са изравнени със земята. Така след унищожението и на еврейското гето година по-рано над 85% от сградите на левия бряг на река Висла са разрушени, а Старият град е изравнен със земята. Когато в началото на 1945 г. хората започват да се връщат в града, те попадат сред печално море от развалини. Мащабът на разрушенията е толкова смазващ, че правителството обмисля да премести столицата в Краков или Лодз. Или дори да запази руините на Варшава като паметник и да построи изцяло нов град.
През януари 1945 г. обаче временното правителство решава да възстанови Варшава – не просто бързо да я реконструира, но и да реставрира напълно всички разрушени исторически сгради. Създадена е специална Служба за възстановяване на Варшава и през първите няколко години след войната почти половината от финансовите и материалните ресурси на Полската народна република са насочвани към реконструирането на столицата.
След Втората световна война много европейски градове трябва да бъдат напълно възстановени от руините и всеки избира различен път.
Така и до днес идеята за Варшава като град феникс, възроден от руините след войната, е ключова част от полската идентичност.



Варшава по време на Втората световна война и днес. Снимки на страници от книгата на Ярослав Зеленски Warsaw Destroyed and Rebuilt, Festina, 2016: Анета Василева.
От гледна точка на международно приетите практики за опазване на културното наследство работата на Службата за възстановяване на Варшава е изключително противоречива. Къде е автентичността? Оригиналният исторически контекст е напълно изчезнал. Всички тези чисто нови „исторически сгради“ всъщност са пълен фалшификат. Никоя реконструкция, дори и най-прецизната, няма потенциала да пресъздаде многопластовостта на оригинала, която е резултат от използването на сградата в различни времена. Всяка реставрирана сграда всъщност е нова сграда.
Но през 1946 г. Ян Захватович, главният консерватор на историческите паметници във Варшава, е категоричен:
Цели страници от нашата история, написани в архитектура, бяха умишлено изтръгнати. Не можем да приемем това. Чувството за отговорност пред бъдещите поколения изисква възстановяване на унищоженото ни наследство, една пълноценна реконструкция, която признава трагедията на създадения по този начин консервационен фалш.*
През 1980 г. реконструираният исторически център на Варшава е включен в Списъка на световното културно наследство на ЮНЕСКО като изключителен пример за почти пълна реконструкция на материална среда от исторически период, обхващащ седем века.
Във Варшава обаче, освен идентичността, следвоенното възстановяване носи със себе си и някои по-малко познати промени в градската структура, които отразяват преоткритата социална роля на архитектурата в следвоенната епоха.

След разрушаването на града през Втората световна война възниква парадоксална възможност за неговото устройствено модернизиране. При възстановяването на града улиците са разширени, парковете са уголемени, създадени са нови. И въпреки настоящия неолиберален строителен бум Варшава все още е един много зелен град. Дори дворовете зад фасадите на изградения през 40-те и 50-те години Стар град са разширени, а районите край река Висла остават умишлено незастроени като част от историческия градски пейзаж.
Така, оказва се, урбицидът е и време за архитектурата да преосмисли миналото, да заеме позиция, да говори, да има мнение, да промени нещо.
Как можеш да пишеш за сгради, за къщи, за обмислени планове и изчистени детайли, когато градове се изравняват със земята в реално време? –
запита през март 2024 г. архитектурният критик на Financial Times Едуин Хийткоут. Той бе сред малцината критици, публично изразили ужаса си от гледката на пълното разрушаване на градската тъкан в Газа. Статията му се появи в популярното онлайн списание за архитектура Dezeen, а коментарите към нея бяха изключени „поради чувствителния характер на темата“.
В статията си Хийткоут е мрачен и тъжен:
От месеци се боря с това чувство на страх и безсилие. Не защото критиците имат значение – всъщност точно защото очевидно нямаме значение. Архитектурна критика? Наистина ли? Ние пишем, защото ни плащат. Но то е все повече с усещането за пълзяща неуместност.
Не ми е известно някой друг архитектурен критик да е написал нещо през последните 18 месеца за урбицида, който се разразява в Газа. През същия този март 2024 г. след статията си в Dezeen дори самият автор в колонката си във Financial Times се занимава с обичайните лъскави и безопасни теми, като новия носител на наградата „Прицкер“, италиански дизайнери от средата на миналия век или изложбата „Тропически модернизъм“ в Лондон. Както впрочем и колегите му в Guardian и New York Times.
Междувременно към януари 2025 г. според доклад на ООН 92% от жилищните сгради в Газа са разрушени или необитаеми, а намиращата се в Лондон високотехнологична разследваща организация Forensic Architecture, основана от родения в Израел архитект Еял Вайцман, събра всички данни в интерактивна карта, която визуализира последиците от конфликта. В средата на юли 2025 г. BBC Verify пусна подробен репортаж за контролирано разрушаване с експлозии и булдозери на до 100% от градската тъкан в различни зони на ивицата след края на примирието, включително такива, които до момента са останали относително незасегнати.
Разрушенията настрана – те обикновено, уви, вълнуват основно малки и неправителствени архитектурни организации. Но когато стане дума за възстановяване и реконструкции, интересът на истински амбициозните архитекти рязко се покачва, а моралът им ясно си проличава. Всъщност не е ли цинизъм да се говори за възстановяване на градовете, докато войната в тях още бушува?
Например, както писах още през април 2022 г., само три месеца след началото на инвазията на Русия в Украйна британският стархитект Норман Фостър предложи помощта си за възстановяване на разрушения украински град Харков. Още тогава беше видно, че световният архитектурен елит иска да покаже съпричастност с Украйна – същият този елит, който само няколко години по-рано с удоволствие приемаше поръчки от Москва. През декември 2023 г. Norman Foster Foundation вече беше готова със своя нов устройствен план за реконструкцията на Харков. Той беше посрещнат от украинските архитекти като опит за интелектуална колонизация – измислили сме решение за вас, може и да ви консултираме в някоя по-късна фаза.
Разбира се, далеч по-шокиращ беше генерираният с ИИ клип Trump Gaza за превръщането на обитаваната от палестинци територия в луксозен курорт, който американският президент популяризира чрез социалната мрежа Truth Social през февруари 2025 г.
И май наистина си вярваше, че Газа може да стане „Ривиерата на Близкия изток“, макар че, както се разбра по-късно, клипът е бил създаден като политическа сатира от американския режисьор от еврейски произход Соло Авитал. Но публикуваният в израелската преса няколко месеца по-рано план Gaza 2035 за трансформация на територията във високотехнологична зона със стъклени небостъргачи и буйна зеленина изглежда съвсем убедителен.

В същото време палестински архитекти се опитват да влязат на терен и да помогнат с адхок решения за реконструкции с подръчни материали.
Преди няколко седмици британският историк Тимъти Гартън Аш припомни думите на Бертолт Брехт:
Какви времена са дошли, че един разговор за дървета да бъде престъпно деяние, защото той включва мълчание за злодействата.
Същото важи в момента за разговорите за архитектура. Как обсъждаме красиви сгради, ходим на събития или пишем за нови музеи и изложби сред сцените на разрушения, човешки трагедии и морално безсилие, които напоследък станаха ежедневие? Как критикуваме градски проблеми, нови улици, велоалеи или състоянието на нечие културно наследство в ситуация на ескалиращи световни конфликти и обезсмисляне на международните институции и споразумения, създадени след Втората световна война?
Защото убийството на един град засяга всички нас – бавно или драстично деградира градската среда, унищожава общностите и вярата в човечеството, но и самия смисъл на архитектурната професия. Дали в Бахмут или Газа, в Бейрут или Сараево, в Белфаст или Бронкс през 70-те години на ХХ век – тези руинирани пейзажи и градове от прах трябва да накарат архитектурата да реагира и да се промени. Въпросът е дали успяват.
* Цитатът е взет от експозиция на музей във Варшава. Превод: Анета Василева. – Б.р.
Post Syndicated from Тоест original https://www.toest.bg/ot-visokoto-kape-med/

от високото капе мед
в короната на дъба
дивите пчели се роят
и не им пука особено
дали някой
ще им вземе меда
ангажирани с преместването
на целия си свят
пчелите не забелязват
как към тях
приближава мечка
тя поглежда лакомо
към жужащата корона
в този момент
върху муцуната ѝ
капва капка мед
умилен от момента
ловецът свежда своята пушка
друг път ще стреля
друг път
не сега
Владислав Христов
Владислав Христов е автор на книгите „Снимки на деца“ (кратки прозаични форми, 2010), „Енсо“ (поезия, 2012), „Фи“ (поезия, 2013), „Германии“ (поезия, 2014), „Обратно броене“ (поезия, 2016), „Продължаваме напред“ (публицистика, 2017), Germanii (поезия, немско издание, 2018), „Комореби“ (поезия, 2019), „Писма до Лазар“ (поезия, 2020), „Мопсът на Вазов“ (кратки прозаични форми, 2021, номинирана за Награда „Пловдив“), „Мед от оси“ (фейлетони, 2023), „Пойни птици“ (поезия, 2024), „Маслен нос“ (поезия, 2025). Съставител е на „Основи на хайку“ – първия учебник по хайку на български. Текстовете му са превеждани на 18 езика. През 2016 г. хайку на Владислав Христов е включено в обучителната програма на Университета „Кумамото“, Япония.
Според Екатерина Йосифова „четящият стихотворение сутрин… добре понася другите часове“ от деня. Убедени, че поезията държи умовете ни будни, а сърцата – отворени, в края на всеки месец ви предлагаме по едно стихотворение. Защото и в най-смутни времена доброто стихотворение е добра новина.
Post Syndicated from Bruce Schneier original https://www.schneier.com/blog/archives/2025/07/how-solid-protocol-restores-digital-agency.html
The current state of digital identity is a mess. Your personal information is scattered across hundreds of locations: social media companies, IoT companies, government agencies, websites you have accounts on, and data brokers you’ve never heard of. These entities collect, store, and trade your data, often without your knowledge or consent. It’s both redundant and inconsistent. You have hundreds, maybe thousands, of fragmented digital profiles that often contain contradictory or logically impossible information. Each serves its own purpose, yet there is no central override and control to serve you—as the identity owner.
We’re used to the massive security failures resulting from all of this data under the control of so many different entities. Years of privacy breaches have resulted in a multitude of laws—in US states, in the EU, elsewhere—and calls for even more stringent protections. But while these laws attempt to protect data confidentiality, there is nothing to protect data integrity.
In this context, data integrity refers to its accuracy, consistency, and reliability…throughout its lifecycle. It means ensuring that data is not only accurately recorded but also remains logically consistent across systems, is up-to-date, and can be verified as authentic. When data lacks integrity, it can contain contradictions, errors, or outdated information—problems that can have serious real-world consequences.
Without data integrity, someone could classify you as a teenager while simultaneously attributing to you three teenage children: a biological impossibility. What’s worse, you have no visibility into the data profiles assigned to your identity, no mechanism to correct errors, and no authoritative way to update your information across all platforms where it resides.
Integrity breaches don’t get the same attention that confidentiality breaches do, but the picture isn’t pretty. A 2017 write-up in The Atlantic found error rates exceeding 50% in some categories of personal information. A 2019 audit of data brokers found at least 40% of data broker sourced user attributes are “not at all” accurate. In 2022, the Consumer Financial Protection Bureau documented thousands of cases where consumers were denied housing, employment, or financial services based on logically impossible data combinations in their profiles. Similarly, the National Consumer Law Center report called “Digital Denials” showed inaccuracies in tenant screening data that blocked people from housing.
And integrity breaches can have significant effects on our lives. In one 2024 British case, two companies blamed each other for the faulty debt information that caused catastrophic financial consequences for an innocent victim. Breonna Taylor was killed in 2020 during a police raid on her apartment in Louisville, Kentucky, when officers executed a “no-knock” warrant on the wrong house based on bad data. They had faulty intelligence connecting her address to a suspect who actually lived elsewhere.
In some instances, we have rights to view our data, and in others, rights to correct it, but these sorts of solutions have only limited value. When journalist Julia Angwin attempted to correct her information across major data brokers for her book Dragnet Nation, she found that even after submitting corrections through official channels, a significant number of errors reappeared within six months.
In some instances, we have the right to delete our data, but—again—this only has limited value. Some data processing is legally required, and some is necessary for services we truly want and need.
Our focus needs to shift from the binary choice of either concealing our data entirely or surrendering all control over it. Instead, we need solutions that prioritize integrity in ways that balance privacy with the benefits of data sharing.
It’s not as if we haven’t made progress in better ways to manage online identity. Over the years, numerous trustworthy systems have been developed that could solve many of these problems. For example, imagine digital verification that works like a locked mobile phone—it works when you’re the one who can unlock and use it, but not if someone else grabs it from you. Or consider a storage device that holds all your credentials, like your driver’s license, professional certifications, and healthcare information, and lets you selectively share one without giving away everything at once. Imagine being able to share just a single cell in a table or a specific field in a file. These technologies already exist, and they could let you securely prove specific facts about yourself without surrendering control of your whole identity. This isn’t just theoretically better than traditional usernames and passwords; the technologies represent a fundamental shift in how we think about digital trust and verification.
Standards to do all these things emerged during the Web 2.0 era. We mostly haven’t used them because platform companies have been more interested in building barriers around user data and identity. They’ve used control of user identity as a key to market dominance and monetization. They’ve treated data as a corporate asset, and resisted open standards that would democratize data ownership and access. Closed, proprietary systems have better served their purposes.
There is another way. The Solid protocol, invented by Sir Tim Berners-Lee, represents a radical reimagining of how data operates online. Solid stands for “SOcial LInked Data.” At its core, it decouples data from applications by storing personal information in user-controlled “data wallets”: secure, personal data stores that users can host anywhere they choose. Applications can access specific data within these wallets, but users maintain ownership and control.
Solid is more than distributed data storage. This architecture inverts the current data ownership model. Instead of companies owning user data, users maintain a single source of truth for their personal information. It integrates and extends all those established identity standards and technologies mentioned earlier, and forms a comprehensive stack that places personal identity at the architectural center.
This identity-first paradigm means that every digital interaction begins with the authenticated individual who maintains control over their data. Applications become interchangeable views into user-owned data, rather than data silos themselves. This enables unprecedented interoperability, as services can securely access precisely the information they need while respecting user-defined boundaries.
Solid ensures that user intentions are transparently expressed and reliably enforced across the entire ecosystem. Instead of each application implementing its own custom authorization logic and access controls, Solid establishes a standardized declarative approach where permissions are explicitly defined through control lists or policies attached to resources. Users can specify who has access to what data with granular precision, using simple statements like “Alice can read this document” or “Bob can write to this folder.” These permission rules remain consistent, regardless of which application is accessing the data, eliminating the fragmentation and unpredictability of traditional authorization systems.
This architectural shift decouples applications from data infrastructure. Unlike Web 2.0 platforms like Facebook, which require massive back-end systems to store, process, and monetize user data, Solid applications can be lightweight and focused solely on functionality. Developers no longer need to build and maintain extensive data storage systems, surveillance infrastructure, or analytics pipelines. Instead, they can build specialized tools that request access to specific data in users’ wallets, with the heavy lifting of data storage and access control handled by the protocol itself.
Let’s take healthcare as an example. The current system forces patients to spread pieces of their medical history across countless proprietary databases controlled by insurance companies, hospital networks, and electronic health record vendors. Patients frustratingly become a patchwork rather than a person, because they often can’t access their own complete medical history, let alone correct mistakes. Meanwhile, those third-party databases suffer regular breaches. The Solid protocol enables a fundamentally different approach. Patients maintain their own comprehensive medical record, with data cryptographically signed by trusted providers, in their own data wallet. When visiting a new healthcare provider, patients can arrive with their complete, verifiable medical history rather than starting from zero or waiting for bureaucratic record transfers.
When a patient needs to see a specialist, they can grant temporary, specific access to relevant portions of their medical history. For example, a patient referred to a cardiologist could share only cardiac-related records and essential background information. Or, on the flip side, the patient can share new and rich sources of related data to the specialist, like health and nutrition data. The specialist, in turn, can add their findings and treatment recommendations directly to the patient’s wallet, with a cryptographic signature verifying medical credentials. This process eliminates dangerous information gaps while ensuring that patients maintain an appropriate role in who sees what about them and why.
When a patient—doctor relationship ends, the patient retains all records generated during that relationship—unlike today’s system where changing providers often means losing access to one’s historical records. The departing doctor’s signed contributions remain verifiable parts of the medical history, but they no longer have direct access to the patient’s wallet without explicit permission.
For insurance claims, patients can provide temporary, auditable access to specific information needed for processing—no more and no less. Insurance companies receive verified data directly relevant to claims but should not be expected to have uncontrolled hidden comprehensive profiles or retain information longer than safe under privacy regulations. This approach dramatically reduces unauthorized data use, risk of breaches (privacy and integrity), and administrative costs.
Perhaps most transformatively, this architecture enables patients to selectively participate in medical research while maintaining privacy. They could contribute anonymized or personalized data to studies matching their interests or conditions, with granular control over what information is shared and for how long. Researchers could gain access to larger, more diverse datasets while participants would maintain control over their information—creating a proper ethical model for advancing medical knowledge.
The implications extend far beyond healthcare. In financial services, customers could maintain verified transaction histories and creditworthiness credentials independently of credit bureaus. In education, students could collect verified credentials and portfolios that they truly own rather than relying on institutions’ siloed records. In employment, workers could maintain portable professional histories with verified credentials from past employers. In each case, Solid enables individuals to be the masters of their own data while allowing verification and selective sharing.
The economics of Web 2.0 pushed us toward centralized platforms and surveillance capitalism, but there has always been a better way. Solid brings different pieces together into a cohesive whole that enables the identity-first architecture we should have had all along. The protocol doesn’t just solve technical problems; it corrects the fundamental misalignment of incentives that has made the modern web increasingly hostile to both users and developers.
As we look to a future of increased digitization across all sectors of society, the need for this architectural shift becomes even more apparent. Individuals should be able to maintain and present their own verified digital identity and history, rather than being at the mercy of siloed institutional databases. The Solid protocol makes this future technically possible.
This essay was written with Davi Ottenheimer, and originally appeared on The Inrupt Blog.
Post Syndicated from Liz Eaton original https://www.raspberrypi.org/blog/hello-world-podcast-what-does-ai-education-look-like-around-the-world/
In a rapidly evolving digital landscape, AI literacy is becoming as fundamental as traditional reading and writing. The latest episode of the Hello World podcast explores this crucial topic, bringing together experts from Kenya, Lithuania, and Malaysia to discuss the current state of AI literacy in their countries. Together, they shed light on the challenges and immense potential of AI education globally.
This episode features a conversation led by Ben Garside (Raspberry Pi Foundation), with contributions from Leonida Soi (Raspberry Pi Foundation, Kenya), Aimy Lee (Penang Science Cluster, Malaysia), and Monika Katkutė-Gelžinė (Vedliai, Lithuania). All are key collaborators in the Raspberry Pi Foundation’s AI literacy programme, Experience AI.
One of the most striking takeaways from the conversation is the universal excitement surrounding AI, coupled with a significant need for foundational digital literacy. As Leonida explains:
“There’s an excitement about AI literacy, both from the learners and the teachers… However, one thing to look into is, we still have low digital literacy. As much as we are bringing in AI, if it is not bundled up together with digital literacy, then there is also misuse.”

This highlights a crucial point: simply introducing AI tools isn’t enough. A solid understanding of digital fundamentals is essential for responsible and effective use of AI.
The discussion also reveals the varying approaches to AI education in different countries. Monika shares her experience in Lithuania:
“We’ve been teaching AI for the last 5 years… I see a lot of opportunity in it, but a lot of challenges not to overburden teachers with the noise and changes.”
Her insight highlights the ongoing need for teacher training and sustainable pedagogical strategies, particularly in a field that evolves so quickly.
A key theme throughout the podcast is the importance of integrating AI literacy beyond traditional computer science classrooms. As Leonida emphasises:
“It’s time that AI literacy is looked at from a broader view, not just in computing… something that cuts across all the learning areas.”
This sentiment is echoed by Monika, who suggests:
“I feel like the entire education system needs to go through an AI filter and come out of it with a bit more efficiency, with a bit more understanding, so it lives in a 21st-century AI world. And I see AI as a form of, you know, building and also as a co-worker for everyone in the future.”

The vision of AI as a “co-worker” for all, empowering young people rather than replacing them, offers a powerful perspective for future education.
Equity is another critical issue, particularly in rural areas. Aimy highlights the ongoing challenge of access:
“The digital divide is in the access to devices, as well as access to high-speed internet connections… but the other thing is also in terms of trained teachers as well.”
Leonida adds that in Kenya there’s a need for unplugged activities to give students an idea of what the world is doing, so that we can start to bridge that gap.
These insights highlight the need for equitable access and innovative teaching methods to ensure no one is left behind.
For teachers who might feel overwhelmed by the prospect of teaching AI, the advice is clear and encouraging. Aimy suggests:
“Start small, cover one topic at a time, one concept at a time. Don’t feel the need to cover everything all at the same time.”

Leonida advocates for the power of community, suggesting a “community of practice where [teachers] can share amongst each other and where they can encourage others.”
Building a network of support and shared resources is key as educators take their first steps into teaching AI.
This episode of the Hello World podcast is a powerful reminder that AI literacy is not just a skill, but a mindset that needs to be nurtured across all subjects and communities. It also underscores that the commitment to prepare the next generation for an AI-powered world is global.
Listen to the full episode of the Hello World podcast to learn more about the global state of AI literacy and gain practical insights for your classroom.
The Experience AI programme is a collaboration between the Raspberry Pi Foundation and Google DeepMind to help young people and educators understand and engage with artificial intelligence. Through free, classroom-ready resources, professional development for teachers, and global partnerships, the programme aims to make AI literacy accessible to all, regardless of geography or background. By supporting educators and inspiring students, Experience AI is helping to prepare the next generation to thrive in a world increasingly shaped by artificial intelligence.
Find out more about Experience AI and how it can support you to bring AI literacy skills to your learners.
The post Hello World podcast: What does AI education look like around the world? appeared first on Raspberry Pi Foundation.
Post Syndicated from The Atlantic original https://www.youtube.com/watch?v=8JQqu85Fj9o