s-p-n

I thought the RTX would do better here, but the Ryzen 3750h performs better on training a model in tensorflow. I'm using this guide to get things going, and I'm usng tf-nightly with Ubuntu 20.04.

https://www.tensorflow.org/tutorials/quickstart/beginner

I'm wondering if using nvidia 440 drivers is the reason? I also have 3 versions of CUDA installed (10.0, 10.1, and 10.2). The tensorflow-js test I did uses CUDA 10.0, and the Ryzen performs roughly 50% faster. The Python test I did uses CUDA 10.1, and the CPU is less than 10% faster.

Even so, shouldn't the GPU perform an order of magnitude better here? I feel like I must be doing something wrong :/

I'm playing around making a language.

I'm a firm believer that recursion is good, but there's a lot going in in `let foo = () => foo;`.

First, I think `let foo` is interpreted, and `foo` is immediately hoisted, as it will be defined.

Second, the value of foo is known to be a function.

That function code isn't evaluated at all, and here's where I have several thoughts going through my head.

I was wondering, at compile-time, should a language bother checking identifiers? I don't particularly like hoisting and think values should be evaluated before declaration begins to take place. I've always liked recursion, but at the moment I thought: "if I want to do recursion, I shouldn't implement any id-validity checking in functions."

Let's say, let bar = () => foo(); (function() { window.foo = () => console.log("hi"); }()); bar(); // console logs "hi"

So, at compile-time it seems complicated to check for the existence of "foo" in the function "bar". I mean- sure, it's possible- but it seems like a losing battle for a compiler to chase identifiers all around the program, simply to check if they will exist when they are needed.

So I suppose one solution is to just let undefined identifiers slide unchecked until runtime. Another solution is to check as much as possible, unless or until the existence of an identifier could potentially come to being during input.

For example, the compiler could see that an array of links in a search-robot might be built after visiting a url that has n links. Perhaps a function is generated for each link, so the compiler might see `links[i].visit()` and think, "Well, that function 'visit' isn't ever created, but links is an object populated by a resource, and maybe that resource provides the necessary API at runtime to make ..visit() defined." Designing a compiler like that seems.. not simple.

So ya, idk. Thoughts?