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: krzysdrewniak@gmail.com

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.

I don't think the BSD/MIT licenses will stop the patent-abusers from using your code because (as I understand them) they say "Here's the code, do whatever you want with it. Just keep the copyright notice on."

If you want to stop your code from being sucked into a black hole, a more "restrictive" license like the GPL would be your best bet. I would recommend the GPL because it's well-known and a lot of people have some idea of what the terms are, as opposed to something like the Apache license, which people might have to look up.

I just went and checked, and the standard gives a default value of "10." for read-base , so decimal by default (I think). It also says:

"Notes:

Altering the input radix can be useful when reading data files in special formats. "

Common Lisp has a global variable called read-base ,which controls also base numbers are read in with. This, IIRC, was put in because some earlier Lisps read numbers in octal, while others used decimal. Setting this variable to something higher than 10 can give you strange results. For example,

    nil
    => NIL
    (eql '() nil)
    => T
    (setf *read-base* 36)
    nil
    => 30477
    (eql '() nil)
    ERROR: 19101 is not a function name; try using a symbol instead
    (|EQL| '() nil)
    => NIL

For you non-lispers, the empty list '() is equal to the "false" value, nil. Also, the pipes are special syntax to allow for symbols which normally not parse as symbols. (The uppercase is for historical reasons too).

The moral of this story: "See that control variable over there, the one that does weird things to parsing? Don't touch it unless you know what you're doing."

This should cut down on duplicate submissions. That is, IF people remember to use it.

This is a great, IRC-specific extension to esr's "How To Ask Questions the Smart Way" ( http://catb.org/~esr/faqs/smart-questions.html ). Reading (and understanding) both of these documents as an IRC newbie will most likely make your experience much more pleasant.

I'll keep this around if I ever need to write a compiler.