# Python, def,

and, as, assert, async, await, break, class, continue, del, elif, else, except,
finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or,
pass, raise, return, try, while, with, yield

False, True, None,
__name__, __init__, __str__, __file__, __dict__, 
list, int, str, print, 
__main__, 

# Rust, fn,

as, async, await, break, const, continue, crate, dyn, else, enum, extern,
false, for, if, impl, in, let, loop, match, mod, move, mut, pub, ref, return,
self, Self, static, struct, super, trait, true, type, unsafe, use, where,
while

## Rust future keywords:  
`abstract`, `become`, `do`, `final`, `override`, `priv`, `typeof`,  `unsized`. 

# Kotlin, fun,

as, break, class, continue, do, else, false, for, if, in, interface, is, null,
object, package, return, super, this, throw, true, try, typealias, val, var,
when, while

lateeint, inline, crossinline, Unit

The "val" vs "var" split: 
In Kotlin, you’ll notice `val` (read-only) and `var` (mutable) are hard keywords.

# Java, public static...,

abstract, assert, boolean, break, byte, case, catch, char, class, const,
continue, default, do, double, else, enum, extends, final, finally, float, for,
goto, if, implements, import, instanceof, int, interface, long, native, new,
package, private, protected, public, return, short, static, strictfp, super,
switch, synchronized, this, throw, throws, transient, try, void, volatile,
while

Java's "Ghost" Keywords:  `const` and `goto`, 


# Go, func,

break, case, chan, const, continue, default, defer, else, fallthrough, for,
func, go, goto, if, import, interface, map, package, range, return, select,
struct, switch, type, var

# Node / JS, function,

await, break, case, catch, class, const, continue, debugger, default, delete,
do, else, enum, export, extends, false, finally, for, function, if, import, in,
instanceof, new, null, return, super, switch, this, throw, true, try, typeof,
var, void, while, with, yield


# C (C11), No keyword as 'def, fun, fn, func', 

    return_type function_name(){//body}

auto, break, case, char, const, continue, default, do, double, else, enum,
extern, float, for, goto, if, inline, int, long, register, restrict, return,
short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void,
volatile, while, _Alignas, _Atomic, _Generic

# C++ (C++20), 

No keyword to define functions, same as C,

All C keywords plus: 
alignas, asm, bool, catch, class, concept, constexpr, const_cast, decltype,
delete, dynamic_cast, explicit, export, false, friend, mutable, namespace, new,
noexcept, operator, private, protected, public, reinterpret_cast, requires,
template, this, thread_local, throw, true, try, typeid, typename, using,
virtual


# bash, shell, function

if, then, elif, else, fi:  Used for conditional execution.
case, esac:  Used for multi-way branching based on patterns.
for, while, until:  Used to initiate different types of loops.
do, done:  Used to enclose the body of a loop.
select:  Used to generate menus for user input.
function:  Used to define a shell function.
time:  Used to report how long a command takes to execute.
coproc:  Used to create a coprocess for asynchronous communication.
in:  Used within for, case, and select constructs.
{ and }:  Used to group commands in the current shell environment.
[[ and ]]:  Used for advanced conditional expressions (superior to the [ builtin).
!:  Used for logical negation or history expansion depending on context.
|:  pipe

Sources
https://github.com/angular/clutz

Sources
https://github.com/google/apis-client-generator






Since your **TinyLlama** thinks it knows Python and Rust, 
you might want to test it by asking: *"Can I name a variable 'await' in Python?"* 
(The answer should be no!).

# Android OS kill process in developing

2026 Apr. 10

The "Silent Assassin" Strikes Again
When you see Unexpected EOF! 
followed by the process instantly restarting, it
means your app didn't just throw a normal Kotlin exception. 
It means the Android Linux kernel itself stepped in and 
ruthlessly assassinated your app so
fast that the logging daemon (logd) couldn't even finish writing the error
message to the console.

There are two main suspects for this on an older device like the MI 9:

The Low Memory Killer (LMK): The MI 9 is fighting for its life. When you hit
"Chat", the C++ engine tries to load hundreds of megabytes of neural network
weights into active RAM. If the phone doesn't have enough free RAM at that
exact millisecond, Android's LMK panics and kills your app to keep the phone
from freezing.

A Native Segfault (SIGSEGV): 
As we discussed last night, if the engine tries to
read the sm8550 model on your MI 9's CPU, 
the C++ code hits an illegal hardware
instruction and instantly implodes.


# Hello World for many programming languages.

## Rust

fn main(){
    println!("hello world.")
}

    $ rustc hello-world.rs
    $ hello-world

    $ cargo new hello_world
    $ cd hello_world
    $ cargo build
    $ ./target/debug/hello_world

    $ cargo run # check, test, doc

## C

    file hello.c
    #include <stdio.h>
    int main(){
        printf("hello world.\n");
        return 0
    }

    $ gcc hello.c -o hello
    $ ./hello


## C++

    /* file hello.cpp */
    #include <iostream>

    int main() {
        std::cout << "Hello, World!" << std::endl;
        return 0;
    }

    $ g++ hello.c -o hello
    $ ./hello