Gankro

7 ms·

1.
by Gankro 7y ago
Yeah motivation is the bigger factor (why would Mozilla care about the system APIs of an OS, of all things?) but also it doesn't hurt that Apple is one of the richest companies in the world (depending on the day).
2.
by Gankro 7y ago
It's literally true that Rust tried and failed in the sense that Rust's early design was extremely similar to Swift's, polymorphic compilation and all, and it was thrown out when it didn't seem to work. Swift pushed on i
3.
by Gankro 7y ago
More accurately I worked on stdlib stuff for both, with a focus on collections. It's just that this naturally pushes you into minoring in language design and majoring in the low-level details of the language. Plus it's hard to no
4.
by Gankro 7y ago
Yeah the smearing approach is the only one that merits a callout from my position in the pipeline, because the other approaches are handled by your shaper or rasterizer, which are usually 3rd party libs that can be mostly regarded as black
5.
by Gankro 7y ago
I mainly prioritize making my pages work reasonably with different zooms and window sizes, since all I really know for certain is that there's no ideal for everyone. The font settings are just from a copy of bootstrap from like 6 years
6.
by Gankro 7y ago
Yeah there's a reason all my examples use the same ~3 languages, and only a few random fragments from them. You just need a few examples that demonstrate that something can happen. Everything actually works pretty uniformly, so as lo
7.
The Kinds of Implementation-Defined?(gankro.github.io)
1 points by Gankro 8y ago|0 comments
8.
by Gankro 8y ago
To elaborate on the float example, see JSON, where text-based representations of numbers has led to massive incompatibilities among different parsers and generators. The original "spec" didn't even define if numbers were doub
9.
by Gankro 9y ago
Ultimately it boils down to the fact that there's basically no interesting difference between an immutable reference to a primitive and the primitive itself in Rust. It can't dangle. The immutability can't be casted away. The
10.
by Gankro 9y ago
There will only be minimum requirements for GL/DirectX versions. I believe we require GLES 3.1, and then whatever DX version Angle turns that into.
11.
by Gankro 9y ago
even more clearly: webrender is "the stuff that works pretty ok and we can run through CI". In principle enabling webrender should get you the ~same results as not having it on, visually, modulo a few known bugs. webrendest is &qu
12.
by Gankro 9y ago
Yes, let us never forget how many exploits there are in trivial codecs like ICO and BMP, because they're written in C(++): https://bugzilla.mozilla.org/show_bug.cgi?id=775794#c0
13.
by Gankro 9y ago
Yeah when we do named args it will very likely be based on Swift, but a bit different due to backwards compat and the desire to integrate it into existing methods like Vec::from_raw_parts and ptr::copy.
14.
by Gankro 9y ago
To clarify: C says it's UB, C++ rounds up to 1.
15.
by Gankro 9y ago
Do you mean: * All unsafe operations don't exist. * All unsafe operations exist, but the literal unsafe keyword and its machinery doesn't exist The latter is how most ostensibly safe languages work. See Haskell's UnsafePerfor
16.
by Gankro 9y ago
Re: parameterized unsafe -- I think it's been discussed and rejected, I don't remember where. I think it was mostly a matter of "yes this would be more powerful, but the complexity isn't worth it". Note that we sort
17.
Bugs You'll Probably Only Have in Rust(gankro.github.io)
367 points by Gankro 9y ago|83 comments
18.
by Gankro 9y ago
Note that a lot of these optimizations aren't necessary in Rust -- e.g. list fusion is only valuable in Haskell because mapping over lists is exposed as a one-shot operation that produces a new list. So `map map map list` is conceptual
19.
by Gankro 9y ago
Yeah the only thing that Rust might have over C, in terms of really optimized implementations, is low-level idioms that C declares to be UB, but Rust declares to be defined (generally to be what x64 hardware does). Maybe something that leve
20.
by Gankro 9y ago
Yeah dropck is a fun little gem, which has received several post-1.0 revisions due to soundness problems. I agree the system you propose would be simpler in terms of spec and effort, but I don't know about simpler to use . Much like r
21.
by Gankro 9y ago
This is really ignoring how relevant and affine types interact with different features. For example, unwinding makes perfect sense with affine, not so with relevant. Rust has unwinding, and no effect system to track whether something can or
22.
by Gankro 9y ago
Literally the only link in the article, on the first use of the Official Terminology, is a link to the wikipedia page that defines all the terms.
23.
The Pain of Real Linear Types in Rust(gankro.github.io)
167 points by Gankro 9y ago|81 comments
24.
by Gankro 10y ago
Honestly I just think distros and package managers are the busted ones here. LLVM is strongly coupled to your language's semantics, and I'm unaware of any good reason to force every compiler to use the same version.
25.
by Gankro 10y ago
Ah good point. It could be that the first-preimage attack gets you exactly X, in which case it fails to handle second-preimage. I would expect this to be incredibly unlikely (especially since they seem to generally involve generating some r
26.
by Gankro 10y ago
You seem to be mistaking or misreading something here. * Collision attack: find X and Y such that hash(X) = hash(Y) * Second-preimage: given X, find Y such that hash(X) = hash(Y) * First-preimage: given hash(X), find Y such that hash(X) = h
27.
by Gankro 10y ago
The Swift memory model is current incoherent; this is an attempt to fix that. (defining accesses properly, properly preventing conflicting accesses in single threaded ways) Boring single-threaded swift code can currently be incredibly slow
28.
by Gankro 10y ago
The major holes are: class fields, globals, and captures of escaping (non-scoped) closures (which are basically class fields). Although this system proposes dynamic checking for these cases, it's explicitly not atomic checking. Atomic
29.
by Gankro 10y ago
The argument for Swift's behaviour is basically: very few things actually need this guarantee, and it's bad for performance (or memory usage) for all the other types to inherit it. Personally, as someone who has spent a lot of tim
30.
by Gankro 10y ago
Hit me up with any questions y'all have.

More ›