43 days ago I asked this question:

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

This question got voted down everywhere I discussed it on Hacker News, but somehow the submission itself got 11 points. Apparently, it is an offensive question to some silent, pro-censorship part of the population here. Today I'll ask it again, and I hope somebody will respond in a useful way:

QUESTION:

I write software for parallel processors at a hardware/software company you've heard of. I am located in California but many of my coworkers are located in China (roughly half the team).

We are directly affected by the American government's severe new CPU/GPU export restrictions.

It seems to me that America is preparing for a period of cold war, or worse.

It's time to start thinking about contributing to the American war effort by writing high-performance military computing systems.

For example, SIMD particle filters for hypersonic weapons, or low-latency convolutional neural networks for battlefield devices.

So, Hacker News: What company is the best place to do this work? What team?

Does anyone here already work in this field?

If you can tolerate a .gov email address, there are high-performance computing, edge computing, and AI groups at DOE labs. My impression is that they're always starved for talent in these areas due to stiff competition from industry and lifestyle restrictions that come with a security clearance (being a US citizen, reduced international travel, no drugs other than alcohol and nicotine, your work may require on-site). Defense labs are probably similar.

Look at the Green Arrays F18, the "conclusion" that Forth reached:

https://www.greenarraychips.com/home/documents/greg/PB003-11...

Here's a clear description of what each instruction does:

https://colorforth.github.io/forth.html

Hilariously, the system has no logical OR, only AND and XOR and NOT, because "Inclusive-or is rarely needed."

This system was designed by Chuck Moore, father of Forth. Here is an entertaining video of him explaining the F18A stack machine and programming system:

https://youtu.be/0PclgBd6_Zs

This is such a simple machine. I am planning to make a tiny emulator for my site. One could probably write an emulator in 80 lines of Go (one goroutine for each of the 144 cores).

>The word */ multiplies by a ratio, with a double-length intermediate product. It eliminates the need for floating-point.

Anyone who knows a lot about numeric stuff care to comment on this statement?

It's just a fixed point instruction.

Fixed point multiply: a*m times b*m yields (a*b)*m = a*m * b*m / m

In the above, m is the fixed point 1. For example, 65536 for a 16.16 fixed point.

The instruction allows you to multiply a*m by b*m and then divide by m, renormalizing your fixed point result.

Chuck Moore thinks nobody needs floating point because fixed point is sufficient!

And, importantly, the double-length intermediate result prevents the rapid loss of precision, compared to the naive alternatives of

  : */ * 65536 / :

and

  : */ 65536 / * ;

This is based on Russ Cox's essay:

https://research.swtch.com/gorace

The code in Russ Cox's article does not race with the modern Go compiler.

But it's simple to fix that. Given arbitrary memory access within a Go process under Linux, can you see how to terminate the process and return 0 to the system?

Like calling os.Exit(0) when package os is unavailable.

This is based on Russ Cox's essay:

https://research.swtch.com/gorace

But, the code in Russ Cox's article does not race with the modern Go compiler.

A really tremendous varint/VLQ encoder (using a zig-zag encoding and an generalized base):

https://bugfix-66.com/2c1df73cab89ec76d6fa10caf8a27c1fbe4d16...

and the decoder:

https://bugfix-66.com/1efa93a5eb0cc12b3de7cd1dab8e471a2cc95e...

The common varint, which you see in applications everywhere (e.g., git), is just base-128 version of the above general scheme!

But base-32 or base-8 or base-64 varints can be a big win for some purposes. Remove the zig-zag encoding if negative integers don't occur.

A more challenging code puzzle game: https://BUGFIX-66.com

Thank you. Could you paste the Humans Only Clause here so we can read it?

Here was my attempt to write a clause prohibiting language model training/inference:

https://bugfix-66.com/7a82559a13b39c7fa404320c14f47ce0c304fa...

  3. Use in source or binary form for the construction or operation
     of predictive software generation systems is prohibited.

How does the Humans Only Clause fix the flaws in my attempt?

The Humans Only Clause adds an explicit licensing fee, and what else?

How is the clause worded?

"Use of the Software by any person to train, teach, prompt, populate, or otherwise further or facilitate any so-called generative artificial intelligence, generative algorithm, generative adversarial network, generative model, or similar or related activity (or to attempt to perform any of the foregoing acts or activity), whether in connection with any so-called machine learning, deep learning, neural network, or similar or related framework, system, or model or otherwise, is strictly prohibited and beyond the limited scope of this license, absent prior payment to licensor of the licensing fee of the amount of ____"

This seems to prohibit benign activities like importing the code into an IDE that contains auto-complete.

A necessary evil. You point out a cost. The benefits outweigh that cost.

That clause appears to violate Item #6 of the OSI's open source definition:

> The license must not restrict anyone from making use of the program in a specific field of endeavor. For example, it may not restrict the program from being used in a business, or from being used for genetic research.

It also seems to violate freedom 0 of the FSF's four essential freedoms that define free software:

> The freedom to run the program as you wish, for any purpose (freedom 0).

I'm not sure this can be used by open source projects if they want to remain open source projects.

Thank you. I see the Humans Only Clause is much more explicit about what is prohibited than the No-AI 3-Clause License, and furthermore directly states a licensing fee.

That wouldn't license code. That's just license text that happens to be in a string. Not sure why this bugfix site is being used instead of just pastebin with text.

I'm presenting the license text in a creative and unusual way that real hackers might enjoy.

If that confused you, or you consider it "obnoxious", then you are not the target audience.

That's ok. Hacker News is not 100% hackers!

I think it is more likely you are just baldly shilling your website. Which is a shame, because I think the site isn't a bad idea - I like the minimal interface and the thought you've put into hints for many not-quite-right solutions. I've seen quality links you've posted in the past with more interesting, subtle, and relevant bugs - but this isn't one of them.

I have a different Hacker News account for every one of my projects. It happens that the No-AI 3-Clause License became part of the BUGFIX-66 project. I'm sorry that upsets you, but I'm sure you'll get over it. Happy Thanksgiving.

It's more obnoxious than creative and unusual

This is a "broadword matrix multiplication" as described in Knuth's The Art of Computer Programming Volume 4A (exercise 55 in section 7.1.3).

Here is a lecture where Knuth explains it:

https://youtu.be/o22BAuQj3ds?t=1h20s

It's efficient for 64-bit registers, but even larger registers could be used in the same way.

There are also interesting computational possibilities, like the broadword matrix multiplication algorithm that Knuth presents in The Art of Computer Programming Volume 4A:

https://bugfix-66.com/2d447332bf8f8c67348d520c6508b2cc7d3204...

The basic idea is that "smart memories" can be used to do make the multiplication very local and parallel.

The above code spreads matrices out within 64-bit registers, but you could generalize this to huge, multi-megabyte registers.

So memoisation and caching?