…or a high number to brag!

I'm also still searching. If anyone is looking to part with a ticket, feel free to send me an offen. Contact is in my profile

Models trained on Google TPUs according to Reuters [0]. Does anyone know the "technical document" the news article references?

[0] https://www.reuters.com/technology/artificial-intelligence/h...

Alternative upload for [2] on Youtube https://youtu.be/5TosI6r-5_o

You can also construct programs in Turing complete languages to always halt (e.g. by bounding the number of iterations of all loops, usually with the tradeoff of limited input size).

Yes, you can program in a subset of your language that is not Turing complete.

You'd also need to forbid (even indirect) recursion, i. e. one function cannot appear in a callstack twice.

Isn't that overly restrictive? Some programs are guaranteed to terminate even with mutual recursion.

For example, these (obviously inefficient) functions always terminate for all values of x, since both terminate given an input of 0, and 0 is the minimum possible input to these functions.

  bool even(unsigned int x)
  {
    return (n == 0) ? true : odd(n - 1);
  }

  bool odd(unsigned int x)
  {
    return (n == 0) ? false : even(n - 1);
  }

The point of these restrictions is that you can formally verify that a given program will terminate in a way which can be checked by e.g. a compiler or some other kind of checker.

While statically verifying your snippet is possible, it is also significantly more difficult to do than enforcing rules like "all loops must have an upper limit". I also think that you'd need dependent types to make this approach viable. Your simple example is IMHO rather an exception, just having "unsigned int" parameters / return types would mostly not suffice to statically verify that a recursive method will finish or not. (plus things like global state etc.)

A language with your suggested restriction (and a few more) might be possible.

But it's not the only way to get a total language (that always halts), contrary to what your original comment claims.

Agda doesn't need that restriction, as far as I know. And neither does Dhall. See https://dhall-lang.org/

Neither language is Turing complete.

But then reaching it will mean a crash. I could use a similar approach to say that any program will terminate if I set a fixed time (instruction count) limit.

Yes — that’s correct.

Programs with a fixed amount of execution time always terminate. That’s why we add timeouts to executions, because they’re a solution to the halting problem, which guarantees execution flow of our machines always returns at some point.

Surprised to find 0 mentions of state machines, which they seem to have rediscovered, in this article.

Reach out to other contractors who you’ve worked with directly (e.g. worked on the same project at a former employer) and valued/praised your work.

…or they might have determined that they‘d rather spend their time on something else.

Keeping control is a (mostly time) commitment and liability. You have to stay on top of things and actively decide on issues that inadvertently come up.

Chrome Dev Tools has had that feature (for css specifically, not transpiled languages) for years. https://developer.chrome.com/docs/devtools/workspaces/

We used to have full WYSIWYG editors in browsers as far back as the 90s (including deployment via FTP). Specialized editors just seem to have always been the preference for developers.

Workaround for anyone struggling with this: Use the Import feature from the Files menu instead of the usual Open dialog for csv files. You can change decimal separators in the import wizard.