Can’t See Someone’s Last Seen on Telegram? Here’s Why & What to Do 🚀 webstick.blog/telegram-last-… #TelegramHiddenStatus #LastSeenError #FindUser #ChatPrivacy #AppSettings #TechGuide #FixNow

That's a job of findUser, but it's leaking information via that 404.

Let name = findUser(this)... If name.isDeveloper() // check dev status return "Ohanz is OpenToConnect() 👨‍💻♠️❤"

Let name = findUser(this)... If name.isDeveloper() // check dev status return "Ohanz is OpenToConnect() 👨‍💻♠️❤"

Clean or dangerous? Optional<User> user = findUser(id); if (user.isPresent()) { sendEmail(user.get()); } Why might this not be the best way to use Optional? What would a senior engineer suggest instead?

Classic case of Optional being treated like it’s… not optional 😅 Optional is never null. This code defeats the whole purpose. return findUser(id) .map(User::getEmail) .orElse(null); Or if absence is exceptional, use orElseThrow(). Optional ≠ fancy null wrapper. Use it properly 👀

In general returning "null" for a user does not really make sense... either return a "ANONYMOUS" (or alike) or throw an exception: return findUser(id).orElse("ANONYMOUS"); or return findUser(id).orElseThrow(new UserNotFoundException("The user %d couldn't be found".format(id));

Issues: - Optional itself should never be null - Calling get() without checking isPresent() can throw - Returning null reintroduces null-handling trying to avoid Or better, don’t return null at all: return findUser(id) .map(User::getEmail);

This code defeats the purpose of Optional. Instead of guarding against null, you're checking the Optional reference itself. The correct pattern is to use its API to handle presence or absence: return findUser(id) // Returns Optional<User> .map(User::getEmail) // If a User is present, get the email .orElse(null); // If not, return null Even better, avoid null entirely and return Optional<String>.

never check if an Optional is null. if an api returns Optional, the contract is that it will always return an object (either empty or full), never null. checking user != null implies you don't trust findUser to follow the basic rules of the type system.

This code can be simplified using the Optional class's map function to avoid explicit null checks, making it more concise and readable For example- you can use return findUser(id).map(User::getEmail).orElse(null); to achieve the same result.

Review this code : Optional<User> user = findUser(id); if (user != null) { return user.get().getEmail(); } return null;

Rust patterns that make your TypeScript actually type-safe Most TS codebases claim to be "type-safe" but panic at runtime constantly. Here's how to write TypeScript that borrows Rust's obsession with correctness. --- 1. Result types instead of throwing Rust doesn't have exceptions. Every error is a value you handle explicitly. TypeScript has exceptions, but you can choose not to use them. 𝐁𝐚𝐝 (𝐬𝐭𝐚𝐧𝐝𝐚𝐫𝐝 𝐓𝐒): `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝖿𝗎𝗇𝖼𝗍𝗂𝗈𝗇 𝗉𝖺𝗋𝗌𝖾𝖴𝗌𝖾𝗋(𝗃𝗌𝗈𝗇: 𝗌𝗍𝗋𝗂𝗇𝗀): 𝖴𝗌𝖾𝗋 { 𝖼𝗈𝗇𝗌𝗍 𝖽𝖺𝗍𝖺 =̵ 𝖩𝖲𝖮𝖭.𝗉𝖺𝗋𝗌𝖾(𝗃𝗌𝗈𝗇); // 𝖢𝖺𝗇 𝗍𝗁𝗋𝗈𝗐 𝗂𝖿 (!𝖽𝖺𝗍𝖺.𝖾𝗆𝖺𝗂𝗅) 𝗍𝗁𝗋𝗈𝗐 𝗇𝖾𝗐 𝖤𝗋𝗋𝗈𝗋('𝖬𝗂𝗌𝗌𝗂𝗇𝗀 𝖾𝗆𝖺𝗂𝗅'); // 𝖢𝖺𝗇 𝗍𝗁𝗋𝗈𝗐 𝗋𝖾𝗍𝗎𝗋𝗇 𝖽𝖺𝗍𝖺; } // 𝖢𝖺𝗅𝗅𝖾𝗋 𝗁𝖺𝗌 𝗇𝗈 𝗂𝖽𝖾𝖺 𝗍𝗁𝗂𝗌 𝗍𝗁𝗋𝗈𝗐𝗌 𝖼𝗈𝗇𝗌𝗍 𝗎𝗌𝖾𝗋 =̵ 𝗉𝖺𝗋𝗌𝖾𝖴𝗌𝖾𝗋(𝗂𝗇𝗉𝗎𝗍); ` 𝐆𝐨𝐨𝐝 (𝐑𝐮𝐬𝐭-𝐬𝐭𝐲𝐥𝐞): `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝗍𝗒𝗉𝖾 𝖱𝖾𝗌𝗎𝗅𝗍<𝖳, 𝖤> = | { 𝗈𝗄: 𝗍𝗋𝗎𝖾; 𝗏𝖺𝗅𝗎𝖾: 𝖳 } | { 𝗈𝗄: 𝖿𝖺𝗅𝗌𝖾; 𝖾𝗋𝗋𝗈𝗋: 𝖤 }; 𝖿𝗎𝗇𝖼𝗍𝗂𝗈𝗇 𝗉𝖺𝗋𝗌𝖾𝖴𝗌𝖾𝗋(𝗃𝗌𝗈𝗇: 𝗌𝗍𝗋𝗂𝗇𝗀): 𝖱𝖾𝗌𝗎𝗅𝗍<𝖴𝗌𝖾𝗋, 𝗌𝗍𝗋𝗂𝗇𝗀> { 𝗍𝗋𝗒 { 𝖼𝗈𝗇𝗌𝗍 𝖽𝖺𝗍𝖺 = 𝖩𝖲𝖮𝖭.𝗉𝖺𝗋𝗌𝖾(𝗃𝗌𝗈𝗇); 𝗂𝖿 (!𝖽𝖺𝗍𝖺.𝖾𝗆𝖺𝗂𝗅) { 𝗋𝖾𝗍𝗎𝗋𝗇 { 𝗈𝗄: 𝖿𝖺𝗅𝗌𝖾, 𝖾𝗋𝗋𝗈𝗋: '𝖬𝗂𝗌𝗌𝗂𝗇𝗀 𝖾𝗆𝖺𝗂𝗅' }; } 𝗋𝖾𝗍𝗎𝗋𝗇 { 𝗈𝗄: 𝗍𝗋𝗎𝖾, 𝗏𝖺𝗅𝗎𝖾: 𝖽𝖺𝗍𝖺 }; } 𝖼𝖺𝗍𝖼𝗁 (𝖾) { 𝗋𝖾𝗍𝗎𝗋𝗇 { 𝗈𝗄: 𝖿𝖺𝗅𝗌𝖾, 𝖾𝗋𝗋𝗈𝗋: '𝖨𝗇𝗏𝖺𝗅𝗂𝖽 𝖩𝖲𝖮𝖭' }; } } // 𝖢𝗈𝗆𝗉𝗂𝗅𝖾𝗋 𝖿𝗈𝗋𝖼𝖾𝗌 𝗒𝗈𝗎 𝗍𝗈 𝗁𝖺𝗇𝖽𝗅𝖾 𝖻𝗈𝗍𝗁 𝖼𝖺𝗌𝖾𝗌 𝖼𝗈𝗇𝗌𝗍 𝗋𝖾𝗌𝗎𝗅𝗍 = 𝗉𝖺𝗋𝗌𝖾𝖴𝗌𝖾𝗋(𝗂𝗇𝗉𝗎𝗍); 𝗂𝖿 (𝗋𝖾𝗌𝗎𝗅𝗍.𝗈𝗄) { 𝖼𝗈𝗇𝗌𝗈𝗅𝖾.𝗅𝗈𝗀(𝗋𝖾𝗌𝗎𝗅𝗍.𝗏𝖺𝗅𝗎𝖾.𝖾𝗆𝖺𝗂𝗅); } 𝖾𝗅𝗌𝖾 { 𝖼𝗈𝗇𝗌𝗈𝗅𝖾.𝖾𝗋𝗋𝗈𝗋(𝗋𝖾𝗌𝗎𝗅𝗍.𝖾𝗋𝗋𝗈𝗋); } ` Now errors are in the type signature. You can't ignore them. --- 2. Option types for nullable values Rust has `Option<T>` for "maybe exists, maybe doesn't." TypeScript has `T | null | undefined` but people handle it inconsistently. 𝐁𝐚𝐝: `typescript function findUser(id: string): User | null { return db.get(id) ?? null; } const user = findUser('123'); console.log(user.email); // Runtime error if null ` 𝐆𝐨𝐨𝐝: `typescript type Option<T> = | { some: true; value: T } | { some: false }; function findUser(id: string): Option<User> { const user = db.get(id); return user ? { some: true, value: user } : { some: false }; } const result = findUser('123'); if (result.some) { console.log(result.value.email); // Type-safe } else { console.log('User not found'); } ` Can't access `.value` without checking `.some` first. --- 3. Exhaustive pattern matching Rust's `match` forces you to handle every case. TypeScript's `switch` doesn't. You can forget cases silently. 𝐁𝐚𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝗍𝗒𝗉𝖾 𝖲𝗍𝖺𝗍𝗎𝗌 = '𝗉𝖾𝗇𝖽𝗂𝗇𝗀' | '𝗌𝗎𝖼𝖼𝖾𝗌𝗌' | '𝖾𝗋𝗋𝗈𝗋'; 𝖿𝗎𝗇𝖼𝗍𝗂𝗈𝗇 𝗁𝖺𝗇𝖽𝗅𝖾𝖲𝗍𝖺𝗍𝗎𝗌(𝗌𝗍𝖺𝗍𝗎𝗌: 𝖲𝗍𝖺𝗍𝗎𝗌) { 𝗌𝗐𝗂𝗍𝖼𝗁 (𝗌𝗍𝖺𝗍𝗎𝗌) { 𝖼𝖺𝗌𝖾 '𝗉𝖾𝗇𝖽𝗂𝗇𝗀': 𝗋𝖾𝗍𝗎𝗋𝗇 '𝖫𝗈𝖺𝖽𝗂𝗇𝗀...'; 𝖼𝖺𝗌𝖾 '𝗌𝗎𝖼𝖼𝖾𝗌𝗌': 𝗋𝖾𝗍𝗎𝗋𝗇 '𝖣𝗈𝗇𝖾!'; // 𝖥𝗈𝗋𝗀𝗈𝗍 '𝖾𝗋𝗋𝗈𝗋' - 𝖼𝗈𝗆𝗉𝗂𝗅𝖾𝗌 𝖿𝗂𝗇𝖾, 𝖻𝗋𝖾𝖺𝗄𝗌 𝖺𝗍 𝗋𝗎𝗇𝗍𝗂𝗆𝖾 } } ` 𝐆𝐨𝐨𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝖿𝗎𝗇𝖼𝗍𝗂𝗈𝗇 𝗁𝖺𝗇𝖽𝗅𝖾𝖲𝗍𝖺𝗍𝗎𝗌(𝗌𝗍𝖺𝗍𝗎𝗌: 𝖲𝗍𝖺𝗍𝗎𝗌): 𝗌𝗍𝗋𝗂𝗇𝗀 { 𝗌𝗐𝗂𝗍𝖼𝗁 (𝗌𝗍𝖺𝗍𝗎𝗌) { 𝖼𝖺𝗌𝖾 '𝗉𝖾𝗇𝖽𝗂𝗇𝗀': 𝗋𝖾𝗍𝗎𝗋𝗇 '𝖫𝗈𝖺𝖽𝗂𝗇𝗀...'; 𝖼𝖺𝗌𝖾 '𝗌𝗎𝖼𝖼𝖾𝗌𝗌': 𝗋𝖾𝗍𝗎𝗋𝗇 '𝖣𝗈𝗇𝖾!'; 𝖼𝖺𝗌𝖾 '𝖾𝗋𝗋𝗈𝗋': 𝗋𝖾𝗍𝗎𝗋𝗇 '𝖥𝖺𝗂𝗅𝖾𝖽!'; 𝖽𝖾𝖿𝖺𝗎𝗅𝗍: 𝖼𝗈𝗇𝗌𝗍 _𝖾𝗑𝗁𝖺𝗎𝗌𝗍𝗂𝗏𝖾: 𝗇𝖾𝗏𝖾𝗋 = 𝗌𝗍𝖺𝗍𝗎𝗌; 𝗍𝗁𝗋𝗈𝗐 𝗇𝖾𝗐 𝖤𝗋𝗋𝗈𝗋(`𝖴𝗇𝗁𝖺𝗇𝖽𝗅𝖾𝖽 𝗌𝗍𝖺𝗍𝗎𝗌: ${_𝖾𝗑𝗁𝖺𝗎𝗌𝗍𝗂𝗏𝖾}`); } } ` Add a new status? TypeScript errors until you handle it. --- 4. Branded types for validation Rust newtypes prevent mixing incompatible types. TypeScript's structural typing lets you pass any string anywhere. 𝐁𝐚𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝖿𝗎𝗇𝖼𝗍𝗂𝗈𝗇 𝗌𝖾𝗇𝖽𝖤𝗆𝖺𝗂𝗅(𝖾𝗆𝖺𝗂𝗅: 𝗌𝗍𝗋𝗂𝗇𝗀) { ... } 𝖿𝗎𝗇𝖼𝗍𝗂𝗈𝗇 𝖽𝖾𝗅𝖾𝗍𝖾𝖴𝗌𝖾𝗋(𝗎𝗌𝖾𝗋𝖨𝖽: 𝗌𝗍𝗋𝗂𝗇𝗀) { ... } 𝖼𝗈𝗇𝗌𝗍 𝖾𝗆𝖺𝗂𝗅 = '𝗎𝗌𝖾𝗋@𝖾𝗑𝖺𝗆𝗉𝗅𝖾.𝖼𝗈𝗆'; 𝖽𝖾𝗅𝖾𝗍𝖾𝖴𝗌𝖾𝗋(𝖾𝗆𝖺𝗂𝗅); // 𝖢𝗈𝗆𝗉𝗂𝗅𝖾𝗌 𝖿𝗂𝗇𝖾. 𝖣𝗂𝗌𝖺𝗌𝗍𝖾𝗋. ` 𝐆𝐨𝐨𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝗍𝗒𝗉𝖾 𝖤𝗆𝖺𝗂𝗅 = 𝗌𝗍𝗋𝗂𝗇𝗀 & { 𝗋𝖾𝖺𝖽𝗈𝗇𝗅𝗒 __𝖻𝗋𝖺𝗇𝖽: '𝖤𝗆𝖺𝗂𝗅' }; 𝗍𝗒𝗉𝖾 𝖴𝗌𝖾𝗋𝖨𝖽 = 𝗌𝗍𝗋𝗂𝗇𝗀 & { 𝗋𝖾𝖺𝖽𝗈𝗇𝗅𝗒 __𝖻𝗋𝖺𝗇𝖽: '𝖴𝗌𝖾𝗋𝖨𝖽' }; 𝖿𝗎𝗇𝖼𝗍𝗂𝗈𝗇 𝖤𝗆𝖺𝗂𝗅(𝗌: 𝗌𝗍𝗋𝗂𝗇𝗀): 𝖤𝗆𝖺𝗂𝗅 | 𝗇𝗎𝗅𝗅 { 𝗋𝖾𝗍𝗎𝗋𝗇 𝗌.𝗂𝗇𝖼𝗅𝗎𝖽𝖾𝗌('@') ? 𝗌 𝖺𝗌 𝖤𝗆𝖺𝗂𝗅 : 𝗇𝗎𝗅𝗅; } 𝖿𝗎𝗇𝖼𝗍𝗂𝗈𝗇 𝖴𝗌𝖾𝗋𝖨𝖽(𝗌: 𝗌𝗍𝗋𝗂𝗇𝗀): 𝖴𝗌𝖾𝗋𝖨𝖽 { 𝗋𝖾𝗍𝗎𝗋𝗇 𝗌 𝖺𝗌 𝖴𝗌𝖾𝗋𝖨𝖽; } 𝖿𝗎𝗇𝖼𝗍𝗂𝗈𝗇 𝗌𝖾𝗇𝖽𝖤𝗆𝖺𝗂𝗅(𝖾𝗆𝖺𝗂𝗅: 𝖤𝗆𝖺𝗂𝗅) { ... } 𝖿𝗎𝗇𝖼𝗍𝗂𝗈𝗇 𝖽𝖾𝗅𝖾𝗍𝖾𝖴𝗌𝖾𝗋(𝗎𝗌𝖾𝗋𝖨𝖽: 𝖴𝗌𝖾𝗋𝖨𝖽) { ... } 𝖼𝗈𝗇𝗌𝗍 𝖾𝗆𝖺𝗂𝗅 = 𝖤𝗆𝖺𝗂𝗅('𝗎𝗌𝖾𝗋@𝖾𝗑𝖺𝗆𝗉𝗅𝖾.𝖼𝗈𝗆')!; 𝖼𝗈𝗇𝗌𝗍 𝗎𝗌𝖾𝗋𝖨𝖽 = 𝖴𝗌𝖾𝗋𝖨𝖽('𝟣𝟤𝟥'); 𝖽𝖾𝗅𝖾𝗍𝖾𝖴𝗌𝖾𝗋(𝖾𝗆𝖺𝗂𝗅); // 𝖳𝗒𝗉𝖾 𝖾𝗋𝗋𝗈𝗋! 𝖢𝖺𝗇'𝗍 𝗆𝗂𝗑 𝗍𝗁𝖾𝗆. ` Primitive types but compiler-enforced separation. --- 5. Builder pattern for complex construction Rust uses builders for objects with many optional fields. TypeScript just has massive option objects that nobody validates. 𝐁𝐚𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝗂𝗇𝗍𝖾𝗋𝖿𝖺𝖼𝖾 𝖢𝗈𝗇𝖿𝗂𝗀 { 𝗁𝗈𝗌𝗍?: 𝗌𝗍𝗋𝗂𝗇𝗀; 𝗉𝗈𝗋𝗍?: 𝗇𝗎𝗆𝖻𝖾𝗋; 𝗍𝗂𝗆𝖾𝗈𝗎𝗍?: 𝗇𝗎𝗆𝖻𝖾𝗋; 𝗋𝖾𝗍𝗋𝗂𝖾𝗌?: 𝗇𝗎𝗆𝖻𝖾𝗋; } // 𝖶𝗁𝖺𝗍'𝗌 𝗋𝖾𝗊𝗎𝗂𝗋𝖾𝖽? 𝖶𝗁𝖺𝗍 𝖺𝗋𝖾 𝗍𝗁𝖾 𝖽𝖾𝖿𝖺𝗎𝗅𝗍𝗌? 𝖶𝗁𝗈 𝗄𝗇𝗈𝗐𝗌. 𝖼𝗈𝗇𝗌𝗍 𝖼𝗈𝗇𝖿𝗂𝗀: 𝖢𝗈𝗇𝖿𝗂𝗀 = { 𝗁𝗈𝗌𝗍: '𝗅𝗈𝖼𝖺𝗅𝗁𝗈𝗌𝗍' }; ` 𝐆𝐨𝐨𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝖼𝗅𝖺𝗌𝗌 𝖢𝗈𝗇𝖿𝗂𝗀𝖡𝗎𝗂𝗅𝖽𝖾𝗋 { 𝗉𝗋𝗂𝗏𝖺𝗍𝖾 𝗁𝗈𝗌𝗍 = '𝗅𝗈𝖼𝖺𝗅𝗁𝗈𝗌𝗍'; 𝗉𝗋𝗂𝗏𝖺𝗍𝖾 𝗉𝗈𝗋𝗍 = 𝟪𝟢𝟪𝟢; 𝗉𝗋𝗂𝗏𝖺𝗍𝖾 𝗍𝗂𝗆𝖾𝗈𝗎𝗍 = 𝟧𝟢𝟢𝟢; 𝗉𝗋𝗂𝗏𝖺𝗍𝖾 𝗋𝖾𝗍𝗋𝗂𝖾𝗌 = 𝟥; 𝗌𝖾𝗍𝖧𝗈𝗌𝗍(𝗁𝗈𝗌𝗍: 𝗌𝗍𝗋𝗂𝗇𝗀): 𝗍𝗁𝗂𝗌 { 𝗍𝗁𝗂𝗌.𝗁𝗈𝗌𝗍 = 𝗁𝗈𝗌𝗍; 𝗋𝖾𝗍𝗎𝗋𝗇 𝗍𝗁𝗂𝗌; } 𝗌𝖾𝗍𝖯𝗈𝗋𝗍(𝗉𝗈𝗋𝗍: 𝗇𝗎𝗆𝖻𝖾𝗋): 𝗍𝗁𝗂𝗌 { 𝗂𝖿 (𝗉𝗈𝗋𝗍 < 𝟢 || 𝗉𝗈𝗋𝗍 > 𝟨𝟧𝟧𝟥𝟧) { 𝗍𝗁𝗋𝗈𝗐 𝗇𝖾𝗐 𝖤𝗋𝗋𝗈𝗋('𝖨𝗇𝗏𝖺𝗅𝗂𝖽 𝗉𝗈𝗋𝗍'); } 𝗍𝗁𝗂𝗌.𝗉𝗈𝗋𝗍 = 𝗉𝗈𝗋𝗍; 𝗋𝖾𝗍𝗎𝗋𝗇 𝗍𝗁𝗂𝗌; } 𝗌𝖾𝗍𝖳𝗂𝗆𝖾𝗈𝗎𝗍(𝗆𝗌: 𝗇𝗎𝗆𝖻𝖾𝗋): 𝗍𝗁𝗂𝗌 { 𝗍𝗁𝗂𝗌.𝗍𝗂𝗆𝖾𝗈𝗎𝗍 = 𝗆𝗌; 𝗋𝖾𝗍𝗎𝗋𝗇 𝗍𝗁𝗂𝗌; } 𝖻𝗎𝗂𝗅𝖽(): 𝖢𝗈𝗇𝖿𝗂𝗀 { 𝗋𝖾𝗍𝗎𝗋𝗇 { 𝗁𝗈𝗌𝗍: 𝗍𝗁𝗂𝗌.𝗁𝗈𝗌𝗍, 𝗉𝗈𝗋𝗍: 𝗍𝗁𝗂𝗌.𝗉𝗈𝗋𝗍, 𝗍𝗂𝗆𝖾𝗈𝗎𝗍: 𝗍𝗁𝗂𝗌.𝗍𝗂𝗆𝖾𝗈𝗎𝗍, 𝗋𝖾𝗍𝗋𝗂𝖾𝗌: 𝗍𝗁𝗂𝗌.𝗋𝖾𝗍𝗋𝗂𝖾𝗌 }; } } 𝖼𝗈𝗇𝗌𝗍 𝖼𝗈𝗇𝖿𝗂𝗀 = 𝗇𝖾𝗐 𝖢𝗈𝗇𝖿𝗂𝗀𝖡𝗎𝗂𝗅𝖽𝖾𝗋() .𝗌𝖾𝗍𝖧𝗈𝗌𝗍('𝖺𝗉𝗂.𝖾𝗑𝖺𝗆𝗉𝗅𝖾.𝖼𝗈𝗆') .𝗌𝖾𝗍𝖯𝗈𝗋𝗍(𝟦𝟦𝟥) .𝖻𝗎𝗂𝗅𝖽(); ` Defaults clear. Validation enforced. Immutable result. --- 6. No silent coercion Rust doesn't let you compare different types. TypeScript does. And it's a footgun. 𝐁𝐚𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝖼𝗈𝗇𝗌𝗍 𝖼𝗈𝗎𝗇𝗍 = '𝟧'; 𝗂𝖿 (𝖼𝗈𝗎𝗇𝗍 > 𝟥) { // '𝟧' > 𝟥 𝗂𝗌 𝗍𝗋𝗎𝖾 (𝗌𝗍𝗋𝗂𝗇𝗀 𝖼𝗈𝗆𝗉𝖺𝗋𝗂𝗌𝗈𝗇) 𝖼𝗈𝗇𝗌𝗈𝗅𝖾.𝗅𝗈𝗀('𝖬𝗈𝗋𝖾 𝗍𝗁𝖺𝗇 𝟥'); } ` 𝐆𝐨𝐨𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 // 𝖤𝗇𝖺𝖻𝗅𝖾 𝗌𝗍𝗋𝗂𝖼𝗍 𝗆𝗈𝖽𝖾 𝗂𝗇 𝗍𝗌𝖼𝗈𝗇𝖿𝗂𝗀.𝗃𝗌𝗈𝗇 { "𝖼𝗈𝗆𝗉𝗂𝗅𝖾𝗋𝖮𝗉𝗍𝗂𝗈𝗇𝗌": { "𝗌𝗍𝗋𝗂𝖼𝗍": 𝗍𝗋𝗎𝖾, "𝗌𝗍𝗋𝗂𝖼𝗍𝖭𝗎𝗅𝗅𝖢𝗁𝖾𝖼𝗄𝗌": 𝗍𝗋𝗎𝖾, "𝗇𝗈𝖨𝗆𝗉𝗅𝗂𝖼𝗂𝗍𝖠𝗇𝗒": 𝗍𝗋𝗎𝖾 } } 𝖼𝗈𝗇𝗌𝗍 𝖼𝗈𝗎𝗇𝗍: 𝗇𝗎𝗆𝖻𝖾𝗋 = 𝗉𝖺𝗋𝗌𝖾𝖨𝗇𝗍('𝟧', 𝟣𝟢); 𝗂𝖿 (𝖼𝗈𝗎𝗇𝗍 > 𝟥) { // 𝖭𝗈𝗐 𝗂𝗍'𝗌 𝖺𝖼𝗍𝗎𝖺𝗅𝗅𝗒 𝖼𝗈𝗆𝗉𝖺𝗋𝗂𝗇𝗀 𝗇𝗎𝗆𝖻𝖾𝗋𝗌 𝖼𝗈𝗇𝗌𝗈𝗅𝖾.𝗅𝗈𝗀('𝖬𝗈𝗋𝖾 𝗍𝗁𝖺𝗇 𝟥'); } ` Strict mode catches this. Always use it. --- 7. Immutable by default Rust requires `mut` to make things mutable. TypeScript lets everything mutate unless you say otherwise. 𝐁𝐚𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝗂𝗇𝗍𝖾𝗋𝖿𝖺𝖼𝖾 𝖴𝗌𝖾𝗋 { 𝗂𝖽: 𝗌𝗍𝗋𝗂𝗇𝗀; 𝗇𝖺𝗆𝖾: 𝗌𝗍𝗋𝗂𝗇𝗀; } 𝖼𝗈𝗇𝗌𝗍 𝗎𝗌𝖾𝗋: 𝖴𝗌𝖾𝗋 = { 𝗂𝖽: '𝟣', 𝗇𝖺𝗆𝖾: '𝖠𝗅𝗂𝖼𝖾' }; 𝗎𝗌𝖾𝗋.𝗇𝖺𝗆𝖾 = '𝖡𝗈𝖻'; // 𝖬𝗎𝗍𝖺𝗍𝖾𝗌. 𝖭𝗈 𝗐𝖺𝗋𝗇𝗂𝗇𝗀. ` 𝐆𝐨𝐨𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝗂𝗇𝗍𝖾𝗋𝖿𝖺𝖼𝖾 𝖴𝗌𝖾𝗋 { 𝗋𝖾𝖺𝖽𝗈𝗇𝗅𝗒 𝗂𝖽: 𝗌𝗍𝗋𝗂𝗇𝗀; 𝗋𝖾𝖺𝖽𝗈𝗇𝗅𝗒 𝗇𝖺𝗆𝖾: 𝗌𝗍𝗋𝗂𝗇𝗀; } 𝖼𝗈𝗇𝗌𝗍 𝗎𝗌𝖾𝗋: 𝖴𝗌𝖾𝗋 = { 𝗂𝖽: '𝟣', 𝗇𝖺𝗆𝖾: '𝖠𝗅𝗂𝖼𝖾' }; 𝗎𝗌𝖾𝗋.𝗇𝖺𝗆𝖾 = '𝖡𝗈𝖻'; // 𝖳𝗒𝗉𝖾 𝖾𝗋𝗋𝗈𝗋 // 𝖮𝗋 𝗎𝗌𝖾 𝖱𝖾𝖺𝖽𝗈𝗇𝗅𝗒 𝗎𝗍𝗂𝗅𝗂𝗍𝗒 𝗍𝗒𝗉𝖾 𝖴𝗌𝖾𝗋 = 𝖱𝖾𝖺𝖽𝗈𝗇𝗅𝗒<{ 𝗂𝖽: 𝗌𝗍𝗋𝗂𝗇𝗀; 𝗇𝖺𝗆𝖾: 𝗌𝗍𝗋𝗂𝗇𝗀; }>; ` Make mutation explicit, not the default. --- 8. Phantom types for state machines Rust uses phantom types to track state at compile time. TypeScript can do this too, but almost nobody does. 𝐁𝐚𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝖼𝗅𝖺𝗌𝗌 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝗂𝗈𝗇 { 𝗉𝗋𝗂𝗏𝖺𝗍𝖾 𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽 = 𝖿𝖺𝗅𝗌𝖾; 𝖼𝗈𝗇𝗇𝖾𝖼𝗍() { 𝗍𝗁𝗂𝗌.𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽 = 𝗍𝗋𝗎𝖾; } 𝗌𝖾𝗇𝖽(𝖽𝖺𝗍𝖺: 𝗌𝗍𝗋𝗂𝗇𝗀) { 𝗂𝖿 (!𝗍𝗁𝗂𝗌.𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽) 𝗍𝗁𝗋𝗈𝗐 𝗇𝖾𝗐 𝖤𝗋𝗋𝗈𝗋('𝖭𝗈𝗍 𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽'); // ... } } 𝖼𝗈𝗇𝗌𝗍 𝖼𝗈𝗇𝗇 = 𝗇𝖾𝗐 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝗂𝗈𝗇(); 𝖼𝗈𝗇𝗇.𝗌𝖾𝗇𝖽('𝗁𝖾𝗅𝗅𝗈'); // 𝖱𝗎𝗇𝗍𝗂𝗆𝖾 𝖾𝗋𝗋𝗈𝗋 ` 𝐆𝐨𝐨𝐝: `𝗍𝗒𝗉𝖾𝗌𝖼𝗋𝗂𝗉𝗍 𝗍𝗒𝗉𝖾 𝖣𝗂𝗌𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽 = { 𝗋𝖾𝖺𝖽𝗈𝗇𝗅𝗒 𝗌𝗍𝖺𝗍𝖾: '𝖽𝗂𝗌𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽' }; 𝗍𝗒𝗉𝖾 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽 = { 𝗋𝖾𝖺𝖽𝗈𝗇𝗅𝗒 𝗌𝗍𝖺𝗍𝖾: '𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽' }; 𝖼𝗅𝖺𝗌𝗌 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝗂𝗈𝗇<𝖲𝗍𝖺𝗍𝖾> { 𝗉𝗋𝗂𝗏𝖺𝗍𝖾 𝖼𝗈𝗇𝗌𝗍𝗋𝗎𝖼𝗍𝗈𝗋(𝗉𝗋𝗂𝗏𝖺𝗍𝖾 𝗌𝗍𝖺𝗍𝖾: 𝖲𝗍𝖺𝗍𝖾) {} 𝗌𝗍𝖺𝗍𝗂𝖼 𝖼𝗋𝖾𝖺𝗍𝖾(): 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝗂𝗈𝗇<𝖣𝗂𝗌𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽> { 𝗋𝖾𝗍𝗎𝗋𝗇 𝗇𝖾𝗐 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝗂𝗈𝗇({ 𝗌𝗍𝖺𝗍𝖾: '𝖽𝗂𝗌𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽' }); } 𝖼𝗈𝗇𝗇𝖾𝖼𝗍(𝗍𝗁𝗂𝗌: 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝗂𝗈𝗇<𝖣𝗂𝗌𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽>): 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝗂𝗈𝗇<𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽> { 𝗋𝖾𝗍𝗎𝗋𝗇 𝗇𝖾𝗐 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝗂𝗈𝗇({ 𝗌𝗍𝖺𝗍𝖾: '𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽' }); } 𝗌𝖾𝗇𝖽(𝗍𝗁𝗂𝗌: 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝗂𝗈𝗇<𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽>, 𝖽𝖺𝗍𝖺: 𝗌𝗍𝗋𝗂𝗇𝗀) { // 𝖢𝖺𝗇 𝗈𝗇𝗅𝗒 𝖼𝖺𝗅𝗅 𝗂𝖿 𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽 } } 𝖼𝗈𝗇𝗌𝗍 𝖼𝗈𝗇𝗇 = 𝖢𝗈𝗇𝗇𝖾𝖼𝗍𝗂𝗈𝗇.𝖼𝗋𝖾𝖺𝗍𝖾(); 𝖼𝗈𝗇𝗇.𝗌𝖾𝗇𝖽('𝗁𝖾𝗅𝗅𝗈'); // 𝖳𝗒𝗉𝖾 𝖾𝗋𝗋𝗈𝗋: 𝗇𝗈𝗍 𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽 𝖼𝗈𝗇𝗌𝗍 𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽 = 𝖼𝗈𝗇𝗇.𝖼𝗈𝗇𝗇𝖾𝖼𝗍(); 𝖼𝗈𝗇𝗇𝖾𝖼𝗍𝖾𝖽.𝗌𝖾𝗇𝖽('𝗁𝖾𝗅𝗅𝗈'); // 𝖮𝖪 ` Illegal states become unrepresentable. --- The mindset shift: Rust: Make invalid states impossible to represent TypeScript default: Let anything happen, hope for the best TypeScript with discipline: Make invalid states impossible to represent --- You don't need Rust to write correct code. You need Rust's mindset applied to whatever language you're using. Make errors explicit. Make invalid states unrepresentable. Make the compiler your ally. That's type safety. Not just slapping `: string` on everything.

Spring tiene una joya escondida que muchos ignoran: Spring Cache ⚡ Con una sola anotación (@ Cacheable) puedes hacer que los resultados de un método se guarden en memoria. Así la próxima vez que se invoque con los mismos parámetros, Spring devuelve el resultado directamente del caché sin volver a ejecutar la lógica. Veamos un ejemplo muy simple: @ Cacheable("users") public User findUser(Long id) { return userRepository.findById(id).orElseThrow(); } 💡 La primera vez, se ejecuta el método. La segunda, tercera, etc… La respuesta viene del cache. Lo interesante es que Spring Cache no es una implementación en sí, es una abstracción que puedes conectar con múltiples motores: - Caffeine: Rápido y en memoria (ideal para apps pequeñas o locales). - Redis: Distribuido, perfecto para entornos escalables. - Ehcache / Hazelcast: Opciones robustas para enterprise. También contamos con otras anotaciones que nos ayudan a controlar diferentes aspectos: @ CacheEvict: Limpia una entrada. @ CachePut: Actualiza sin invalidar. @ Caching: Combina varias reglas. 👀 La decisión clave es elegir bien que cachear y que no. No todo debe ir al cache: cachear datos dinámicos o con mucha rotación puede hacer más daño que bien.

Caching Brain Teaser 1 - @Cacheable Null Puzzle 🧩 '''java @Cacheable("users") public User findUser(String id) { return null; } ''' What happens? Does Spring cache null or call DB every time? 👉 Hint: We can change the settings.

Prøver et par Oberliga-finduser i dag: * Mechtersheim MÅ vinne i kampen for å (mulig) overleve og et ferdigspilt Eppeldorn som slipper inn nesten 3 i snitt og som er fryktelig svake borte skal slås hjemme til 2.45 i #odds.

Comparing Structured Concurrency approaches in #Java: JEP 505 (left) vs Jox (right). Both implement the same logic: run `findUser` and `fetchOrder` in parallel, and combine their results. Any failure interrupts the other tasks, and when they terminate, propagates the exception.

actual backdoor also more likely to be named something like setcolor or finduser