Oh nice! I’ll have to dig into that. Wonder if its an implementation issue across vendors. I was always under the impression that DHCPv6 was the common convention if not static.

Ok. So a device didn’t get a dhcp address? No problem… It creates it’s open IP address and starts talking and try to get out on internet on its own…

Its not that different from a conceptual point of view. Your router is still the gate keeper.

Home router to ISP will usually use DHCPv6 to get a prefix. Sizes vary by ISP but its usually like a /64. This is done with Prefix Delegation.

Client to Home Router will use either SLACC, DHCPv6, or both.

SLACC uses ICMPv6 where the client asks for the prefix (Router Solicitation) and the router advertises the prefix (Router Advertisement) and the client picks an address in it. There is some duplication protection for clients picking the same IP, but its nothing you have to configure. Conceptually its not that different from DHCP Request/Offer. The clients cannot just get to the internet on their own.

SLACC doesn’t support sending stuff like DNS servers. So DHCPv6 may still be used to get that information, but not an assigned IP.

Just DHCPv6 can also be used, but SLACC has the feature of being stateless. No leases or anything.

The only other nuance worth calling out is interfaces will pick a link local address so it can talk to the devices its directly connected to over layer 3 instead of just layer 2. This is no different than configuring 169.254.1.10/31 on one side and 169.254.1.11/31 on the other. These are not routed, its just for two connected devices to send packets to each other. This with Neighbor Discovery fills the role of ARP.

There is a whole bunch more to IPv6, but for a typical home network these analogies pretty much cover what you’d use.

I’m coming from a Haskell/Scala background. This job just pays more. TS has been “good enough” for types. I don’t think I could be as effective without them at this point.

I don’t see it dying from my perspective. Its only been getting better and better. The only thing I could see displacing it in my org is maybe Rust due to WASM proving a transition path.

We use TS on the back end to leverage our teams existing skill set and libraries we’ve built up.

I know it’s a meme to use “the next best thing” in the ecosystem, but we’ve been really happy with the newish Effect library + Bun runtime. Effect is like a merger of the older fp-ts/io-ts libraries (same author works on both) with Zio from the Scala ecosystem. It vastly simplifies the former and the new stuff with dependency injection and defect management is refreshing. With the Bun runtime, we see a 15x faster startup time (great for dev). Its halved the RAM requirements in prod. We don’t even need to transpile… We still do for prod to tree-shake dev-only code to ensure its not available in prod, but deploying to dev is FAST.

https://www.openwall.com/lists/oss-security/2024/03/29/4

Never used ic before, but there is an example in the README on GitHub.

>>> import logging
>>> from icecream import ic
>>>
>>> def warn(s):
>>>     logging.warning(s)
>>>
>>> ic.configureOutput(outputFunction=warn)
>>> ic('eep')
WARNING:root:ic| 'eep': 'eep'

If you are interested in pushing more, there are other JVM languages.

Scala was my first functional programming language after doing Java -> Groovy -> Scala. All 3 can access the entire Java ecosystem and are compatible with each other. Scala is like having Generics for your Generics (Higher Kinded Types).

Motivation is one hell of a teacher.

Plus DNS caching… I do DOT or DOH (forget which, setup years ago) from my router’s local DNS server without any noticeable latency.

Agree. What I linked provides core type support for that library. The pipe one is just a bunch of overloads to support a specific way of handling function composition to appease the TypeScript type checker.

There are a lot of typing hacks in that library to simulate higher kinded types.

Not OP, and these examples are not unreadable, but they are a few steps up from your typical generics.

https://effect-ts.github.io/effect/effect/Unify.ts.html#unify

https://effect-ts.github.io/effect/effect/Pipeable.ts.html

Strings are just a pain… Common solution is a runtime guard or doc comment. Can maybe try an overload and annotate a string param with NoReturn and an @throws doc comment.

Been awhile since doing python, but even that might not work since string satisfies both overloads. I recall having issues with unions where types were not discrete. I may have solved by ordering the overloads differently so string is considered first, but again, its been awhile.

https://stackoverflow.com/questions/44912374/python-type-annotation-for-sequences-of-strings-but-not-for-strings

Look at the official docs. There is a table part way down stating which methods are available for each. I pick the one closest to how I use it. So if I’m not mutating I’ll use Sequence over List to inform the caller I’m treating as immutable and to safe guard myself from mutating it in my implementation via static type analysis.

https://docs.python.org/3/library/collections.abc.html

KDX as a concept actually had a “predecessor”, Hotline, that was one of the best Mac OS warez scenes in its prime.

https://en.m.wikipedia.org/wiki/Hotline_Communications

Eslint rules and prettier. I use the AirBnB ruleset as a base close to my personal preferences and then customize to my liking.

I don’t really have to do any manual formatting. I just save to apply the formatting.

edit: javascript

“You smelled it you dealt it” kept everyone quite when I was in school so long as there is plausible deniability for the source.

I’m often seen as calm even though I have my frustrated outbursts. The one thing I make sure to do is not direct that frustration towards other living things.

As you mentioned in the dog analogy, I’ll outwardly vocalize what I could have done to avoid the situation and own the blame. I have a couple dogs as well. If I’m upset enough that I notice a change in their behavior I’ll play with them to show its okay. Now that I think about it, they started bringing me toys when I’m upset which has a calming effect on its own.

I want other people witnessing my tantrum to understand I’m frustrated with myself. There is always something I could have done to improve/avoid the situation. On the rare occasion I’m unable to self regulate I’ll remove myself and take time to reflect. Sometimes it takes a night of sleep.

I’ve lived with a number of narcissistic and borderline personality types throughout my life. Seeing and experiencing the damage one can do with anger, I’ve made it a core principal to never project my own shortcomings onto another living thing.

For situations where one could not have done anything, I’ll resort to assertiveness principals if I’m not okay with another’s behavior or accept the the situation and go into “fix it” mode to mitigate what’s in my control.

Key point I suppose is to remove anger, shaming, eluded ignorance, and other forms of manipulative behaviors as a means to control others and to see every frustration as a test of my principals.

That’s one of the things I appreciate in a language/framework. Drives me nuts getting an exception from a dependency of a dependency of a dependency.

Even better if its baked into the type system and I can’t run my code without handling it.

import gravity; gravity = None

edit: of course there is an xkcd: https://xkcd.com/353/.

Yes. As of this writing there are 7,738 type definitions in a central repo maintained by users for plain JavaScript packages.

https://github.com/DefinitelyTyped/DefinitelyTyped

Many package owners write type definitions included with their package that is written in JavaScript also.