HNHacker News
TopNewBestAskShowJobs

mbauman

4,240 karma · joined February 3, 2012

mbauman.com
submissionscomments
mbauman··on When tracking your period lets companies track you
It's funny: becoming a parent made me FAR less judgmental of other parents.
mbauman··on Tesla Model S Goes 752 Miles with a Startup's Prototype Battery
~700 miles is the magic point at which charging times can be significantly extended to simply be overnight.
mbauman··on Julia 1.7 Highlights
I'd love to figure out where the disconnect is — and how we can make the manual more clear. It's a pretty simple rule: the number of semicolons specifies the dimension in which you "move". I've seen two disconnects, but yours might be different

* Julia's arrays are column major but when you use spaces to write them, you do so in row major fashion. This new syntax enables a column major input: `[1 2; 3 4]` is equivalent to `[1; 3;; 2; 4]`.

* When you're using spaces, it might feel "funny" to jump from one semicolon (which concatenates the rows in the first dimension) to three semicolons (which concatenates the matrices in the third dimension) in an expression like `[1 2; 3 4;;; 5 6; 7 8]`, but the key is that spaces first build rows and then the semicolons concatenate them along a particular dimension.

Anyhow, if you can expand on what's causing trouble, it'd be great to figure out how to improve the description in the manual.

mbauman··on Beware of fast-math
See the one footnote: you can re-associate a list of 2046 numbers such that they sum to _any_ floating point number between 0 and 2^970.

https://discourse.julialang.org/t/array-ordering-and-naive-s...

mbauman··on Beware of fast-math
That's precisely the part that makes it so impossible to use! Sometimes it means fewer bits of accuracy than IEEE would otherwise give you; sometimes it means more. Sometimes it results in your code being interpreted in a more algebra-ish way, sometimes it's less.

That's why finer-grained flags are needed — yes, FMAs and SIMD are essential for _both_ performance and improved accuracy, but `-ffast-math` bundles so many disparate things together it's impossible to understand what your code does.

> And most math will work fine with fast-math, if you are careful how you write it.

The most hair-pulling part about `-ffast-math` is that it will actively _disable_ your "careful code." You can't check for nans. You can't check for residuals. It'll rearrange those things on your behalf because it's faster that way.

mbauman··on How not to sort by average rating (2009)
I'd love to see an update here that:

* Included a graph of the resulting ordering of the two dimensional plane and some examples

* Included consideration of 5- or 10-star scales.

mbauman··on Jimmy Wales’ Final Email
The donation matches are typically not grants, but rather _other donors_ playing those games (surely in collaboration with NPR's development dept). They definitely exist.
mbauman··on The paradox of the Prostate-Specific Antigen (PSA) test
The problem is twofold: the test is notoriously flakey, and the cancer is frequently not an issue. You're also absolutely right that many more men die with prostate cancer than from it — but that's most commonly _without_ treatment or even knowledge of it!

The trouble is exactly that it _can_ manifest early and it can become aggressive and that's when it's crucial to catch and treat.

mbauman··on Books.jl: Create Books with Julia
That exists more directly with Weave.jl — this is built for bigger things. As the README says:

> If you want a small report instead of a book with numbered sections, then Weave.jl might be more suitable for your problem.

http://weavejl.mpastell.com/stable/

mbauman··on An unexpected victory: container stacking at the port of Los Angeles
All the dismissals here are fascinating to me — and sure seem to be exactly the overarching story of TFA. Yes, this certainly isn't the only problem here, but it's certainly the easiest to fix.

And yes, the narrative of the story is definitely important, because it avoided all the rabble you see here that was getting in the way of a simple first step.

mbauman··on Willingness to look stupid
But they did help him. I don't see this as a huge indictment on the rep here — they _do_ deal with people who are very ignorant of tech everyday. Maybe it took a while to convince them, but I think that's just as likely a failing of communication.

> I eventually asked them to humor me and just bring out the boxes for the various laptop models so I could see the boxes, which they did, despite clearly thinking that my decision making process made no sense

mbauman··on Willingness to look stupid
I am really curious what his end goal here was. Apple's boxes are all very small — in what situation would a few centimeters in box size outweigh all other considerations?
mbauman··on More details about the October 4 outage
The rest of the internet sucked yesterday, and my understanding was it was due to a thundering herd of recursive DNS requests. Slowing down clients seems like a good thing.
mbauman··on More details about the October 4 outage
How would've it been worse? Waiting for a timeout is a good thing as it prevents a thundering herd of refresh-smashing (both automated and manual).

I don't know BGP well, but it seems easier for peers to just drop FB's packets on the floor than deal with a DNS stampede.

mbauman··on New features coming in Julia 1.7
As a moderator on the primary discussion board — discourse — please do flag problematic posts and/or DM me. We don't see everything and rely on flags.
mbauman··on What if Git worked with programming languages?
You can already choose different `diff` programs to use for particular filetypes. E.g., nbdime for Jupiter notebooks:

https://nbdime.readthedocs.io/en/latest/vcs.html#git-integra...

mbauman··on Ask HN: Who is hiring? (September 2021)
Julia Computing: https://juliacomputing.com and https://juliahub.com

Julia Computing is a company founded by all of the co-creators of the Julia Language, and we've just raised our Series A to build out our core product: JuliaHub, a SaaS platform for computing (analysis, modeling, and simulation) at scale targeting many different technical domains. We're hiring for many full-time roles: https://jobs.juliacomputing.com/jobs

- Sales Engineer (Boston or Remote US): https://jobs.juliacomputing.com/jobs/y58-NbhWEM-e/

- Cloud Engineer (Bangalore, Boston, or Remote): https://jobs.juliacomputing.com/jobs/k_NT-998DQPl/

- Compiler and Runtime Engineer (Boston, or Remote): https://jobs.juliacomputing.com/jobs/4fc4leHHp9V_/

- Julia Application Developer: https://jobs.juliacomputing.com/jobs/3NhVYuObq6cY/

- Wireless Systems Research Engineer: https://jobs.juliacomputing.com/jobs/NpHiTgQMWv94/

mbauman··on IEEE 754 round-off errors
The point is simply there’s a method to the madness. It’s not randomly inaccurate. Many operations are perfectly accurate. Those that aren’t are just the closest representable value to the accurate value.

Doing something like what you initially suggested would break that.

mbauman··on IEEE 754 round-off errors
Oh cool, you want to use different definitions. No matter. Point remains: the floating point representation of 1/4 is not approximate. Similarly, the closest floating point value to 1/10 also precisely defines some value: it's exactly 0.1000000000000000055511151231257827021181583404541015625.

Now whether that's accurate to you depends upon your application. But the numbers don't care.

mbauman··on IEEE 754 round-off errors
> the other just gives you a (more) wrong number.

This is a common misconception: IEEE754 floating point arithmetic is not wrong or fuzzy or inherently inexact. It is very exact; it just has limited precision.

mbauman··on IEEE 754 round-off errors
That's just trading one class of bugs for another. Adding a million 10^-50s to 1.0 is far still closer to 1.0 than the next floating point number.

Your algorithm would give an answer that's a million values away.

mbauman··on A Woman Hid Her Pregnancy from Big Data (2014)
Whoa, retail is doing LPR now? Not surprising, but goodness.

I forgot a high-value item at a checkout lane the other day, and when I returned with my receipt to ask for it, they pulled up the video of the checkout lane to confirm I hadn't gotten it. Not terribly far-fetched to see that moving to identification via tracking to LPR or otherwise.

And sure enough, google finds a vendor that combines the two: https://www.asmag.com/showpost/9640.aspx

mbauman··on Apple’s Mistake
That's not what I'm saying. Apple is required by law to report images if they have "actual knowledge" of CSAM. Courts aren't too kind about superficial technicalities like "that output label wasn't trained" when Apple is doing on-device ML classification of pictures to identify content. By proactively scanning for selective hashes they can say they're doing something without being required to report a less-accurate ML output.

That's also why this only applies if connected to iCloud; otherwise they don't have "knowledge" of it.

mbauman··on Apple’s Mistake
Even without a requirement to proactively scan, Apple is surely expanding its ML stack on photos to categorize and describe photos and persons in them.

Is that not the simpler explanation for this?

mbauman··on What's bad about Julia?
You can expose it as a CLI tool if you wish: https://github.com/fredrikekre/jlpkg
mbauman··on What's bad about Julia?
Folks generally don't do development in notebooks, thankfully. Instead, they generally use a Revise- or REPL- based workflow, often with VS Code.
mbauman··on What's bad about Julia?
I've never seen anyone say that latency is a good thing or that it's not a priority. It's a hard problem and it's being worked on and it's getting significantly better — particularly over the past three releases. It's disingenuous to suggest the latency gripes aren't being heard or respected.

Now what I see frequently is that folks *do* regularly suggest workflows that work for them. Sometimes too zealously, yes. And indeed REPL-based workflows aren't for everyone.

On documentation I whole-heartedly agree. The manual hasn't seen a major re-structuring since its inception AFAIK — and it's long overdue.

mbauman··on Julia's multiple dispatch explained with Pokemons
When folks talk about the performance of Julia's JIT, they're generally talking about the compile-time overhead (and not the runtime speed). Type inference is one part of the compile-time overhead that enables improved runtime speed... but I think you're actually curious about runtime speed.

Julia aggressively compiles multiple specialized versions of almost all the methods it encounters — one specialization for each unique combination of the argument types you pass. Even if you only define a single method `f(x,y) = 3x+2y`, Julia will compile a specialized floating point implementation when you call `f(2.5, 3.5)`, an integer implementation when you call `f(1, 2)`, and so on. It's this very aggressive compilation of everything many times over that makes Julia infamously slow to start and fast to run.

Inside each of these specializations, Julia concretely knows the type of `x` and `y`. And so it can — while compiling it — look up exactly which multiplication method it should use to compute `3x` and `2y`, inline them, infer the types of the results, lookup which `+` method to call, and inline it.

Even if you end up calling bigger functions that don't inline, Julia can hard-code the pointer to the exact specialization of every function you call because it's in a context where it knows the exact types of everything.

So it's a bit of a chicken-and-egg question. Julia's JIT (typically) compiles specializations of methods with precisely known argument types. This makes does make inference easier: every function call is a fresh start! If at any point inference loses the trail, it's ok, Julia just compiles it pessimistically to handle any type and can lookup the exact method/specialization that's needed for each function call on-demand (potentially compiling it and getting a new fresh start if needed), and then you're back on the happy well-inferred and super-specialized path.

mbauman··on Julia Computing raises $24M Series A
There's no hidden dirty magic, but you're right: Complex numbers require `Real` components and Rationals require `Integer` numerators and denominators. Both `Real` and `Integer` are simply abstract types in the numeric type tree, but you're free to make your own. You can see how this works directly in their docstrings — it's that type parameter in curly braces that defines it, and `<:` means subtype:

    help?> Complex
    search: Complex complex ComplexF64 ComplexF32 ComplexF16 completecases
    
      Complex{T<:Real} <: Number
    
      Complex number type with real and imaginary part of type T.
mbauman··on Julia Computing raises $24M Series A
Yes, that's what I figured you meant, and that's precisely what that paragraph and my comment above detail. You can enter a credit card into JuliaHub and start running large scale distributed compute on CPUs and GPUs right now. Or you can email us about procuring an enterprise version for your whole team and/or licensing JuliaSim or Pumas.
← PreviousPage 6 of 9Next →