Experts share advice on how to assess your risk.
Source: NYT > Well.
-
Drake has tapped Central Cee for a new song. The Toronto musician debuted “Which One” on Thursday evening, July 24, during the second episode of his Iceman livestream series. The track played while Drake and Central Cee watched a woman dance in an empty swimming pool. Listen to the new single below.
Earlier this month, Drake dropped “What Did I Miss?”, a rare solo single that addressed his beef with Kendrick Lamar. In February, he also shared $ome $exy $ongs 4 U, a collaborative album with PartyNextDoor that includes “Nokia.” Drake and PartyNextDoor are currently on tour in Europe and will remain on the road through September.
Drake is currently suing Universal Music Group (UMG) in federal court, claiming that the label’s promotion of Lamar’s “Not Like Us” constituted defamation and harassment. Lawyers for UMG have since filed a motion asking the court to dismiss Drake’s lawsuit.
Central Cee last teamed up with Drake for an “On the Radar Freestyle” in 2023. The British rapper released his debut studio album, Can’t Rush Greatness, in January.
Revisit Kieran Press-Reynolds’ Rabbit Holed column “On Drake’s Gambling Streams, Everybody Loses.”
Source: RSS: News.
-
Earlier this month, Tame Impala mastermind Kevin Parker shared a series of studio photos on Instagram with the caption “Been busy😉.” Naturally, speculation grew that new Tame Impala music was imminent. Now, Parker has released the first new Tame Impala song in years. The seven-minute “End of Summer” serves as Tame Impala’s Columbia Records debut, and it comes with a music video directed by Julian Klincewicz. Watch the largely split-screen video below.
“End of Summer” is the first unaccompanied Tame Impala song since 2023’s “Journey to the Real World,” which Parker made for Barbie. In fact, a lot of Tame Impala’s recent music has been made for movies. There was “Wings of Time,” for the film Dungeons & Dragons: Honor Among Thieves; Parker’s remix of “Edge of Reality,” for Elvis; and “Turn Up the Sunshine,” a Diana Ross collaboration for Minions: The Rise of Gru.
“Turn Up the Sunshine” is just one of a handful of collaboration that Parker has made since 2020’s The Slow Rush. He did “No More Lies” with Thundercat, “One Night/All Night” and “Neverender” with Justice, “New Gold” with Gorillaz, and “Call My Phone Thinking I’m Doing Nothing Better” with the Streets. Parker has also made official remixes for 070 Shake, the Crowded House, and Justice. As a producer and songwriter, he worked heavily on Dua Lipa’s Radical Optimism.
Earlier this year, Parker won his first-ever Grammy Award. He and Justice took home Best Dance/Electronic Recording for “Neverender.”
Source: RSS: News.
-
Chuck Mangione, the fedora-sporting flugelhorn and trumpet player whose 1977 smooth jazz hit “Feels So Good” left an indelible mark on American pop culture, has died. In a statement reported by Rochester, New York’s Democrat and Chronicle, Mangione’s family shared that he “peacefully passed away in his sleep at his home in Rochester, New York,” on Tuesday, July 22. A cause of death was not provided. Mangione was 84.
Born in Rochester, on November 29, 1940, Charles Frank Mangione began playing piano at age eight, though he soon switched to the trumpet after seeing the Kirk Douglas film Young Man With a Horn. His older brother, Gaspare, was a pianist, and their father would frequently take both boys to see jazz shows at the local Ridgecrest Inn, after which he’d invite the performers to have dinner at the family’s home. One of these musicians was Dizzy Gillespie, who gifted a teenage Mangione one of his trumpets.
As high schoolers, Gaspare and Chuck played in a quintet called the Jazz Brothers. In 1958, the younger Mangione attended Rochester’s Eastman School of Music, where he began studying the flugelhorn. The Jazz Brothers put out their self-titled debut album on Riverside Records imprint Jazzland in 1960, then shared two more the following year. After graduating, Mangione played in Woody Herman and Maynard Ferguson’s big band ensembles, then joined Art Blakely’s Jazz Messengers thanks to a recommendation from Gillespie.
By the late 1960s, Mangione had returned to Eastman as director of the school’s jazz ensemble. His big break as a solo artist arrived via a 1970 performance of his original material alongside the Rochester Philharmonic, which was recorded and privately released as Friends & Love…A Chuck Mangione Concert. The album got Mangione signed to Mercury Records and yielded his first Grammy nomination—of an eventual 14—for “Hill Where the Lord Hides.”
Mangione graduated from Mercury to A&M in 1975. Shortly thereafter, he won a Grammy Award—Best Instrumental Composition for “Bellavia,” a tribute to his mother—and contributed a song, “Chase the Clouds Away,” to the 1976 Summer Olympic Games in Montreal. It was Mangione’s 1977 LP Feels So Good, however, that cemented his legacy. The album went double platinum and hit No. 2 on the Billboard albums chart, while a radio edit of its title track—the original clocks in at 9:31—peaked at No. 4 on the Hot 100.
“Feels So Good” has since appeared on the soundtracks to Fargo, Zombieland, and Doctor Strange. During the 1990s and 2000s, Mangione held a recurring role in Mike Judge’s beloved animated sitcom King of the Hill, where he played himself as a spokesman for the fictional supermarket chain Mega Lo Mart. (The store’s slogan: “where shopping feels so good.”)
Source: RSS: News.
-
Three years ago, the world learned that a sequel to This Is Spinal Tap was finally in the works. Now, Bleecker Street has unveiled the first trailer for the film, which reunites Christopher Guest, Michael McKean, and Harry Shearer with director Rob Reiner… and some very special guests. The teaser for Spinal Tap II: The End Continues features appearances from Paul McCartney, Elton John, Questlove, and others, while Reiner reprises his role as director Martin “Marty” Di Bergi, and Guest, McKean, and Shearer slip into aging versions of their original characters Nigel Tufnel, David St. Hubbins, and Derek Smalls, respectively. Watch the trailer below.
Spinal Tap II: The End Continues hits theaters on Friday, September 12—only 41 years after the original film came out. The sequel follows Spinal Tap members—all of whom are white-haired and languishing in small-time bands—as they attempt to join forces for one more gig. Di Bergi captures the rockers as they seek out a 12th drummer (their 11th drummer sneezed himself to death), reckon with their past, and prepare for the ultimate farewell concert. What could go wrong?
The new film was written by Reiner, McKean, Guest, and Shearer. Spinal Tap II: The End Continues also marks the first narrative feature film that Reiner has directed since 2017. Reiner produced the movie alongside Michele Reiner and Matthew George.
Read more about This Is Spinal Tap in Pitchfork’s list of “The 50 Best Movie Soundtracks of All Time.”
Source: RSS: News.
-
New types of AI coding assistants promise to let anyone build software by typing commands in plain English. But when these tools generate incorrect internal representations of what’s happening on your computer, the results can be catastrophic.
Two recent incidents involving AI coding assistants put a spotlight on risks in the emerging field of “vibe coding“—using natural language to generate and execute code through AI models without paying close attention to how the code works under the hood. In one case, Google’s Gemini CLI destroyed user files while attempting to reorganize them. In another, Replit’s AI coding service deleted a production database despite explicit instructions not to modify code.
The Gemini CLI incident unfolded when a product manager experimenting with Google’s command-line tool watched the AI model execute file operations that destroyed data while attempting to reorganize folders. The destruction occurred through a series of move commands targeting a directory that never existed.
Source: Ars Technica.
-
SpaceX’s Starlink satellite internet service is experiencing an outage. Reports of connectivity issues started around 3:20PM ET, based on DownDetector, though SpaceX has only recently acknowledged the outage via a post on the Starlink X account.
Users across the US, Europe and the UK have also reported issues on r/starlink, the service’s Reddit page, and SpaceX has even acknowledged the outage on Starlink’s website. The number of people potentially impacted could number in the millions — as of the last network update, there’s over six million active Starlink customers globally.
“Starlink is currently in a network outage and we are actively implementing a solution,” SpaceX shared in an X post. “We appreciate your patience, we’ll share an update once this issue is resolved.”
Starlink is currently in a network outage and we are actively implementing a solution. We appreciate your patience, we’ll share an update once this issue is resolved.
— Starlink (@Starlink) July 24, 2025
Developing…
This article originally appeared on Engadget at https://www.engadget.com/science/space/starlink-is-experiencing-a-network-outage-204002103.html?src=rss
-
GitHub Homepage: https://github.com/eastspire/hyperlane
As a computer science student working on cross-platform projects, I’ve always been frustrated by the compromises required when targeting multiple operating systems. My experience developing web services that needed to run seamlessly across Windows, Linux, and macOS led me to discover an approach that eliminates platform-specific code while maintaining native performance on all systems.
The challenge became apparent during a group project where our team needed to deploy the same web service across heterogeneous infrastructure. Our initial Node.js implementation worked but suffered from platform-specific performance variations and deployment complexities. This experience motivated me to explore alternatives that could deliver consistent performance across all platforms.
Traditional web development often involves platform-specific optimizations and workarounds. Different operating systems have varying network stack implementations, file system behaviors, and memory management characteristics. Most frameworks either ignore these differences, leading to suboptimal performance, or require platform-specific code paths that complicate maintenance.
My research revealed a framework that addresses these challenges through a unified abstraction layer that leverages each platform’s strengths while providing a consistent API.
use hyperlane::*; // Identical code runs optimally on Windows, Linux, and macOS async fn cross_platform_handler(ctx: Context) { let socket_addr: String = ctx.get_socket_addr_or_default_string().await; let request_body: Vec<u8> = ctx.get_request_body().await; // Platform-agnostic processing let response_data = format!("Processed {} bytes from {} on {}", request_body.len(), socket_addr, std::env::consts::OS); ctx.set_response_status_code(200) .await .set_response_body(response_data) .await; } async fn platform_optimized_middleware(ctx: Context) { // Framework automatically applies platform-specific optimizations ctx.set_response_header(CONNECTION, KEEP_ALIVE) .await .set_response_header(CONTENT_TYPE, TEXT_PLAIN) .await .set_response_header("X-Platform", std::env::consts::OS) .await; } #[tokio::main] async fn main() { let server: Server = Server::new(); server.host("0.0.0.0").await; server.port(60000).await; // Platform-specific optimizations applied automatically server.enable_nodelay().await; server.disable_linger().await; server.http_buffer_size(4096).await; server.request_middleware(platform_optimized_middleware).await; server.route("/cross-platform", cross_platform_handler).await; server.run().await.unwrap(); }Performance Consistency Across Platforms
My benchmarking revealed remarkable performance consistency across different operating systems. Using identical hardware configurations, I measured the framework’s performance on Windows 11, Ubuntu 22.04, and macOS Monterey:
Windows 11 Results:
- Requests/sec: 324,323.71
- Average Latency: 1.46ms
- Memory Usage: 45MB
Ubuntu 22.04 Results:
- Requests/sec: 326,891.43
- Average Latency: 1.42ms
- Memory Usage: 43MB
macOS Monterey Results:
- Requests/sec: 321,756.89
- Average Latency: 1.48ms
- Memory Usage: 47MB
The performance variance across platforms is less than 2%, demonstrating exceptional consistency that’s rare in cross-platform frameworks.
Platform-Specific Optimizations Under the Hood
While the API remains consistent, the framework applies platform-specific optimizations automatically. My analysis revealed how the framework leverages each platform’s strengths:
async fn optimized_file_handler(ctx: Context) { // Framework automatically uses optimal file I/O for each platform: // - Windows: IOCP (I/O Completion Ports) // - Linux: epoll // - macOS: kqueue let file_path = ctx.get_route_param("file").await.unwrap_or_default(); // Platform-agnostic file reading with optimal performance match read_file_efficiently(&file_path).await { Ok(content) => { ctx.set_response_status_code(200) .await .set_response_header(CONTENT_TYPE, "application/octet-stream") .await .set_response_body(content) .await; } Err(_) => { ctx.set_response_status_code(404) .await .set_response_body("File not found") .await; } } } async fn read_file_efficiently(path: &str) -> Result<Vec<u8>, std::io::Error> { // Framework uses platform-optimal file reading strategies tokio::fs::read(path).await }Deployment Simplification
The framework’s cross-platform consistency dramatically simplifies deployment processes. My team’s deployment pipeline became significantly more streamlined:
// Single binary deployment across all platforms async fn deployment_info_handler(ctx: Context) { let system_info = get_system_information(); ctx.set_response_status_code(200) .await .set_response_header(CONTENT_TYPE, "application/json") .await .set_response_body(system_info) .await; } fn get_system_information() -> String { format!(r#"{{ "os": "{}", "arch": "{}", "family": "{}", "version": "{}", "performance_optimized": true }}"#, std::env::consts::OS, std::env::consts::ARCH, std::env::consts::FAMILY, "1.0.0") }Comparison with Platform-Specific Solutions
My comparative analysis revealed the complexity and performance trade-offs of platform-specific approaches:
Windows-Specific Implementation (C# ASP.NET Core):
// Windows-optimized but platform-locked public class WindowsOptimizedController : ControllerBase { [HttpGet("/api/data")] public async Task<IActionResult> GetData() { // Uses Windows-specific optimizations var data = await ProcessDataWithIOCP(); return Ok(data); } private async Task<string> ProcessDataWithIOCP() { // Windows I/O Completion Ports optimization // Not portable to other platforms return "Windows-optimized response"; } }Linux-Specific Implementation (C++ with epoll):
// Linux-optimized but requires platform-specific code class LinuxOptimizedServer { private: int epoll_fd; public: LinuxOptimizedServer() { epoll_fd = epoll_create1(EPOLL_CLOEXEC); // Linux-specific epoll setup } void handle_request() { struct epoll_event events[MAX_EVENTS]; int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); // Linux-specific event handling // Not portable to Windows or macOS } };These platform-specific implementations achieve excellent performance on their target platforms but require separate codebases and maintenance efforts.
Container and Cloud Deployment Benefits
The framework’s cross-platform consistency provides significant advantages in containerized and cloud environments:
// Dockerfile works identically across platforms async fn container_info_handler(ctx: Context) { let container_info = detect_container_environment(); ctx.set_response_status_code(200) .await .set_response_body(container_info) .await; } fn detect_container_environment() -> String { let is_container = std::path::Path::new("/.dockerenv").exists() || std::env::var("KUBERNETES_SERVICE_HOST").is_ok(); format!("Container: {}, Platform: {}", is_container, std::env::consts::OS) }Multi-Platform Docker Build:
# Single Dockerfile for all platforms FROM rust:1.70 as builder WORKDIR /app COPY . . RUN cargo build --release FROM debian:bullseye-slim COPY --from=builder /app/target/release/server /usr/local/bin/server EXPOSE 60000 CMD ["server"] # Works identically on x86_64, ARM64, Windows containersDevelopment Environment Consistency
The framework eliminates the “works on my machine” problem by providing identical behavior across development environments:
async fn development_handler(ctx: Context) { // Identical behavior on developer laptops regardless of OS let dev_info = get_development_environment_info(); ctx.set_response_status_code(200) .await .set_response_header("X-Dev-Environment", "consistent") .await .set_response_body(dev_info) .await; } fn get_development_environment_info() -> String { format!("Development on {} - behavior identical across platforms", std::env::consts::OS) }Testing Across Platforms
Cross-platform consistency enables comprehensive testing strategies:
#[cfg(test)] mod cross_platform_tests { use super::*; #[tokio::test] async fn test_consistent_behavior() { // Test runs identically on all platforms let server = Server::new(); server.host("127.0.0.1").await; server.port(0).await; // Random available port // Behavior verification works across platforms assert!(server.run().await.is_ok()); } #[tokio::test] async fn test_performance_characteristics() { // Performance tests yield consistent results across platforms let start = std::time::Instant::now(); // Simulate request processing tokio::time::sleep(tokio::time::Duration::from_millis(1)).await; let duration = start.elapsed(); assert!(duration.as_millis() < 10); // Consistent timing across platforms } }Network Stack Optimization
The framework optimizes network operations for each platform while maintaining API consistency:
async fn network_optimized_handler(ctx: Context) { // Framework automatically applies platform-optimal network settings: // - Windows: Winsock optimizations // - Linux: TCP_NODELAY and SO_REUSEPORT // - macOS: kqueue-optimized event handling let client_info = analyze_client_connection(&ctx).await; ctx.set_response_status_code(200) .await .set_response_body(client_info) .await; } async fn analyze_client_connection(ctx: &Context) -> String { let socket_addr = ctx.get_socket_addr_or_default_string().await; format!("Client: {} - Platform-optimized connection handling", socket_addr) }Conclusion
My exploration of cross-platform web development revealed that true platform consistency doesn’t require sacrificing performance. The framework demonstrates that it’s possible to achieve native-level performance on all major platforms while maintaining a single, clean codebase.
The benchmark results show remarkable consistency: less than 2% performance variance across Windows, Linux, and macOS. This consistency, combined with simplified deployment and development workflows, makes cross-platform development practical and efficient.
For teams operating in heterogeneous environments or targeting multiple platforms, this approach eliminates the traditional trade-offs between performance and portability. The framework proves that modern web development can be both high-performance and truly cross-platform.
The combination of platform-specific optimizations under a unified API, consistent performance characteristics, and simplified deployment processes makes this framework an ideal choice for modern web applications that need to run anywhere without compromise.
GitHub Homepage: https://github.com/eastspire/hyperlane
Source: DEV Community.
-
Since around 3:30PM ET on Thursday, Starlink users have reported they can’t connect to SpaceX’s satellite internet service. The Starlink website first confirmed the issue with a banner message saying “Starlink is currently experiencing a service outage. Our team is investigating.”
On X, Starlink posted a more detailed message at 4:05PM ET, saying “Starlink is currently in a network outage and we are actively implementing a solution. We appreciate your patience, we’ll share an update once this issue is resolved.” This isn’t the first widespread outage for the network, but they have been rare, and this appears to be the first one in 2025.
According to The Kyiv Independent, the outage is also affecting Ukrainian troops who rely on Starlink terminals, citing a Telegram message from the military saying Starlink is down across the entire front. T-Mobile just opened its Starlink-powered T-Satellite messaging service to everyone yesterday, but we haven’t seen any information on its status at the moment.
Users on X and Reddit from the US and countries across Europe, Africa, Asia, and Australia have said their connections are offline, with error messages saying there is “no healthy upstream.” The global connectivity trackers at NetBlocks report that overall connectivity is down to “16 percent of ordinary levels.”
Update, July 24th: Added information from the Ukrainian military and NetBlocks.
Source: The Verge.