candl

I run some Huawei networking equipment under VRP OS (switches, OLTs). CLI is almost identical to iOS, but commands have alternative naming (e.g. show -> display, but many more such instances wherever possible - often times I prefer the naming in VRP). Apparently even the first editions of VRP documentation had parts citing cisco verbatim or had references to cisco docs. Rumors say its origins are stolen iOS source code at some point in the past via corporate espionage. The irony of this is that this cisco codebase has been rewritten at least once by the chinese before LLMs ;).

The first programming language I learned almost two decades ago was Ruby, later when I explored Smalltalk which gained some popularity due to Seaside I couldn't believe how much cleaner and easier the syntax was. However the image model is a tough pill to swallow and I never wrapped my head around it despite it being the selling point for those that can take advantage of it. I also never liked that the GUI is it's own thing and always felt foreign to the system I was running on. In the past there was some headless version with some minor syntax extensions I think called Coral? which could be used ordinarily from the shell like other scripting languages but I don't know if it's still a thing and it always surprised me this path wasn't explored or pushed further to make it more popular/approachable.

As a small WISP operating within the RIPE region, Are there ways to obtain usable IPv6 address space for customer connectivity (to provide e.g. /56 to customer CPEs) without becoming a LIR and paying the associated fees (Which frankly are unfair considering that companies that hold millions of ipv4 addresses pay the same amount... but that's another topic)? I currently own a single IPv4 PI /24 prefix, but I am not a LIR.

What are the pros and cons compared to ASP.Net/Blazor?

Who or what is going to fund your retirement pension? Who or what is going to look after you when your health deteriorates?

Are there any coding plans for this? (aka no token limit, just api call limit). Recently my account failed to be billed for GLM on z.ai and my subscription expired because of this... the pricing for GLM went through the roof in recent months, though...

What providers offer nowadays coding plans, so no pricing per tokens, just api call limit and a monthly fee. Which are affordable?

I bought a glm-4.7 subscription and paired it with with claude code. According to usage, I have already used millions of tokens, yet I have barely reached the prompt limits for the tier I have per the 5 hour window. I haven't done anything crazy with my prompts as well. Now if this were something else billed per 1 million tokens it would have cost me a lot more. Yet apparently the majority of LLM providers are billing for 1 million tokens. What's the catch? What I am not understanding? What other providers have similar usage/pricing pattern? I can't see any of the providers billing per 1 million tokens to be useful/cost effective at all for coding. Granted, I am new to all of this, I want to see what the fuss is about so perhaps I am blind to something obvious.

The only medical condition I can think of which they would not disclose is pregnancy. That would lead to further questions and is controversial despite being very simple. Further evidenced by the fact that the affected crew member is unknown to the public.

What features have you used for shaping with pf/FreeBSD? I remember (around 8ish years ago) using dummynet with pf, but it wasn't supported out of the box and I used some patches from the mailing lists for this purpose. It wasn't perfect, at times buggy. Back then ipfw had better support for such features, but I didn't like the syntax just as much as iptables. I eventually settled on Linux as I have grown to understand iptables (I hate that nftables is the brand new thing with entirely different syntax to learn again... and even requires more work upfront because basic chains are not preconfigured...) but traffic shaping sucked big time on linux, I never understood the tc tool to be effective, it's just too arcane. I always admired pf, especially on OpenBSD since it had more features but the single threaded nature killed it for any serious usage for me.

I learned some Gleam a while ago, my familarity with F# helped, but I didn't find a use case for it. Some while ago I wanted to play with raw sockets so I figured, why not Gleam, its binary parsing syntax will be handy so I looked into the erlang sockets module and attempted to write some ffi wrappers for the necessary functions. Turns out it is not as straight forward, especially that the definitions on erlang side are often complex, with many variants and the dynamic nature doesn't often map very well to Gleam. The documentation was also quite sparse for interop. Interop also involves a lot of Dynamic types so encoding/decoding back which is cumbersome. Sooner or later I hit a wall. By virtue of reading Erlang docs to write the ffi wrappers I eventually got familiar with Erlang syntax which at first was quite alien, but turns out it is rather simple with just some rules to remember. I settled on writing Erlang directly. I am not sure how Elixir compares, never tried it, but I was initially put off by the syntax resembling Ruby, which I have fond memories of, but was always very implicit which I didn't like. Writing pure gleam is pretty fun, but a lot of interesting things require either ffi interop or decoders/encoders even for simple things like json which takes away some of that fun.

Wish it had a tab component.

Not DOS, but I remember playing a copy of Settlers III and was surprised when iron smelters produced pigs instead of iron.

Should one use the result type for handling errors or exceptions or both? What's the rule in F#?

When should you prefer immutability over mutability since both are possible in F# and it probably has a measurable impact on performance?

When should you use objects instead of records or unions in F#?

Since mutability is possible, any reason to not allow an explicit return or continue? It makes certain code patterns much less nested and easier to read.