krzysz00

This does seem to align decently well with, for example, the policy the LLVM project recently adopted https://llvm.org/docs/AIToolPolicy.html , which allows for AI but requires a human in the loop that understands the code and allows for fast closure of "extractive" PRs that are mainly a timesink for reviewers where the author doesn't seem to be quite sure what's going on.

Location: Seattle Remote: Yes Willing to relocate: To major cities on suburbs with good non-car commute options (that is, not Mountain View)

Technologies: Much of my recent experience is in Rust, but I've worked in several languages and have broad systems experience. So also Python, C++, program synthesis (including Z3), and more on the resume, Erlang, and so on.

I'm Krzysztof. I'm indefinitely pausing/dropping out of a PhD in program synthesis with my Master's, having realized I want to work on something more applied and that the structure of a PhD may not be for me. I'm overall looking for interesting work that's generally backend-focused. While much of my recent work has been on high-performance code generation, I'm actively open to expending out into roles like reliability engineering, infrastructure, and so on.

Resume: https://kdrewniak.com/resume.pdf

Email: [email protected]

There's also [libflame](https://github.com/flame/libflame) by the same group, which is a higher-level API for matrix computations. The library's API si such that you can derive an algorithm (along with its proof of correctness) on paper and then translate the notation of the proof directly into code.

You can find some more {complex, idiomatic, not terribly hacked together} Rust kernels at https://github.com/thepowersgang/ .

I'm not sure what you're getting at. More of what?

My current approach to the heap problem (I'm working on a toy Rust kernel) is to compile the allocator portions of the standard library (liballoc) with a configuration flag that makes them use a particular set of external functions as the low-level heap allocation machinery. Then, my kernel provides these functions, and all the nice stuff (Box, Vec, etc.) "just works".

IF you're curious, the relevant code is at https://github.com/krzysz00/rust-kernel/blob/master/kernel/m... . The functions that start with "rust_" are the allocator interface

I guess one interpretation of Erlang's = (this is from someone rather new to the language) is "Make the thing on the left equal to the thing on the right without mutating existing variables. If that's impossible, error". That nicely accounts for the apparent dual nature of the = operator.

Well, every base has issues with non-termination. In base 10, we have problems like 1/3 = 0.33333... . Base 2 has its own set of non-terminating decimal expansions, including 1 / 3 = 0.01010101... and 1 / 10 = 0.0001100110011... . Since we only have finite storage space, we have to cut the repeating string of digits off somewhere, no matter what base we're in. This can cause rounding issues.

You can't dodge all your rounding problems by changing base. There are binary-coded decimal (BCD) systems that store numbers as strings of decimal digits. You can generally find these in calculators (ever notice that a TI-84 overflows after 9.(9)e99) or some financial software. However, you'll still have problems like the 0.1 * 0.2 issue in binary floating-point. For example (assuming shorter-than-usual numbers):

2/3 = 0.66... ~ 0.66667

2/3 + 2/3 ~ 0.66667 + 0.66667 = 1.33334

However, 4/3 = 1.33333... ~ 1.33333, which isn't the same result.

Basically, you can't get away from this problem, you can only push it around to cases you care less about.

(You probably can't find an API for binary-coded decimal in $LANGUAGE unless $LANGUAGE is often used for tasks where you really really don't want any float-related gotchas since most everyone else doesn't care too much).

If by "decimal numbers" you mean the reals written in base 10, how do you propose we precisely represent the result of 1 / 3 . Or pi?

The feature is rather useful for record-keeping purposes (also known as CYA).

As this comment's uncle pointed out, you can probably find a "fill in the blank" DMCA notice somewhere on the net.

If that doesn't work, many lawyers give free consultations (AFAIK), and there's probably someone willing to take the case in exchange for X% of the settlement.

Could you use a DMCA-like thing to get them to stop doing that?

You probably need a font that covers the relevant ligatures. Does "fi" display for you? That's the Unicode codepoint U+FB01.

How do you change your negative sign on a unixoid? The only reference to negative signs in locale(5) is under LC_MONETARY.

I'm pull request #36.

Not too difficult in Common Lisp (the parser is fully exposed to user code, so I just changed the meaning of "g").

I also got accepted to work on Unicode support in SBCL!

The reverse, I think.

Not to drag the thread off topic, but this seems like the kind of situation where a version of Haskell's Maybe or Either monads might come in handy, so you could write:

    do
      command1
      command2
      ...

and have the failures propagate automatically.

Disabling zoom is also not good for visually impaired users and other people who need things to be bigger sometimes.

Is the signup failing with "Facebook returned an error:" for anyone else?

Out of curiosity, what's the string?

If it's for your own development work, Debian/Ubuntu will generate a self-signed SSL certificate when you install the package `ssl-cert`.

It's an ID10T error, though (IIRC) it's more tech supprot/sysadmin jargon.