here is an example of the information telegram sends:

Code:

await app.get_chat_settings(user_id)

Result:

{
    "_": "ChatSettings",
    "can_report_spam": true,
    "can_add_contact": true,
    "can_block_contact": true,
    "can_share_contact": false,
    "can_report_geo": false,
    "can_invite_members": false,
    "is_autoarchived": true,
    "is_business_bot_paused": false,
    "is_business_bot_can_reply": false,
    "need_contacts_exception": true,
    "request_chat_broadcast": false,
    "registration_date": "08.2022",
    "phone_country": "KE",
    "name_change_date": "2025-02-27 23:20:08"
}

The TL:

peerSettings#f47741f7 flags:# report_spam:flags.0?true add_contact:flags.1?true block_contact:flags.2?true share_contact:flags.3?true need_contacts_exception:flags.4?true report_geo:flags.5?true autoarchived:flags.7?true invite_members:flags.8?true request_chat_broadcast:flags.10?true business_bot_paused:flags.11?true business_bot_can_reply:flags.12?true geo_distance:flags.6?int request_chat_title:flags.9?string request_chat_date:flags.9?int business_bot_id:flags.13?long business_bot_manage_url:flags.13?string charge_paid_message_stars:flags.14?long registration_month:flags.15?string phone_country:flags.16?string name_change_date:flags.17?int photo_change_date:flags.18?int = PeerSettings;

Anthropic (the company behind Claude 3 Sonnet) got the best interpretability team.

Check out this video Scaling Interpretability by Anthropic

string literal concatenation
(also known as "string literal joining")

When you place two string literals next to each other with only whitespace between them, Python automatically concatenates them during the parsing phase.

So these are equivalent:

x = "hi" "hello"    # Results in "hihello"
x = "hi" + "hello"  # Also results in "hihello"

This feature is particularly useful for breaking long strings across multiple lines:

long_string = "This is a very long string " \
              "that I want to break " \
              "across multiple lines"

As for other languages:
- C and C++ support this feature
- Java does not support this
- JavaScript does not support this
- Rust does not support this

It's worth noting that this only works with string literals (strings written directly in quotes in the code). It won't work with variables or expressions:

a = "hi"
b = "hello"
c = a b      # This will cause a SyntaxError
c = a + b    # This is the correct way

This feature is most commonly seen in C/C++ and Python, but it's relatively rare in modern programming languages.

Regex validator for JSON data

https://regex101.com/r/tA9pM8/1

React Flow

A customizable React component for building node-based editors and interactive diagrams

https://reactflow.dev/
https://reactflow.dev/examples
https://github.com/xyflow/xyflow

#react #flowchart

Self-Hosting a Firefox Sync Server
Article, Comments

- syncstorage-rs
- syncstorage-rs-docker

#rust #firefox #docker

hilariously, I bet this all was caused by US antimonopoly entity, who requested google to stop dominating market, which stopped or made threats to agreement between mozilla and google to have google as default search engine

https://www.bloomberg.com/news/newsletters/2023-05-05/why-google-keeps-paying-mozilla-s-firefox-even-as-chrome-dominates



In 2021 these payments accounted for 83% of Mozilla’s revenue.

Yes, Claude Code can decompile itself. Here's the source code
Article, Comments

https://github.com/ghuntley/claude-code-source-code-deobfuscation

GrapheneOS blocked exploitation of 3 Android zero-days used by Cellebrite
Article, Comments

Each of these is an upstream Linux kernel vulnerability:

* CVE-2024-53104: heap overflow in a Linux kernel USB webcam driver
* CVE-2024-53197: heap overflow in a Linux kernel USB sound card driver
* CVE-2024-50302: uninitialized heap memory in a Linux kernel USB touchpad driver

#vulnerability

Should I blame caching

https://shouldiblamecaching.com/

Godot 4.4 is released!
changelogs

CVE-2025-21333 (score: 7.8, high)
Windows Hyper-V Zero-Day
POC Repository

heap-based buffer overflow. It leverages WNF state data and I/O ring IOP_MC_BUFFER_ENTRY
The vulnerability was detected as being actively exploited by threat actors. Tested on Windows 11 23h2.

Overwriting I/O Ring buffer entry to get arbitrary read/write
It allocates in the Paged Pool an array of pointers to _IOP_MC_BUFFER_ENTRY and overwrites the first pointer with a malicious IOP_MC_BUFFER_ENTRY* located in user-space. Using BuildIoRingWriteFile()/BuildIoRingReadFile() It is possible to obtain arbitrary read/write in the kernel.

The array of pointers to _IOP_MC_BUFFER_ENTRY is an object with PoolTag IrRB.

#vulnerability #cve

"An atomic load is ~5x faster than a mutex, which can matter in tight loops."

1. Mutex Operations: A mutex involves several expensive operations:
- System calls to the kernel
- Potential context switches
- Lock contention handling
- Thread scheduling overhead

2. Atomic Operations:
- Execute directly on the CPU using special hardware instructions
- Don't require kernel intervention
- No context switching
- No thread scheduling overhead

The ~5x performance difference comes from eliminating all the mutex-related overhead. However, it's important to note that atomic operations aren't always the best solution - they're ideal for simple operations like this error check, but mutexes are still necessary for more complex critical sections where you need to protect multiple operations.

- Commit

Urban Dead is shutting down
Article, Comments

klee-client

Secure and local AI on your desktop with a built-in RAG knowledge base and Markdown note support.
https://github.com/signerlabs/klee-client