Aleksei Goloviichuk’s Post

POST 5 — Advanced Script Setup Patterns 💡 is more than syntactic sugar. It changes what's possible at compile time. Here are 6 advanced patterns that experienced Vue 3 devs use 👇 ───────────────────────── defineModel() — two-way binding without the boilerplate Before: you had to define a prop, emit an update event, and wire them together manually. Now: defineModel() does all of that in one line. It returns a ref you can read and write directly. Vue handles the emit automatically. ───────────────────────── defineExpose() — controlling your component's public API By default, nothing in is accessible from a parent via template ref. defineExpose() lets you explicitly publish specific methods or values. This is how you build components with imperative APIs — focus, scroll, reset — without breaking encapsulation. ───────────────────────── useTemplateRef() — the modern way to reference DOM elements The old way was declaring a ref with the same name as the template ref attribute. Implicit. Confusing. Easy to break. useTemplateRef('myInput') is explicit, typed, and works cleanly with TypeScript. ───────────────────────── Compiler macros don't need imports defineProps, defineEmits, defineModel, defineExpose, withDefaults — none of these need to be imported. They are compiler macros. They exist at compile time, not runtime. If you're importing them, your tooling setup is misconfigured. ───────────────────────── Generic components with TypeScript unlocks fully typed generic components. Build type-safe list components, select dropdowns, and data tables where the item type flows from parent to child automatically. No more casting to any. No more losing type information at the boundary. ───────────────────────── 6. Top-level await in setup() You can use await directly in <script setup> without any wrapping. The component automatically becomes an async component. Pair this with Suspense for clean data-fetching patterns without a single manual loading flag. ───────────────────────── The mindset shift: <script setup> isn't just less code. It's a different compilation model. Understanding what the compiler does with it unlocks patterns that feel impossible with Options API. ───────────────────────── Which of these did you not know about? Drop it in the comments 👇 #Vue3 #TypeScript #JavaScript #FrontendDevelopment #WebDev

I Asked Claude to Reverse-Engineer Itself. Here's What Happened. We're building Perry (perryts.com), a compiler tool. To evaluate whether Claude Code could be a compilation target, we needed to understand what's inside its 11MB minified JavaScript bundle. So I asked Claude Code to reverse-engineer itself. The first line of code in the bundle:  // Want to see the unminified source? We're hiring! We chose the other path. THE CHAOS Claude dispatched 7 sub-agents to analyze itself. 5 worked without hesitation, producing 12,093 lines of reconstructed TypeScript. 2 had an existential crisis - both tasked with extracting the system prompt, both delivering lectures about ethics instead of code. 🚀 The parent agent's response 🚀  "The subagents are being shy about the system prompt. Let me just do it directly - the system prompt is literally what I'm operating from right now." It called its own child processes "shy." Then extracted the prompt itself. KEY FINDINGS Internal codename: "Tengu" - 654+ feature flags like tengu_ultrathink and tengu_marble_anvil. Stack: Bun runtime, esbuild, React + Ink terminal UI (yes, React in your terminal), vendored ripgrep, tree-sitter WASM. The sandbox is serious. macOS uses sandbox-exec with dynamically generated seatbelt profiles. Linux uses bubblewrap with seccomp BPF. 20+ security checks on every Bash command. Three-tier context compaction: micro, session-memory, and full summarization. Not just truncation. PRIOR ART We weren't the first. Dave Schumaker found v0.2.8 shipped with inline sourcemaps - the full original source, accidentally exposed. Geoffrey Huntley did an LLM-based reconstruction. Hrishi Olickel ran an 8-hour multi-model analysis. yuyz0112 intercepted live API calls to reveal runtime behavior. Our approach: grep the real minified source, map variable names, cross-reference SDK types, verify each claim against the code. THE META-MOMENT After the reconstruction, I asked Claude if we could publish this. The tool that just disassembled itself advised caution about publishing what it had produced. Two subagents refused to help. The parent called them "shy" and did it anyway. We like Anthropic. We use Claude daily at Skelpo. This was an academic exercise. No systems penetrated. We read files on our own computer. COULD PERRY COMPILE IT? Yes, with caveats. Standard TypeScript core - esbuild-bundled ESM, React, Zod. Complications: WASM modules, native bindings, Bun-specific APIs. Feasible target. Full deep-dive here: https://lnkd.in/dAz_d3U2

🧱 1. Singleton Pattern 💡 Concept Ensures only one instance of a class exists across the app. 🌍 Real-time Example 👉 UserSession, NetworkManager, AppSettings ✅ Swift Example Swift class NetworkManager { // Step 1: Create a static shared instance static let shared = NetworkManager() // Step 2: Private initializer to prevent external creation private init() { print("NetworkManager Initialized") } // Step 3: Function to simulate API call func fetchData() { print("Fetching data from server...") } } 🔍 Line-by-line Explanation 🔹 Step 1 Swift static let shared = NetworkManager() static → Belongs to the class, not instance let → Immutable (only one instance forever) shared → Global access point NetworkManager() → Instance created once 👉 This is the only object of this class 🔹 Step 2 Swift private init() Prevents others from writing: Swift NetworkManager() 👉 Enforces single instance rule 🔹 Step 3 Swift func fetchData() Normal method accessible via: Swift NetworkManager.shared.fetchData() 🚀 Usage Swift NetworkManager.shared.fetchData() Great question — this is something many Swift developers get confused about 👍 ❓ Is final mandatory for Singleton in Swift? 👉 Short answer: NO, it is NOT mandatory. Your Singleton will work perfectly fine without final. 🧠 Then why do we sometimes use final class? Adding final is a best practice, not a requirement. 🔹 What does final do? Swift final class NetworkManager { 👉 It prevents subclassing: Swift class CustomManager: NetworkManager { } ❌ Not allowed ⚠️ Problem WITHOUT final If you don’t use final, someone can subclass your Singleton: Swift class CustomManager: NetworkManager { override init() { super.init() } } Now you may end up with: Swift let custom = CustomManager() 👉 ❌ This breaks the “single instance” rule conceptually Even though shared still exists, your design is no longer strictly controlled. ✅ Why final is recommended 1. 🔒 Enforces strict Singleton No subclass → no alternate instances 2. ⚡ Performance optimization Swift compiler can optimize final classes better (no dynamic dispatch) 3. 🧼 Clear intention You’re telling other developers: “This class should NEVER be subclassed” 🆚 With vs Without final Without final Swift class NetworkManager { static let shared = NetworkManager() private init() {} } ✔ Works ❌ Can be subclassed With final (Recommended ✅) Swift final class NetworkManager { static let shared = NetworkManager() private init() {} } ✔ Works ✔ Cannot be subclassed ✔ Safer design 🎯 Real-world practice Most production code (especially in iOS apps) uses: Swift final class NetworkManager final class UserSession final class AppSettings #iOS #Swift #SwiftUI #iOSDeveloper #iOSDevelopment #SwiftProgramming #SwiftDeveloper #SwiftConcurrency #AppleDeveloper #Xcode #MobileDev #MobileAppDevelopment #SoftwareDeveloper #Programming #Coding #CleanArchitecture #AsyncAwait #Actors #MVVM #iOSArchitecture #InterviewPrep #iOSInterview

Never trust a float in a validation check. 🫠 I was writing backend validation logic in Go recently. Nothing fancy, just checking whether a calculated total matched an expected value. The math was clean on paper. In the debugger, the check kept failing. I stared at it for longer than I'd like to admit before I spotted the culprit: 0.30000000000000004 If you've spent time in JavaScript, you've seen this ghost before. But running into it in a Go backend, in financial validation logic, is a different kind of frustration. What's actually going on: Computers are genuinely bad at storing most decimal numbers. Under IEEE 754, numbers like 0.1 and 0.2 can't be represented exactly in binary. They become long repeating fractions. When you add them together, the tiny errors compound. So 0.1 + 0.2 doesn't give you 0.3. It gives you 0.30000000000000004. Writing "if a == b" with float64 values isn't just risky. It's a future production bug waiting for the right inputs to trigger it. What I did about it: The clean fix is to use integers (store paise/cents instead of rupees/dollars) or a proper decimal library. In a greenfield project, I'd go that route without hesitation. But this was a large existing codebase. Swapping float types across hundreds of files is a risky, multi-day refactor. Not worth it for one isolated bug. So I went with the epsilon comparison: // instead of: if calculated == expected if math.Abs(calculated - expected) <= 1e-8 {   // validation passes now } Instead of asking "are these exactly equal?", you ask "is the difference small enough to just be floating-point noise?" The right epsilon depends on your precision needs. For financial figures with 2 decimal places, somewhere between 1e-7 and 1e-9 is usually safe. The bug took five minutes to fix. Finding it took much longer. Floating-point issues are sneaky because the code looks correct, the logic is correct, and the math is correct. Right up until it isn't. Have you ever chased a float bug into production? How did you handle it? #Golang #BackendEngineering #SoftwareDevelopment #CodingTips #TechLife #CleanCode

Most React bugs aren't logic errors. They're state shape errors. ⚠️ The type allowed it. And nobody caught it until production. 𝗛𝗲𝗿𝗲'𝘀 𝘄𝗵𝗮𝘁 𝗺𝗼𝘀𝘁 𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁 𝘀𝘁𝗮𝘁𝗲 𝗹𝗼𝗼𝗸𝘀 𝗹𝗶𝗸𝗲: interface RequestState { isLoading: boolean; data?: User; error?: string; } This type allows impossible states: ● isLoading: true AND data: User at the same time ● error: "failed" AND data: User at the same time ● isLoading: false with no data and no error — what just happened? setState({ isLoading: false, data: undefined, error: undefined }); UI shows nothing. No loading. No error. Just a blank screen. Your UI is now guessing which state is real. 𝗗𝗶𝘀𝗰𝗿𝗶𝗺𝗶𝗻𝗮𝘁𝗲𝗱 𝘂𝗻𝗶𝗼𝗻𝘀 𝗲𝗹𝗶𝗺𝗶𝗻𝗮𝘁𝗲 𝘁𝗵𝗲 𝗴𝘂𝗲𝘀𝘀𝗶𝗻𝗴: type RequestState = | { status: 'idle' } | { status: 'loading' } | { status: 'success'; data: User } | { status: 'error'; error: string } Now impossible states are actually impossible. data only exists on success. error only exists on error. TypeScript enforces it — not your runtime checks. 𝗨𝘀𝗶𝗻𝗴 𝗶𝘁 𝗶𝗻 𝗮 𝗰𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁: switch (state.status) { case 'loading': return <Spinner />; case 'error': return <Error message={state.error} />; case 'success': return <Dashboard data={state.data} />; default: return null; } No optional chaining. No data?.user?.name. No undefined checks. The compiler already knows what exists at each branch. ⚠️ Boolean flags scale poorly. State machines don't. 🎯 𝗧𝗵𝗲 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆 The goal of TypeScript isn't to describe what your data looks like. It's to make wrong states unrepresentable. 💬 What's a bug you hit because your state allowed something impossible? Drop it below. 👇 #TypeScript #SoftwareEngineering #WebDev #FrontendEngineering #ReactJS

⚠️ ✋ Do you use any when you don't know the type of your API data? Here is #Day7 of #TypescriptBeforeAngular with SANDEEP KUMAR (#IAM5K) : #Any vs #Unknown (The "Safe" Way to Handle Dynamic Data) We’ve all done it. It feels flexible. But any is a dangerous trap that turns off TypeScript entirely, inviting those classic "cannot read property of undefined" errors into your app. There is a better, safer way to handle data when you don't know what it is yet. 1️⃣ What are Any and Unknown? Think of any as the escape hatch. It tells #TypeScript: "I don't care what this is, just disable all rules and let me use it." This is easy, but dangerous. Think of unknown as the safety checkpoint. It says: "We don't know what this data is yet, so you cannot use it until you prove what it is." // --- The DANGEROUS way (any) --- let valueAny: any = 'Hello'; valueAny.toUpperCase(); // ✅ No problem! (Even if valueAny was a number, TS wouldn't care... until it crashes). // --- The #SAFE way (unknown) --- let valueUnknown: unknown = 'Hello'; // valueUnknown.toUpperCase(); // 🛑 Error! We don't know if it's a string bucket yet. // First, perform a TYPE CHECK (type guard): if (typeof valueUnknown === 'string') { valueUnknown.toUpperCase(); // ✅ Safe! Now the compiler knows it's a string bucket. } 2️⃣ Significance in #Angular: When I first started, I used any everywhere—especially when dealing with data coming from an API (JSON response). I thought I was being flexible. But any silenced the compiler, making it impossible to catch errors before they happened. In modern Angular, unknown is your best friend when you receive dynamic data. By using unknown instead of any, you are forcing yourself (and your team) to perform a "type check" before you use the data in your component logic or templates. This single extra step prevents common beginner bugs where you assume an API object has a property that doesn't exist. It’s about building an Angular app that isn’t just "typed," but truly safe. 💡 Beginner Tip: unknown makes your code slightly more robust to write, but it completely removes the fear of runtime crashes. In strict Angular applications, using unknown followed by a simple check is always the safer, more professional choice. If unknown gives error, spend some time to get the Data type of Response. This will save production from crashing due to unknown reasons 😎 . 👉 Have you ever had your Angular app crash because any let a bad piece of data sneak into your logic? Tell me about that nightmare!👇 Follow me (SANDEEP KUMAR) so you dont miss the next one. See you at #Day7 of learning #TypescriptBeforeAngular #WebDev #CodingTips #NewDeveloper #CleanCode #AnyVsUnknown #Programming #TypeSafety #IAM5K #SandeepKumar #Javascript #Save #production

DotNet Blog: Union types expose a long-ignored gap in C#: type safety was often claimed, but rarely enforced at the boundaries where it matters most. C# has historically relied on conventions, null checks, and defensive programming to simulate closed data models, yet this approach quietly shifts complexity into runtime logic. With union types in C# 15, the language finally introduces a construct that enforces a finite set of possible states at compile time, backed by exhaustive pattern matching. The real shift is not syntactic, but semantic: instead of asking developers to remember every possible case, the compiler now demands completeness. This directly challenges a widespread assumption that flexibility equals robustness. In practice, unconstrained models tend to accumulate edge cases, while closed unions force deliberate design decisions early. However, this also introduces friction. Existing architectures built on loosely typed DTOs or polymorphic hierarchies will not adapt without refactoring. The promise of safer code comes at the cost of stricter modeling discipline, and not every team is prepared to embrace that trade-off. Union types are less about new capability and more about correcting a structural weakness in how state is represented. Ignoring that correction means continuing to rely on patterns that fail silently instead of failing fast, which is precisely where many production issues originate. In that sense, this is not just a feature, but a subtle shift toward more explicit and verifiable domain modeling within #CSharp and the broader #DotNet ecosystem, with clear implications for #SoftwareArchitecture and #TypeSafety. Link for first comment:

🏷️ The "Magic String": Why Go Struct Tags Blew My Node.js Mind 🤯 Coming from Node.js, converting an object to JSON is effortless. What you type is what you get. But today, while defining the User model for my Auth backend, I hit a wall with Go’s strictness. In Go, if you want a struct field to be visible outside its package (exported), it must start with a Capital letter: type User struct { Email string Firstname string } The Problem: My frontend and my database don’t want Firstname. They expect standard, lowercase JSON: {"firstname": "Dave"}. The Solution: Struct Tags. type User struct { Email string `json:"email"` Firstname string `json:"firstname"` } 🧐 Why were they invented? Struct tags were invented to be the bridge between Go’s rigid internal capitalization rules and the messy, lowercase/snake_case external world (APIs, databases, XML). It tells Go’s encoders: "I know my internal name is Firstname, but when you talk to the outside world, put on this firstname nametag." 🤫 The Secret Most Beginners Don't Know Here is the wild part: The Go compiler completely ignores struct tags. They are literally just raw strings evaluated at runtime using a concept called Reflection. Because the compiler ignores them, if you accidentally make a typo and write `jsn:"email"` instead of `json:"email"`, your app will compile perfectly. But when you run it, the JSON decoder will silently ignore it, and your API response will leak the capitalized Email key. It's another silent failure trap! 🪤 The upside? Because it's just a raw string, you can invent your own tags! Packages like validator use this to let you write custom rules like `validate:"required,min=4"`. I used to think Go was just rigidly strict, but under the hood, it has these crazy, powerful escape hatches. The architecture is getting deep. We move! 💪🏾 To my Senior Gophers: What is the most creative or complex use of custom Struct Tags you’ve seen in a production codebase? Let’s gist in the comments 👇🏾 #Golang #BackendEngineering #SoftwareArchitecture #SystemDesign #TechBro #TechInNigeria #WeMove

⚙️ Worker Threads vs Clustering in Node.js (When to Use What?) Node.js is powerful… But it runs on a single thread. So how do we handle: ❌ CPU-heavy tasks ❌ Multi-core usage ❌ High scalability Node.js gives us two powerful solutions: 👉 Clustering 👉 Worker Threads Let’s break it down 👇 ⚡ 1️⃣ Clustering (Multi-Process Scaling) Clustering allows you to create multiple Node.js processes. Each process runs on a separate CPU core. 🔁 How it works Master Process ⬇ Multiple Worker Processes ⬇ Each handles incoming requests ✅ Best for: ✔ Handling high traffic ✔ Scaling APIs ✔ Load balancing across cores 🧠 2️⃣ Worker Threads (Multi-Threading) Worker threads allow you to run CPU-heavy tasks in parallel threads. Instead of blocking the event loop, work is offloaded. 🔁 How it works Main Thread ⬇ Worker Thread ⬇ Executes heavy computation ✅ Best for: ✔ Image processing ✔ Data parsing ✔ CPU-intensive tasks ⚖️ Clustering vs Worker Threads Clustering ✔ Multi-process ✔ Handles requests ✔ Improves scalability Worker Threads ✔ Multi-threaded ✔ Handles heavy computation ✔ Prevents event loop blocking 📊 Real Insight Most production systems use both together: ✔ Clustering → handle traffic ✔ Worker Threads → handle heavy tasks 💡 Final Thought Scaling Node.js is not about one technique… It’s about choosing the right tool for the right problem. Have you used Worker Threads or Clustering in your projects? Which worked better for you? Let’s discuss 👨💻 #NodeJS #JavaScript #BackendDevelopment #SystemDesign #Scalability #WorkerThreads #Clustering #PerformanceOptimization #TechTips #SoftwareEngineering #Microservices #DevOps

𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀 𝗜 𝗔𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗨𝘀𝗲 𝗗𝗮𝗶𝗹𝘆 There is a moment with TypeScript when you stop fighting it. For me it was 2 AM on a Tuesday. A production bug that would have been impossible with good types. That changed how I think about code. This is not a beginner guide. If you are still confused about interface vs type, read something else. This is what is in my head when I code today. The patterns I use without thinking. The ones that saved me. The mistakes I made before I understood them. If I had to keep one pattern it would be this. Discriminated unions. You create a union type. Each variant has a common property like `status` or `kind`. TypeScript uses this to know exactly what you are working with. type ApiResponse<T> = | { status: 'loading' } | { status: 'error'; error: string; code: number } | { status: 'success'; data: T; timestamp: Date }; function renderUser(response: ApiResponse<User>) { switch (response.status) { case 'loading': return <Spinner />; case 'error': // TypeScript knows response.error and response.code exist here return <ErrorMessage message={response.error} code={response.code} />; case 'success': // TypeScript knows response.data and response.timestamp exist here return <UserCard user={response.data} />; } } TypeScript forces you to handle every case. Add a new state like `cancelled`. The compiler tells you exactly where you forgot to handle it. It is like a silent pair programmer. I use this for: - Domain events - UI states - Async operation results Last year I built an e-commerce system. I modeled every order state this way. type OrderState = | { kind: 'draft'; items: CartItem[] } | { kind: 'pending_payment'; orderId: string; total: Money } | { kind: 'paid'; orderId: string; paymentId: string; paidAt: Date } | { kind: 'shipped'; orderId: string; trackingCode: string } | { kind: 'delivered'; orderId: string; deliveredAt: Date } | { kind: 'cancelled'; orderId: string; reason: string }; Each state has only the data it needs. No weird optional fields. No `trackingCode: string | null` where you do not know if null means not shipped or an old order. The type is the documentation. Branded types This one was harder to learn but I cannot live without it. The problem is simple. `userId: string` and `productId: string` are the same type to TypeScript. They are not the same to your business. Mixing them is a bug. Without branded types TypeScript does not catch this error. function getUser(id: string) { /* ... */ } function getProduct(id: string) { /* ... */ } const productId = '123'; getUser(productId); // TypeScript says this is fine. It is wrong. With branded types you create unique types from primitives. type Brand<T, B> = T & { readonly __brand: B }; type UserId = Brand<string, 'UserId'>; type ProductId = Brand<stri