Restore Edge Collections with SQLite Browser

PoliteDB is now available on Linux. We’ve officially added Linux support to PoliteDB. This is an early version, and we’re continuing to improve stability and compatibility across different environments. Download and try it out: https://lnkd.in/g3tKEKSQ

What's actually inside a Windows shell shortcut? Pavel Yosifovich just published a deep dive into .lnk files — what they are, why they're binary COM objects, and how to work with them programmatically in C++. He covers the IShellLink and IPersistFile interfaces, walks through loading and modifying an existing shortcut with code, and explains how to use OleView to discover what interfaces a COM class actually implements. There's also a practical security section on .lnk persistence — why it works, and what to watch for defensively. Free on the TrainSec knowledge library: https://lnkd.in/gkZgeGkp

🚀 Just released mail2go v0.1.0 — an open-source self-hosted SMTP gateway built with .NET 10 and ASP.NET Core. It lets you send emails through your own server without relying on third-party email services. Lightweight, easy to deploy, and fully self-contained. 🔧 What's included: * Embedded SMTP server (port 2525) * Web dashboard for managing users & mail * SQLite storage — no external DB needed * Single-file binaries for Windows, Linux, and macOS 💡 Since it runs locally with no external dependencies, it can also serve as a lightweight email sandbox — useful when you need an SMTP endpoint for local development or automated testing. 📦 Download: https://lnkd.in/guyezUUS Feedback and contributions are welcome! 🙌 #dotnet #opensource #selfhosted #smtp #csharp #aspnetcore

🔍 Searching for text patterns in Linux using grep! This one is all about grep, and here’s how I used it: The full command: “grep -i ‘essential’ /usr/share/dict/linux.words | grep -v ‘^$’ > /var/tmp/pattern.txt” Piece by piece breakdown: 1️⃣ grep -i The -i flag makes the search case-insensitive. It finds “Essential”, “ESSENTIAL” and “essential” all the same. 2️⃣ The search pattern The caret symbol before the word means “start of line.” So instead of finding “essential” anywhere in a line it only finds lines that begin with it. 3️⃣ The file being searched “/usr/share/dict/linux.words” is a massive dictionary file built into Linux containing hundreds of thousands of words. 4️⃣ The second grep “grep -v” means invert the match. Tells Linux to show me everything that does NOT match the pattern. The pattern means “a line where the start is immediately followed by the end” which is an empty line. So this step strips out any blank lines from the results. 5️⃣ The redirect The “>” sends all the output into a file instead of printing it to the screen. 6️⃣ I verified it worked: “cat /var/tmp/pattern.txt” Printed every line beginning with essential, no empty lines, saved to file. ✅ One line. Five moving parts. All working together. #RHCSA #Linux #Grep #SysAdmin #LearningInPublic

Three details from Claude Code 2.1.117–2.1.121 that most coverage will gloss over: 1. The Opus 4.7 context bug wasn't just cosmetic. Auto-compact fires when /context percentage hits a threshold. Computing percentage against 200K instead of 1M means Claude was summarizing your session 5x too aggressively, losing detail you didn't need to lose. If you've felt sessions "forget" things faster than they used to, this is why. 2. Native builds on macOS and Linux replaced the Glob and Grep tools with embedded bfs and ugrep, available through the Bash tool. The win is the eliminated tool round-trip – Claude doesn't context-switch to a separate search tool for what's effectively a `find` or `grep`. 3. The find file-descriptor crash on large directory trees was a host-wide stability bug, not a Claude Code-specific bug. macOS and Linux native builds were exhausting the user's open-file limit during recursive search, taking down other processes. 2.1.121 reduced peak FD usage during find significantly. Full breakdown:

Was poking around my home directory looking for the `.claude` folder and noticed how many dot files I've accumulated. `.aws`, `.ssh`, `.config`, `.gitconfig`, `.nvm`, `.1password`, `.cursor`. `.docker`, `.gradle`, the list goes on and on. Got me wondering where this convention came from. Why a dot? Did a little digging. Apparently it started as a bug. When `.` and `..` were added to the early Unix file system to make directory navigation easier, they started showing up in `ls` output. Cluttery. So either Ken Thompson or Dennis Ritchie added a quick filter to `ls`: skip anything starting with a period. Two characters of logic, around 1971. Hidden files weren't a feature anyone designed. Developers just figured out they could hide config files by prefixing the name with a dot. The convention spread, and now we've all got home directories full of them. Rob Pike wrote about it back in 2012 and called it a mistake. He pointed out that Plan 9 used dedicated config directories instead. Linux has been trying to retrofit that idea ever since through the XDG Base Directory spec. Funny to think a quick fix in `ls` from fifty years ago is the reason `.claude` lives where it does today. Totally random thought.. yes I know...

Most people who look at a PE file think about two things: code and data. The resource section gets less attention, Standard resource types are well-known: icons, menus, cursors, bitmaps, string tables. Windows has documented formats for all of them and provides APIs like `LoadMenu` and `LoadIcon` to convert them into runtime objects. But resources don't have to be any of those things. They can have arbitrary type names and hold any binary data. I wanted to show a concrete example of this, so I looked at Process Explorer. Run it with admin rights and it loads a kernel driver, but there's no driver file anywhere in the Sysinternals folder. Open the 32-bit executable in a PE viewer and you'll find two custom "BINRES" resources, both starting with the MZ header. One is the 64-bit variant of Process Explorer itself. The other is the driver. In the full writeup I walk through what PE resources are, how standard vs. custom types work, how to inspect them with Total PE, and what this technique means from a security perspective. Full post: https://lnkd.in/eMGhsaVi

Before writing a single line of my own allocator, I wanted to actually watch malloc work. (ﾉ´ヮ´)ﾉ*:･ﾟ✧ So I spent time observing glibc's malloc, using strace, sbrk(), and /proc maps before designing anything myself. A few things that genuinely surprised me (⊙_⊙): ☆ Asking for 1000 bytes gave me 132KB. glibc buys memory in wholesale and stores it internally so it doesn't have to make expensive syscalls every time. ☆ Three consecutive malloc() calls didn't trigger a single extra brk() — all three fit inside the arena that was already set up. ( •̀ ω •́ )✧ ☆ glibc runs code before main() even starts. The kernel is unaware of any of the internal structures glibc imposes on the heap — chunks, bins, top chunk. To the kernel, it's just bytes. (˶ᵔ ᵕ ᵔ˶) All of this is Phase 0 of my mini-malloc series, where I'm building a memory allocator from scratch, referencing the official glibc source throughout. (˶ˆᗜˆ˵) Link in the comments! 🔗 🔗 ⋆˙⟡ ⋆.˚ ⊹₊⟡ ⋆⋆˙⟡ ⋆.˚ ⊹₊⟡ ⋆ #SystemsProgramming #C #Linux #MemoryManagement #LowLevel #DevJournal

Note the ease with which the "computering machine" will do hundreds of times more work than you asked for. You always learn something from real measurements.

In the Linux Kernel, we don't put data inside lists. We put lists inside data. Most CS101 textbooks teach linked lists as boxes that contain a payload. The Linux Kernel flips this concept inside out with the list_head structure. Defined in include/linux/list.h, this "intrusive" design means we embed the list pointers directly inside our custom data structures. It’s an elegant solution that allows a single object to live on multiple lists simultaneously without extra memory allocations. Why it's the "Senior" choice for architecture: ✅ Zero Allocation Growth: Adding a node to a list is O(1) and requires no kmalloc. ✅ Decoupled Logic: One list library manages everything from processes to files. ✅ Seamless Retrieval: Remember yesterday's container_of()? The kernel’s list_entry() macro is just a wrapper around it! Quick Quiz for the Kernel Experts: When traversing a list and deleting elements, why MUST you use list_for_each_entry_safe() instead of the standard version? Let’s hear your take on the mechanics of pointer corruption in the comments! 👇 #LinuxKernel #SystemsEngineering #EmbeddedSystems #CProgramming #DataStructures #TechInsights #StaffEngineer