Actually, you could comfortably reach quite a lot of points in the universe in your lifetime, provided you'd have a free constant thrust engine. This one not, because it's out of our light cone.
Posting under one of my "bad" accounts here - we're searching for front-end developers like crazy, but only if they are "not just frontend", but also UX.
If you don't over-promise your abilities and are up-to-par with agentic coding, you'd fare well (provided an entry-level position exists) in at least one large-ish company I know of.
Benchmark Results
Model Sample Set (20q) Full Set (222q)
Claude 4.6 (baseline) 0.0% Available to researchers
Triad Engine 100.0% Available to researchers
I'm not sure this looks credible. 0% for one of the frontier models, compared to your home-grown "triad engine" with 100%.
Type theory absolutely can enhance imperative languages! In fact, we're seeing this happen:
Rust is the prime example - it uses affine types (linear logic) to track ownership and borrowing in imperative code. The type system prevents memory safety bugs at compile time without garbage collection.
C++ concepts (C++20) bring dependent typing to template metaprogramming. You can express "this function works for any type T that satisfies these type-level constraints."
Refinement types in languages like Dafny let you encode invariants directly in the type system for imperative code: int{x | x > 0} for positive integers.
The challenge isn't technical compatibility - it's that imperative programming often emphasizes mutation and side effects, while type theory shines at reasoning about pure transformations. But when you can encode the "shape" of your mutations in types (like Rust's ownership), you get incredible safety guarantees.
The real question might be: why don't more imperative languages adopt these ideas? Legacy compatibility and learning curves are probably the main barriers.