Dhimas Widrayato

Just another guy, with great GOD, suaminya @nikejunila. Bukan akun kerja, akun alter atau web designer, serius!

Akun dikelola admin, twit asli ditandai *DHM*

[Dhimas Widrayato @dhimasbu]

@tahilalats Orang tua besok subuh

[Cyber_Racheal @CyberRacheal]

Linux doesn't have to cost a dime.

Here are the best free resources to level up your skills in 2026:

1. Linux Foundation Training – Professional-grade introductory courses.
https://t.co/o4FWhK4kPb

2. Linux Journey – A beautifully organized, beginner-friendly learning path.
https://t.co/dXFQh12QV9

3. Ubuntu Tutorials – Step-by-step guides for the world’s most popular distro.
https://t.co/5T3Y9SCDcb

4. Red Hat Training Resources – Enterprise-level learning for developers.
https://t.co/1lUxX5Umwy

5. GNU Documentation – The "source of truth" for core Linux utilities.
https://t.co/XU5buZGulG

6. OverTheWire Bandit – Learn through "wargames" that make the CLI feel like a puzzle.
https://t.co/xzMseITE3c

7. The Linux Command Line Book – A legendary, comprehensive guide for terminal mastery.
https://t.co/n7UJYxtGm5

8. MIT Missing Semester – Essential tools and CLI techniques they don't always teach in college.
https://t.co/9VRYjNuWrm

9. DigitalOcean Linux Tutorials – Practical, hands-on guides for server management.
https://t.co/4aI9ZHD53c

10. Linux From Scratch – The ultimate deep dive: build your own OS from the ground up.
https://t.co/CgWvsN4qPw

11. Arch Linux Wiki – Widely considered the best technical documentation in the Linux world.
https://t.co/AhNi4hWBBe

12. freeCodeCamp Linux Course – High-quality, project-based tutorials.
https://t.co/sqCnIAJCaf

13. Linux Survival – An interactive browser-based terminal for safe practicing.
https://t.co/3M0qvD244i

Courtesy of : @twtayaan

[International Cyber Digest @IntCyberDigest]

‼️🚨 BREAKING: An AI found a Linux kernel zero-day that roots every distribution since 2017. The exploit fits in 732 bytes of Python. Patch your kernel ASAP.

The vulnerability is CVE-2026-31431, nicknamed "Copy Fail," disclosed today by Theori. It has been sitting quietly in the Linux kernel for nine years.

Most Linux privilege-escalation bugs are picky. They need a precise timing window (a "race"), or specific kernel addresses leaked from somewhere, or careful tuning per distribution. Copy Fail needs none of that. It is a straight-line logic mistake that works on the first try, every time, on every mainstream Linux box.

The attacker just needs a normal user account on the machine. From there, the script asks the kernel to do some encryption work, abuses how that work is wired up, and ends up writing 4 bytes into a memory area called the "page cache" (Linux's high-speed copy of files in RAM). Those 4 bytes can be aimed at any program the system trusts, like /usr/bin/su, the shortcut to becoming root.

Result: the next time anyone runs that program, it lets the attacker in as root.

What should worry most: the corruption never touches the file on disk. It only exists in Linux's in-memory copy of that file. If you imaged the hard drive afterwards, the on-disk file would match the official package hash exactly. Reboot the machine, or just put it under memory pressure (any normal system load that needs the RAM), and the cached copy reloads fresh from disk.

Containers do not help either. The page cache is shared across the whole host, so a process inside a container can use this bug to compromise the underlying server and reach into other tenants.

The original sin was a 2017 "in-place optimization" in a kernel crypto module called algif_aead. It was meant to make encryption slightly faster. The change broke a critical safety assumption, and nobody noticed for nine years. That bug then rode every kernel update from 2017 to today.

This vulnerability affects the following:
🔴 Shared servers (dev boxes, jump hosts, build servers): any user becomes root
🔴 Kubernetes and container clusters: one compromised pod escapes to the host
🔴 CI runners (GitHub Actions, GitLab, Jenkins): a malicious pull request becomes root on the runner
🔴 Cloud platforms running user code (notebooks, agent sandboxes, serverless functions): a tenant becomes host root

Timeline:
🔴 March 23, 2026: reported to the Linux kernel security team
🔴 April 1: patch committed to mainline (commit a664bf3d603d)
🔴 April 22: CVE assigned
🔴 April 29: public disclosure

Mitigation: update your kernel to a build that includes mainline commit a664bf3d603d. If you cannot patch immediately, turn off the vulnerable module:

echo "install algif_aead /bin/false" > /etc/modprobe.d/disable-algif.conf
rmmod algif_aead 2>/dev/null || true

For environments that run untrusted code (containers, sandboxes, CI runners), block access to the kernel's AF_ALG crypto interface entirely, even after patching. Almost nothing legitimate needs it, and blocking it shuts the door on this whole class of bug...

[Dhimas Widrayato @dhimasbu]

Sialan emang, korbannya minor pula.

[Maria A. Alkaff @MariaAlkaff_]

Inna lillahi…
Kejahatan dan pelanggaran kode etik berat.
Hukumannya becanda! 😡
—-

Publik diguncang skandal berat di Polda Jambi setelah tiga oknum polisi, Bripda VI, Bripda MIS, dan Bripda HAMZ, menjalani sidang kode etik pada Selasa (7/4/2026).

Ketiganya terbukti menyaksikan dan membiarkan aksi pemerkosaan terhadap remaja berinisial C (18), yang merupakan calon Polwan.

Meski dinyatakan melakukan pelanggaran berat dan perbuatan tercela, sanksi berupa permohonan maaf dan pembinaan rohani dinilai publik sangat tidak sebanding dengan trauma korban.

Banyak pihak kini mendesak transparansi dan keadilan yang lebih tegas atas tindakan yang dianggap sebagai aib besar bagi institusi kepolisian tersebut.

[Tech with Mak @techNmak]

Found a UI library that made me mass mass mass mass mass angry.

Angry that this isn't how everything works.

Oat:
→ 6KB CSS + 2.2KB JS
→ Zero dependencies
→ No framework required
→ No build step
→ Semantic HTML only

You write <button>. It looks good.
You write <dialog>. It looks good.
You write <input>. It looks good.

No className="px-4 py-2 rounded-md bg-blue-500"

No <Button variant="primary" size="md">

Just HTML.

Accessible. Keyboard navigable. Dark mode included.

Built by Kailash Nadh (CTO @ Zerodha)

[Gump n Hell #gumpnhell @gumpnhell]

Religiositas Jepang memang begini.

Ibadahnya mereka adalah mencapai kesempurnaan dalam pekerjaan apapun. Keagungan Tuhan hadir dlm tiap detail.

Level makrifat.

[fyi aja @fyiajaa]

🚨 RESMI
[Suami mba Sasetyaningtyas setuju mengembalikan seluruh dana LPDP S2 & S3 beserta bunga nya]

Menteri keuangan, Purbaya Yudi sadewa mengonfirmasi bahwa yang bersangkutan setuju mengembalikan dana LPDP karena terbukti belum melaksanakan tanggung jawab pengabdiannya, selain itu mereka akan di blacklist dari posisi di pemerintahan, kata purbaya.

"Pak Dirut sudah berbicara dengan (suami) terkait sepertinya dia setuju untuk mengembalikan uang yang dipakai olehnya di LPDP," kata Purbaya dalam Konferensi Pers APBN KiTa edisi Februari 2026,

Sc: Kumparan, CNBC

[Dhimas Widrayato @dhimasbu]

@satyaXBT Ini masuk Indo kapan?

[Dhimas Widrayato @dhimasbu]

Aneh sih kalo lu percaya WA aman. Pemiliknya aja Meta.

[DogeDesigner @cb_doge]

BREAKING: Former Meta contractors say company staff could read WhatsApp chats despite encryption claims.

US officials are now investigating whether messages are truly private. The Commerce Department and a 2024 SEC whistleblower complaint are now reviewing the allegations.

[Akshay Shinde @ConsciousRide]

A billion users sending messages every second means billions of read receipts firing constantly. One boolean column sounds simple until your database melts from write load.

Here's how messaging platforms actually build this feature at scale ==>>

> Why the naive approach fails

Adding an is_read boolean to your messages table seems obvious. When someone reads a message, flip it from false to true. But at scale, this creates a write for every single message read. If a group chat has 100 members and one person sends a message, that's 100 writes when everyone reads it. Multiply that across billions of messages and your database can't keep up.

> The write amplification problem

Every read receipt triggers a database write operation. Writes are expensive. They need to be persisted to disk, replicated across database nodes, and indexed. When reads happen faster than your database can process writes, you get a backlog. Messages appear read late or not at all. User experience breaks.

> Database locking issues

Updating a row locks it briefly. If thousands of people read the same message simultaneously, they all try to update it at once. Lock contention slows everything down. Some updates fail and need retry logic. Your database spends more time managing locks than doing useful work.

> The timestamp pattern for most cases

Instead of tracking read status per message, store the last read timestamp per user per conversation. When you open a chat and scroll to a message, update your last read timestamp to that message's timestamp. Any message older than your last read timestamp is considered read. This turns thousands of individual receipt writes into one timestamp update per conversation.

> When you need precise receipts

For features that require knowing exactly who read which message, maintain a separate read receipts table. This table has user ID, message ID, and read timestamp. When you read a message, insert a row here. Use this for delivery reports or legal compliance where you need audit trails.

> Use append only data structures

The receipts table becomes append only. You never update or delete rows, only insert new ones. This avoids locking entirely. When checking if a message is read, query this table for a receipt matching the user and message. If it exists, the message was read.

> Denormalize for read performance

Checking the receipts table for every message display is still slow. Denormalize by caching read status. When someone opens a chat, load all their read receipts for that conversation into memory or Redis. Now checking if a message is read is a local lookup, not a database query.

> Batch writes for efficiency

Don't write a receipt immediately when someone reads a message. Buffer receipts in memory and write them in batches every few seconds. If someone scrolls through 50 messages, that's one batch write instead of 50 individual writes. This reduces database load massively.

> Use eventually consistent storage

Read receipts don't need strong consistency. If your receipt takes a second to appear, users don't care much. This lets you use eventually consistent data stores that sacrifice immediate accuracy for higher throughput. Cassandra or DynamoDB work well here because they scale writes horizontally.

> Partition by user and conversation

Partition your receipts table by user ID or conversation ID. This spreads writes across multiple database shards. A message in chat A going to shard 1 doesn't interfere with a message in chat B going to shard 2. Each shard handles a fraction of total traffic.

> Message queues for async processing

When a user reads messages, publish read events to a message queue like Kafka. Workers consume these events and write receipts to the database asynchronously. The user's app doesn't wait for the database write to finish. It just sends the event and moves on.

> Idempotency matters

Users might mark a message read multiple times due to app restarts or network issues. Your system needs to handle duplicate read events gracefully. Use message ID and user ID as a composite key. If a receipt already exists, the insert does nothing or updates the timestamp. No errors, no duplicates.

> Handling group chats differently

Group chats amplify the problem. One message to 1000 members means 1000 potential read receipts. Don't show individual read status for large groups. WhatsApp stops showing individual blue ticks above around 256 members for exactly this reason. The database cost isn't worth it.

> Aggregate reads for large groups

For groups, maintain a counter of how many people read each message. Increment this counter when someone reads instead of storing individual receipts. This turns 1000 writes into one counter update. The counter can live in Redis for speed.

> Use bitmaps for membership tracking

If you must track who specifically read a message in a group, use compressed bitmaps like Roaring bitmaps. Each bit represents one member. Set the bit when they read. A 1000 person group compresses to just a few hundred bytes. This is way more compact and faster than 1000 database rows.

> Optimize for recent messages

Most reads happen on recent messages. Use TTL policies to expire old read receipts automatically. Keep per conversation retention, usually the last 30 to 90 days of receipts in hot storage. Archive older data to cold storage if needed for compliance. This keeps your active dataset small and queries fast.

> Client side optimistic updates

When you read a message, immediately show the blue tick on your device without waiting for the server. Send the read event in the background. If it fails, silently retry. Most of the time it works, and users see instant feedback.

> Sync read status across devices

If you read a message on your phone, your laptop should show it read too. Sync read receipts through a user session service. When one device sends a read event, broadcast it to other active sessions for that user via websockets.

> Handle offline scenarios

Users read messages offline. Queue these read events locally and flush them when connectivity returns. The receipts table accepts these late writes because it's append only. Timestamps capture when the read actually happened versus when it was recorded.

> Monitoring write throughput

Track receipts written per second, batch sizes, queue depths, and database write latency. If receipts lag behind message sends, you have a scaling problem. Add more database capacity or tune batch sizes before users notice.

> Privacy and read receipts

Some users disable read receipts. Store this preference and skip receipt writes for those users. But still process receipts from others reading their messages. This asymmetry requires checking user settings before writing.

> Backfilling for new features

If you launch read receipts on an existing messenger, you need to handle messages sent before the feature existed. Don't backfill receipts for old messages. Only track reads going forward. Trying to backfill billions of historical messages will overload your system.

> Database choice impacts design

SQL databases with transactions make implementing receipts harder at scale due to locking and write amplification. NoSQL stores like Cassandra handle high write throughput better with eventual consistency. Choose your database based on write patterns, not just read patterns.

> The core insight

Start with timestamp patterns for basic read tracking. Use append only receipts tables when you need precision. Batch aggressively. Accept eventual consistency. Partition data. Process asynchronously. Use compressed bitmaps for groups. These patterns together let you handle billions of receipts without killing your database. The feature seems simple but the scale forces architectural complexity.

How about you? What's your go-to pattern for read receipts at scale? Timestamp tracking, events table, bitmaps, or something else?

[Dhimas Widrayato @dhimasbu]

@fajarnugros Pengacaranya itu masih sodara kalo lihat rekamannya.

[AlternativeTo @AlternativeTo]

Open source, web-based 3D isometric infrastructure diagram editor. Completely free, runs offline, and no sign up required. Ridiculously user friendly!

[Fernando @Franc0Fernand0]

One of the best math books I've ever read:

MIT's "Mathematics for Computer Science"

Its writing style is brilliant, and it covers everything:

- Linear algebra
- Series
- Logic
- Probability
- Number theory
- Graphs

You can find the PDF here:

https://t.co/iQvaflkDPD

[Adnan @adnansahinovich]

❌ Dropdowns are a web pattern.
Avoid them in mobile at all costs.

Why?
– Break thumb reach
– Hide important choices
– Easy to mis-tap
– Scale terribly on smaller phones

Use segmented controls, lists, or bottom sheets instead.

Mobile UX is thumb-driven.
If it breaks the thumb zone, it breaks usability.

[Dhimas Widrayato @dhimasbu]

@GiaPratamaMD Dok, ada tukang baso mangkal lama di depan rumah nggak?

[dr. Gia Pratama @GiaPratamaMD]

Ini adalah 2 saluran di leher manusia.

Esofagus dan Trakea itu lebih dikenal dengan nama kerongkongan dan tenggorokan.

------------------------------

PR : dimanakah posisi Pita suara manusia?

[Dhimas Widrayato @dhimasbu]

Ytta sih, di dalem perusahaannya gmn.

[Dhimas Widrayato @dhimasbu]

Ga usah ngomong etis ga etis ke orang2 itu, Mas Elon!

Yang ada sampeyan dibilang 'muna'.

[fe @ballericx]

😱😮‍💨

[Dhimas Widrayato @dhimasbu]

Hahaha

Dalam bahasa Indonesia:

Bos sialan!

[IT Unprofessional @it_unprofession]

Last month my intern asked for help with a Kubernetes error.

He was stuck on a YAML file.

He looked desperate.

I make $275,000 a year.

I haven't written a line of code since 2017.

I don't even know what a "pod" is.

But I didn't tell him that.

I leaned back in my Herman Miller chair.

I said, "Stop trying to code. Start prompting."

I told him to paste the error into ChatGPT.

He did.

The AI told him to delete the cluster.

He did.

Production went down instantly.

The CEO called me screaming.

I didn't panic.

I told the CEO we were "testing our disaster recovery protocols."

He was impressed by my foresight.

I got a bonus.

The intern got fired.

Innovation requires sacrifice.

Just not mine.

[GitHub Projects Community @GithubProjects]

Tower defense game that teaches cloud architecture. Build infrastructure, survive traffic, learn scaling.