lbrandy

NASDAQ index has a 3x float weighting (and a far, far smaller total capitalization) which makes it far more susceptible.

Other indexes do not have these multipliers, and are much larger. The exposure for e.g. VTI is far, far less.

You should not trust me, but here's my understanding. I wish there was a really good writeup somewhere to explain this authoritatively but I'm not sure there is one. Would also love to see one. Frankly vanguard should do it.

VTSAX (and VTI) follow the CRSP index. This is float-adjusted but they likely will be fast tracked (these are two separate rules in how this index chooses to weight things and participate in new stocks). At ~5% float, these companies will be in the 50-100B range. So under all those assumptions, they'll be bought quickly but represent less than 1% of VTSAX (until they float more shares on the public market).

There is a huge amount of misinformation on this topic, including in this thread, at the minute.

Some index funds have a very long horizon before they include them (e.g. a year). Others are "fast-tracked" (e.g. notably VTI). Most of those, however, are float-adjusted, so only the stock available for trade is considered part of the marketcap. So e.g. VTI / VTSAX will buy spacex relatively quickly after the IPO but at the float-adjusted weight of ~$75B because that's the % of stock available.

If you care alot about this, now is the time to understand how your index fund treats IPOs wrt to delays + float adjustment.

At least part of the answer is this doesn't meet the requirement of the proposed law. You need to actually provide the functionality of the server-side, not just its API.

Anyway, I don't think that there's anything that it's like to be an LLM. I don't see how anybody who knows how they actually work could think that.

While I have almost zero belief that LLMs are conscious, I just don't think this is so trivially asserted.

The easy half of this is thinking that LLMs aren't conscious given what we know about how they work. The hard part (and very, very famously so) is explaining how _you_ are conscious given what we know about how you work. You can't ignore the second half of this problem when making statements like this... because many of the obvious ways to argue that clearly LLMs aren't conscious would also apply to you.

I have no idea how you can assert what is necessary/sufficient for consciousness in this way. Your comment reads like you believe you understand consciousness far more than I believe anyone actually does.

My point isn't that coordination is easy - it's that treating it as impossible becomes self-fulfilling.

While I see what you are getting at, and I think its super important we come up with philosophical frameworks to push back on the central idea in question (ie, the moral hazard of "its gonna happen anyway so why not pour a little more into the river").... I think your writing/responses miss the central point.

As I see it, the fundamental issue with this essay, and your responses, is you keep conflating impossible with probability zero. People are saying "this is inevitable" to mean this has probability 1 of occurring, with basic game theory reasoning (its a giant iterative prisoners dilemna), and your response "but it's possible". Yes, with measure zero.

Telling us that such a path surely exists isn't useful. If you want to push back on "inevitability" you need to find a credible path with probability > 0 (which is not the same as impossible).

I was struck how the argument is also isomorphic to how we talked about computers and chess. We're at the stage where we are arguing the computer isn't _really_ understanding chess, though. It's just doing huge amounts of dumb computation with huge amounts of opening book and end tables and no real understanding, strategy or sense of whats going on.

Even though all the criticism were, in a sense, valid, in the end none of it amounted to a serious challenge to getting good at the task at hand.

has a model much as we humans do

The premise that an AI needs to do Y "as we do" to be good at X because humans use Y to be good at X needs closer examination. This presumption seems to be omnipresent in these conversations and I find it so strange. Alpha Zero doesn't model chess "the way we do".

Suppose this is as good a place to pile-on as any.

Though this was not the post I was expecting to show up today, it was super awesome for me to get to have played my tiny part in this big journey. Thanks for everything @je (and qi + david -- and all the contributors before and after my time!).

It's fun to see everyone arguing about what "everyone" thought.. when... we can just... look... https://news.ycombinator.com/item?id=3817840 is a fun thread from 2012.

The top reply to the top comment has some useful quotes for the purposes of this discussion...

This is not going to be one of the best tech acquisitions of the next decade.

Instagram is a photo service in a sea of other photo services.

Bookmark this comment. See you in 2022.

Heh.

For uninitialized memory reads, which is one of the biggest classes of issues, valgrind can still be invaluable. MSAN is one of the more difficult things to get setup and remove all the false positives. You typically need to transitively compile everything including dependencies, or annotate/hint lots of things to get the signal-to-noise ratio right. Sometimes its just easier/better/faster to run it under valgrind.

most

Well... "a few" is probably more accurate.

https://twitter.com/tjaltimore/status/1763571057703723344?s=...

I struggle to resonate with what you are saying, as my experience is the opposite. I'm curious where this discrepancy is rooted. Reckless hypothesis: are you working on majority latency or majority throughput sensitive systems?

I have seen so, so, so many examples of systems where latencies, including and especially tail latencies, end up mattering substantially and where java becomes a major liability.

In my experience, actually, carefully controlling things like p99 latency is actually the most important reason C++ is preferred rather than the more vaguely specified "performance".

I agree entirely with the premise here save one subtle bit at the start. I think there is grave danger in reducing "vector database" to "vector search" as equivalent domains and/or pieces of software. I would argue that for "vector databases" there's alot more "database" problems than "vector" problems to be solved.

I fear there's going to be alot of homerolled "vector search" infra that accidentally wanders into an ocean of database problems.

The only reason you and others seem so desperate to redefine bailout so you can call it a bailout is because you want to attach the negative connotations to that word to “hurt” the people you want to be hurt.

It’s embarrassing, shortsighted, and destructive.

We should be clear... in these large organizations... HEAD is always broken. But it has the advantage of being broken for everyone, tested by everyone, fixed by everyone, and thus fixed for everyone. And this usually makes it far better than the alternatives.

Having 1000 dependencies with versions pinned means you are living alone and will run into fewer issues, but when they do come, they will be absolute nightmares that no one else is dealing with and no one can help with. And one day you'll have to do the game of begging someone else to upgrade their version of a downstream thing to fix the issue, and they won't, so you'll try to get the other group to backport the fix in their thing to the version you can't upgrade off. And they won't. etc. etc.

Full versioning is the worst of all approaches, IMO, for large complex interconnected codebases (especially ones that are many-to-many from libraries to output binaries) but it absolutely is sometimes the only viable one (for example, the entire open-source-ecosystem is a giant(er) version of this problem, and in that space, versioning is the only thing that I can imagine working).

FWIW, I joined HN 14 years ago (wow) and there's never been a time in those 14 years that HN wasn't convinced that facebook's demise was just around the corner.

It depends what you mean by free will. Non-philosphers almost always mean "libertarian" free will when they say that, and yes, this same argument also basically outlaws libertarian free will as well. There is no physical mechanism by which you can alter your brain physics to "choose" things.

Carroll and others have a compatibilist notion of free will which is a more subtle concept that I'm not sure I'm qualified to actually explain.

they seem to be advocating for some sort of dualism.

This paper is doing the opposite. It's arguing that other papers/ideas advocating dualism are going the wrong way and purely physicalist explanations are the best path forward.

Here's my attempt at a tldr.

1. The laws of physics at the time scales, space scales, and energies of the human brain are "known" and we have deep reasons to believe that more will not be discovered. He spends a great deal of space explaining and arguing that the credence that physics is "complete" in this regime should be very, very high.

2. Given the current laws of physics, there is no place or room for non-physicalist explanations of consciousness (or, I suppose, for other dualist ideas like a soul) because there is no mechanism for them to effect change in the physical world.

3. Anyone who wants a non-physicalist approach to consciousness must either claim they can violate the laws of physics in our brains, or cannot affect the physical world.

if the team is remote, yes

Software is more like building a machine than either math or art. There've been attempts to make formally-provable programs (so it _is_ like math) but these are not in widespread use.

Go watch the Lockpicking Lawyer on youtube pick locks and trivially crack/open every lock ever made. This is, roughly, the best physical analog to what happens with computer programs and safety. The creators are trying but they have to be correct everywhere, from every angle, and the attacker only needs to find one weakness to break it.

I used to post quite a bit more. Times have changed.

This is the only good use of a const& shared_ptr which is when you 1) only _might_ want to claim shared ownership of the thing, and 2) the perf of those unnecessary refcounts matter.

However, you missed a _super_ important caveat of this which is very subtle and very awful. And that is all of the code being executing here between the start of the function and the copy of the shared_ptr is doing it without the protection of the reference count on the shared pointer. It's entirely conceivable that, for example, the `has_widget` function, while executing, invalidates the original shared_ptr passed in and thus makes your eventual use of that shared_ptr invalid.

hey i've worked on this stuff for awhile at fb.

One important update is that the primary rationale for us, at the time, to change std::string's implementation to `fbstring` was to get SSO. We got huge perf wins for having SSO on std::string. (small string optimization for those unfamiliar with the initialism).

This, at the time, was a violation of the standard. By wording, SSO was not standard compliant.

Once the standard was changed (as of C++11) so that std::strings could have SSO, we removed our patches on the standard library and now use "vanilla" std::string (from libstdc++). We still have `folly::fbstring` for people who want that implementation (which is smaller, and has more in-situ capacity, because of various cleverness detailed in that talk), but it's no longer our `std::string`.

For reference: https://github.com/facebook/folly/blob/master/folly/FBString...

All of msvc, gcc, clang, and the isocpp committee have active work ongoing for C++ modules.

We'll have them Soon™.

"zero overhead abstractions" is a principle of the language, not the library. The STL containers are clearly designed to be on the "safer" side than the performant side. You are right that, perhaps, we've extracted the wrong lesson from the STL but your version ("iterators everywhere, including for your own algorithms and container types") is still definitely the right message.

As an example, STL unordered-maps have fairly strict requirements around iterator invalidation and that results in indirection that do affect performance. It's pretty easy to make a "faster" unordered_map that tosses that requirement (as many do).

"terminal level", in the sense being used by the OP, doesn't mean "end of the IC track". It means a level that you can be at "forever". Often times the junior engineering levels have some expectations around eventually being promoted (ie, "up or out").

Just so I'm clear, what this appears to be doing is the moral equivalent of a function that asks if some constant equals what we know to be its value (true at compile time)? And then at program-init time (via __attribute__((constructor(101)))) changing the value of the constant in the text section so the test is now false?

If so, that's both quite clever and something I don't think I want in my codebase :P. The good news is I'm pretty sure Daveed's proposal that you mention (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p059...) got support last time it came around EWG so I'm hoping we can just go that way.