oso2k

Sometimes I wish we could get to a timeline where the FPU format standards have something like Crockford’s DEC64 end up winning or evolving into the prevailing standard. Simpler & consistent math ought not to be this hard.

https://www.crockford.com/dec64.html

What happened to the 12ft.io project?

Tbh, for the ESP32-C3’s perf, an allow list would likely save RAM and CPU time.

Not just single core perf though. Very efficient idle TDP, efficient all core boost, efficient all core TDP, and efficient mid-high performance tier accelerator (GPU, NPU) TDP.

You can get an updated gmake via brew.

https://formulae.brew.sh/formula/make

This follows Rob Pike’s 5 Rules for Programming

https://web.archive.org/web/20250201145327/https://users.ece...

Right. Floci got posted yesterday here on HN.

https://news.ycombinator.com/item?id=49854416

Has this allegation been substantiated?

The person in the forum thread claimed to be repairing CM5s and CM4s. Unusual but it seems like an otherwise hyper reactive response by the RPi Foundation. Something you wouldn’t batt an eye at if it were Apple instead.

It’s interesting that the author lands on an API much like the function signature for TAP (Test Anything Protocol).

   ok( conditional, message );

https://testanything.org/

Sadly, I think things like distcc or ccache have mostly gone out of mode. Vertically scaling (multi core, multi thread, multi TB RAM build machines) and simple artifact caching have won for now. Artifact caching with dependency tracking in the midst of job scheduling was solved “good enough” by OS based mechanisms. Having used and managed the basics of a build farm, removing the need for networking, build farm management and build job coordination is a huge burden relief when your source tree doesn’t require it.

Part of the motivation to use processes is because their structure helps to keep the job generic, uni

I was not impressed by author’s surprise that original emulation ran at 1/10th speed. For the past 50 years, that’s usually the target for calling (“unaccelerated”) emulation good enough. Especially for architectures that are current or in development or otherwise require some sort of instruction translation.

The last 30 years we’ve seen innovations like dynamic recompilation, fat binaries, JIT VMs, and profile guided optimization. So that has created an expectation of sub-order of magnitude run time performance. It’s a fanciful time we live in.

My favorite trick with this feature is pairing it a timeout

   # Connection successful:
   $ timeout 1 bash -c 'cat < /dev/null > /dev/tcp/google.com/80'
   $ echo $?
   0

There is also git-bash which usually doesn’t need to have administrator to be installed.

https://git-scm.com/install/windows

Thanks for finding this!

I have one those Librex as well. It was fun to play with when it came into my hands back in 1997.

I agree. It's also the evil that created the need and improvements like SSL/TLS, ssh, gzip, bzip2, lz4, Linux, etc. and so many other worthwhile innovations.

I'd presume we're almost all using the Web primarily on some employer's dime (except where we are self-employed but it still applies). Prior to the Web 1.0, I remember interacting with people/managers that discouraged reading email or news or forums or other casual/non-work uses of the Web. I remember articles about employers allowing their programmers to read their email "up to" 2 hours per day. Now we're expected to have rapid response/access to email, slack, SMS, etc.

I believe this is because the commercialization/monetization of Web usage is beneficial to commercial entities. If that isn't possible, then the few who build the Web aren't able to build it in the first place. It's akin OSS and concepts of commercialization in the GPL. You can't create equity if there is no method to transfer value.

Flash succeeding is subjective. There were many who were hostile to Flash (and Java) for a long time. I actively disabled the Flash plugin except when necessary.

HTML not passing the criteria doesn't negate it from being the current leading technology. All it indicates is that there could be a technology that does more (most) of these things better. And, it sets a certain benchmark for the next technology to aspire to.

I think accepting input from anyone is a resiliency feature. Imagine if only Governments drove the Web? Or Multi-national Megacorps? Billionaires? Choice and freedom helps to democratize and enable usage by participants who are diadvantaged.

Content-neutrality is experiential. That is to say, gopher is well known to be more organizationally efficient at transimitting data than http. However, it was primarily aimed at text transmission and was very poor at supporting applications (like banking, commerce sites or email). These were huge boons to the current Web.

I think we could learn from an old (gone?!) Google+ post from Ian Hickson on what could possibly replace HTML but a lot of the criteria applies to Web/Internet as a whole (https://www.sitepoint.com/will-html-ever-be-replaced/).

   Ian Hickson (“Hixie” — WHATWG specification editor, CSS2.1 co-editor and Google’s W3C representative) recently published an interesting post on Google+. He’s occasionally contacted by people suggesting a better alternative to HTML but, in all cases, none have come close. Ian states that any technology would need to satisfy at least five objectives to displace existing web technologies:

   Be devoid of licensing requirements.
   Be vendor-neutral and accept input from everyone.
   Be device and media-neutral; it should work on PCs, TVs, mobiles, tablets, screen readers and any future hardware.
   Be content-neutral and not restrict itself to types of document or application.
   Be radically better than the existing web in every way; faster, more usable, more features, easier to develop, easier to monetize, etc.


   HTML can fail objectives two and three. Technologies such as XHTML2 and XForms only satisfied one and three. Java and Flash struggle in all areas — and I’d also add Google’s Dart to that list.

Maybe this all means there’s a place on the net for gopher, Gemini protocol, or tilde.town or ssh BBSes?

I remember way back when, there were ports of SDL 1.x to djgpp. Glad to see someone still cares.

I say this as someone who likes and use TinyCoreLinux and PiCore, there are some mind numbing ways TCL makes immutability work. I chalk this up to Linux and immutability being sometimes in contention with each other. Lots of Linux code make assumptions paths being writable.

This looks interesting. Thanks for sharing.

I had the same inclination back in the 90s when I upgraded my Cyrix 486 SLC2 50MHz without a heat sink (which seems like a no-no in retrospect) to Cyrix MediaGX 133MHz. The stocker fan was immediately noticeable. I thought I had done something wrong.

There’s several other (well) known examples of the use of mujs.

There’s Artifex’s interpreter from muPDF. It’s also the basis of several JS related projects: https://mujs.com/

There’s also a lesser known interpreter: https://github.com/ccxvii/mujs

And IIRC, there was a CommonJS library of the same name.

Maybe you’re misremembering or referring to Doom (2016). The original Doom was developed for DOS and id had to build a lot of its own network stack. BSD style socket based networking wasn’t a given in DOS.

Still, zclaw is an impressive achievement.

   I don't feel like RedHat had to do anything to sell support contracts in this case, because that was already their business. All they had to do was say they'll include container support as part of their contracts.

Correct. Maybe starting with RHEL7, Red Hat took the stance that “containers are Linux”. Supporting Docker in RHEL7 was built-in as soon as we added it to ‘rhel-7-server-extras-rpms’ repo. The containers were supported as “customer workloads” while we docker daemon and cli were supported as part of the OS.

   What they did do, AIUI based on feedback in the oss docker repos, is those contracts stipulated that you must run RHEL in the container and the host, and use systemd in the container in order to be "in support". So that's kind of a self-feeding thing.

Not quite right. RHEL containers (and now UBI containers) are only supported when they run on RHEL OS hosts or RHEL CoreOS hosts as part of an OpenShift cluster. systemd did not work (well?) in containers for a while and has not been ever a requirement. There’s several reasons for this RHEL containers on RHEL/RHCOS requirement. For one, RHEL/UBI containers inherit their subscription information from their host. This is much like how RHEL VMs can inherit their subscription if you have virtualization host-based subscriptions. If containers weren’t tied to their host, then by convention, each container would need to subscribe to Red Hat on instantiation and would consume a Red Hat subscription instance.

https://access.redhat.com/articles/2726611

I think STL was the intent.

On aliexpress, there’s Pi Pico Dev dev boards featuring the RP2350 in the Pi Zero form factor.

https://www.aliexpress.us/item/3256807163052616.html

Yes. 486 with 26MB for MicroCore (cli) or 46MB for TinyCore (gui).

https://en.wikipedia.org/wiki/Tiny_Core_Linux#System_require...

VGA color palette was 18-bits/256K, but input into the palette was 8-bit per channel. (63,63,63) is visibly different from (255,255,255).

http://qzx.com/pc-gpe/tut2.txt

http://qzx.com/pc-gpe/