skysight-inc/HackerNews huggingface dataset:
Can't say what and Interlisp did, but the MIT Lisp Machine and here the commercial variant Genera.

Files are versioned. The Lisp machine file system has versions (same for DEC VMS and a few other file systems). Nowadays the file version is attached to the name&type. Thus editing a file and saving it creates a new file with the same name&type and an updated version number. I can edit/load/compile/open/... files by specifying its version number. If there is no version number specified, the newest file version is used.

A site shared a namespace server with system registry and several file servers.

Code, documentation, etc. is defined as a system, similar to what ASDF does. A system has major and minor version numbers and other attributes (like being experimental or being released). Each time one does a full compile on a system, its major version gets updated and it tracks which file versions it used for that compilation. Whenever one creates a patch (a change of the sources) to a system, the minor version gets updated. After 12 full compiles and 30 patches to the latest version we have system FOOBAR 12.30. This data is recorded in the system directory, thus outside of an image (called a World in Genera) in the file system.

Now I can use that system FOOBAR in another Lisp and "Load System FOOBAR :version Newest" -> This will load system FOOBAR 12.30 into its runtime. Then new patches may appear in the system. I can then in a Lisp say "Load Patches FOOBAR" and it will look into the system directory for new patches to the current loaded major version and load those patches one by one. This changes the running Lisp. It then knows that it has loaded, say, FOOBAR 12.45, what files it has loaded and in which files the respective code (functions, ...) are located.

If I want to ship a system to the customer or someone else, I might tag it as released and create a distribution (with sources, documentation or not). The distribution is a file (also possibly a tape, a bunch of floppy disks, a CDROM, or similar). A distribution can contain one or more systems and its files (in several versions). On another Lisp I can later restore the distribution or parts of it. The restored systems then can be loaded for a specific version. For example I can load a released system version and then load patches for it.

A saved image knows which versions of what systems it includes. It also knows which functions sources are where. It may also have corresponding documentation versions loaded.

Later a source versioning system (called VC) was added, but I haven't used that.
Of course, but there are still four schools which are clearly the "top" ones. The same is true for academic conferences, or big tech, or intelligence agencies.
I think both RSDS and IPFS use libp2p pub/sub mechanism
You'll do great. This will eventually turn into new discoveries if you keep at it.
The nice thing about mathematics is that there probably won't be any failed or non-reproducible experiments in the lab. That doesn't mean that a math PhD is going to be easy, but you should be aware that a lot of people will have a different idea of what you are doing if you don't tell them that your PhD is in math.

Best of luck for your PhD! You might want to check out this ted talk: https://www.ted.com/talks/uri_alon_why_science_demands_a_lea...
California has the most expensive housing in America. That is the primary reason for its larger homeless population.
Is it really the best approach though if we sink all this capital into it if it can never achieve AGI? It’s wildly expensive and if it doesn’t achieve all the lofty promises, it will be a large waste of resources IMO. I do think LLMs have use cases, but when I look at the current AI hype, the spend doesn’t match up with the returns. I think AI could achieve this, but not with a brute force like approach.
Yes for sure AI or even basic computing prior to that has done wonders, chess being one example. Simply removing some of the issues with humans - inconsistency, errors due to mood or form etc.

I agree this approach is only viable one but I do hope the other way is also being tried. Who knows there may be a breakthrough. Like they try to create life from basic chemicals present in nature.
Their technique for getting out of cataplexy is the same thing I do to get out of sleep paralysis
You definitely needs docs, they are just as important as the product.

But thinking all your prospects will read the docs is a fallacy- maybe 5% of prospects fall into the category of OP, more commonly they won’t even know what their own requirements are, let alone how to map that to your product/docs
Beneficial to humanity does not mean "increasing the GDP". Humans are not machines; there are things that are valuable that is not technology. Just from the title of the thesis I would not judge its value. Analyzing culture and writing about your own ideas can be a good thing.

More important to me is whether it was written because someone really cared about the topic, or wrote 100s of pages of nothing to have a title.

But I also want to comment on your idea that researching AI is superior to researching dancing because it is more beneficial for humanity. I am myself in AI adjacent research, but I still disagree. Dancing is a deeply human thing, and we should care about it. And I believe that many people (especially outside of this bubble) will think that many parts of currently hyped AI research has very questionable "benefit for humanity", such as AI image generators.
Manage Bookmarks Easily
I had an argument on LinkedIn about something data engineering related and the guy literally sent me a DM with his calendly and said pick a time for us to continue the debate.

What. The. Actual. $&%#?
Being typed would make it harder, not easier for a JS dev. Syntax is a very surface-level difference and is basically a rounding error in cases like this after the very initial stages.

If I were to try to make the argument for you, I'd point to some of Elixir's more powerful abstractions like protocols and macros as a reason Elixir might be harder for JS devs. In reality, though, I found it very straightforward to learn as a JS dev, and that was back in 2016 when the documentation was much worse.
I worked for an Australian company from Germany and did similarly (I worked German work days but would start early ~5:30-6am to have some overlap with the Australians - they never expected me to work "core hours", just to have some overlap).

It wasn't too bad! Much easier than working with west coast US (where their 9am is my 6pm - I don't want to work late but I don't mind working early).
True, but it tells that if you are a founder of a niche AI company then you should take money out of it instead of investing everything back into the company, because eventually the generalist-AI will destroy your business and you will be left with nothing.
Happy to say that hold bookmark is live on producthunt https://www.producthunt.com/posts/hold-bookmark?utm_source=o...
I think this is largely right. I look a this space as somebody that plugs together bits and pieces of software components for a living for a few decades. I don't need to deeply understand how each of those things work to be effective. I just need to know how to use them.

From that point of view, AI is more of the same. I've done a few things with the OpenAI apis. Easy work. There's not much to it. Scarily simple actually. With the right tools and frameworks we are talking a few lines of code mostly. The rest is just the usual window dressing you need to turn that into an app or service. And LLMs can generate a lot of that these days.

The worry for VC funded companies in this space is that a lot of stuff is becoming a commodity. For example, the llama and phi models are pretty decent. And you can run them yourself. Claude and OpenAI are a bit better and larger so you can't run them yourself. But increasingly those cheap models that you can run yourself are actually good enough for a lot of things. Model quality is a really hard to defend moat long term. Mostly the advantage is temporary. And most use cases don't actually need a best in class LLM.

So, I'm not a believer in the classic winner takes all approach here where one company turns into this trillion dollar behemoth and the rest of the industry pays the tax to that one company in perpetuity. I don't see that happening. The reality already is that the richest company in this space is selling hardware, not models. Nvidia has a nice (temporary) moat. The point of selling hardware is that you want many customers. Not just a few. And training requires more hardware than inference. So, Nvidia is rich because there are a lot of companies busy training models.
Everyone learning stuff is what's supposed to happen in a debate.
The creator of Rust in his own words:

“ Introducing: Rust Rust is a language that mostly cribs from past languages. Nothing new. Unapologetic interest in the static, structured, concurrent, large-systems language niche, Not for scripting, prototyping, or casual hacking, Not for research or exploring a new type system, Concentrates on known ways of achieving: More safety, More concurrency, Less mess, Nothing new? Hardly anything. Maybe a keyword or two, Many older languages better than newer ones: e.g., Mesa (1977), BETA (1975), CLU (1974) … We keep forgetting already-learned lessons., Rust picks from 80s/early 90s languages: Nil (1981), Hermes (1990), Erlang (1987), Sather (1990), Newsqueak (1988), Alef (1995), Limbo (1996), Napier (1985, 1988).”

If modern PL research is trying to take credit for the latest hot programming language (which I doubt they are, it’s only internet commentators who have nothing to do with PL research who argue with me. Actual PL researchers don’t care about Rust), they should be embarrassed.

Thank you for linking latest PL research, it has been a while since I’ve gone through it, glad to see nothing has changed. Ask yourself, how many of those talks in day 1, have accompanying code? is it even 25%?

For giggles I decided to peruse through “Normal bisimulations by Value”. A 54 page dense paper with theorems, equations and lemmas. Lol, what are we even doing here? You can also notice that they don’t bother justifying their research in the intro or the abstract, claiming relevance to any actual programming language. They themselves realize it’s just math, and PL researchers has become a euphemism for math. Frankly, even one such paper being accepted to a PL conference tells me something is going awry in the field, but if a majority of papers are like this, then the field is a wasteland, that only serves to grind young talented minds into spending their lives chasing academic prestige with no value to society.
Market will sort that out just like it did dotcom or tulip madness.

Another big push back is copyrighted content. Without proper revenue model how to pay for that?

That will also restrict what can be "learned". Already there's lawsuit, allegations of using pirated books etc
is there a mathematics, physics, engineering community to be found on the gemini protocol?

I would really appreciate a HN-like platform which

1) supports tags (more finegrained than lobste.rs which just dumps all of science under "science" or whatever)

2) supports math notation (latex or whatever)
> Getting modern code to compile for Windows 98 was tricky. We first tried mingw, which supposedly could compile modern C++ for Windows 98/Pentium II. That turned into a dead end - possibly due to CMOV instructions that aren't supported pre-Pentium Pro.

How? Pentium 2 is not a pre-Pentium Pro CPU. Pentium 2 is the direct successor to Pentium Pro. Or does Windows 98 not support CMOV?
I forgot to mention that Kenney has a cult following. Reddit often labels him as "Asset Jesus" [0].

It looks like there's even a site dedicated to Asset Jesus [1].

[0] https://www.reddit.com/r/ThemeParkitect/comments/o63nbi/who_...

[1] https://www.assetjesus.com/
One problem of ipv6 is proponents saying there are 2^128 addresses.

It's really hard to comprehend how many unusable ipv6 addresses are.

Having more than 2^16 hosts on a subnet is pretty much impossible. Sticking with "grain of sand" units, but using volumes all from wolfram alpha:

There's 2^80 usable IPs in the entire ipvv6 space, because of the /64 subnets. That's plenty. But for every subnet, that's 40 cubic metres unusable for every subnet, and a sphere 1mm wide of usable addresses.

My ISP give me a /48. I have under 30 addressable devices over 3 vlans. I'm using 40 cubic miles of space. A ratio of about 10 trillion:1

But that's nothing. The IP allocators are happy to give a bank a /16, or in your "grain of sand" measurements 30 times the volume of the moon.

To match my unused:used ratio of 10 trillion to one, chase manhattan would need 2^70 devices, which is billions of addresses per cell.

All the space that fanboys go on about is almost all unusable, so the extreme examples don't really help at all.
Breaking Wheel
I have unfortunately been disappointed with the llama.cpp/ollama ecosystem of late, and thinking about moving my things to vllm instead.

llama.cpp basically dropped support for multimodal visual models. ollama still does support them, but only a handful. Also ollama still does not support vulkan eventhough llama.cpp had vulkan support for a long long time now.

This has been very sad to watch. I'm more and more convinced that vllm is the way to go, not ollama.
> it could know that something is more commonly cited based on its training data

No there is no such concept or way to do something like that. LLMs do not have such kind of meta-knowledge over their training data or weights. But there could be explicit mentions about this on their training data and they could pick on that and that is probably the simplest explanation.
If that’s where the group is, you refuse to be part of that group. Nobody is going to inconvenience themselves for an outsider.

There is obviously variety is what tools groups use though.
> An example, such as an automated test, can serve as a proof of an existentially quantified proposition but isn't itself one. For example, 3 > 2 is a proof of `∃x∈Int : x > 2` (because P(C) ⊢ ∃xP(x)) but isn't itself an existentially quantified proposition.

Yeah, I hand-waved this a bit when I said "if we squint at the test suite for a 'sort' function, we'll see propositions like...". I don't think it's too far off though, since we can (and, as I argued, should) tease apart the data from the assertion, to get something like `let x = 3; assert(x > 2)`; and that's equivalent to `(lambda x: assert(x > 2))(3)` (which old-school Javascript devs may remember as "IIFE", before JS had 'let').

> We can see that because if unit tests could express existentially quantified propositions then they could also express universally quantified ones by negation, which is available to tests, because existential and universal quantifiers are equally powerful, and can each be expressed in terms of the other as `(∀x : P(X)) ≣ (¬∃x : ¬P(x))` (we don't even need to resort to classical axioms because all domains are typically finite).

Hmm, I hadn't thought about that. If I try stretching my constructive-logic argument a bit, we could implement negation `¬A` as a function `A -> Void`. Rewriting your `¬P(x)` would give `¬∃x : (P(x) -> Void)`, and rewriting the remaining negation gives `(∃x : (P(x) -> Void)) -> Void`. In a constructive setting we can take `∃x : (P(x) -> Void)` to be a pair containing `x` and a function of `f: P(x) -> Void`, and hence to implement this in general we need to call that function `f` (since it's the only way to construct `Void`), so we need to construct an argument for it, which requires constructing `P(x)` for general `x`, and hence requires a proof of `P(x)` that holds for all `x` (i.e. universally quantified).

I'm not sure of my intuitions around this. I got the above by "following the types", but test suites rely on runtime execution, which is inherently untyped (e.g. every program in a typed lambda calculus also exists in untyped lambda calculus if we erase the types (and translate type-adjacent features appropriately, like dictionary-passing for type classes)). From an untyped perspective, the idea of `Void` becomes dubious; it feels like `P(x) -> Void` throws a `Success` exception, and that's the only way for a test to pass (returning normally is assumed to be failure, and `Success` is encapsulated so we can't throw it directly). That feels very strange to me, but worth thinking about some more...
That's more to do with increasing prices than decreasing demand
In order to win you often have to start before the problem is fully solved and then count on it being solved better as you build and scale.

Thus starting with engineering effort to fit some of the AI limitations make sense but realize many of those will be temporary and will be replaced in the future.

But there is always a new tech or framework or something that emerges after you start and adopting it will improve your product measurably.
The paper is talking about the reference and I'm talking about the reference in the paper.

Btw I think you're overestimating the degree to which what you say "logically follows".
Not “the people” but those in power in society created the cultural framework that incentivised people to get a lot of kids
Reasoning about the lifetimes of objects in an arena is as simple as it gets - there's only one lifetime, and pointers between everything allocated on the arena are perfectly safe. The complexity of figuring out what's going on, with with respect to the number of objects and links between is O(1).

There's no universal "God pattern" that you can throw at every problem. I used arenas as an example as I didn't want to write a zero-substance "OOP bad" post, but my point wasn't that instead of always using OOP+inheritance you should always use an arena, it was that if you think about your memory, more often than not there's a vastly superior layout than a bunch of heap objects glued together by prayers and smart pointers.
I think you're downplaying how well Cursor is doing "code generation" relative to other products.

Cursor can do at least the following "actions":

* code generation

* file creation / deletion

* run terminal commands

* answer questions about a code base

I totally agree with you on ETL (it's a huge part of our product https://www.definite.app/), but the actions an agent takes are just as tricky to get right.

Before I give Cursor, I often doubt it's going to be able to pull it off and I constantly impressed by how deep it can go to complete a complex task.
That was really great. I did 7 waves on the phone and had fun!
The music was phenomenal
It’s a classic yeah! [edit] The fact this works is because of the lack of filters or tuned circuits, its basically an amplified diode (you can even do without out it tbh)

But small correction, in this case it seems to be:
Antenna > Rectify > Amp > Headphones

Right? Ofc you can add more - rf or audio - amps between the antenna and headphones. But yeah. The lm386 is pretty interesting for this use, try it out, you will surprised what you will hear (from a mess of all nearby stations all mixed together to em emitting devices in your location and possibly ghosts (:p).
I think the brilliant minds working on this know this. It shouldn't stop things just as we'll die one day doesn't stop accumulating wealth or working hard.

But at some point I hope there's breakthrough from any entirely different paradigm.
It's a little depressing how many high valued startups are basically just wrappers around LLMs that they don't own. I'd be curious to see what percentage of YC latest batch is just this.

> 70% of Y Combinator’s Winter 2024 batch are AI startups. This is compared to -57% of YC Summer 2023 companies and ~32% from the Winter batch one year ago (YC W23).

The thinking is, the models will get better which will improve our product, but in reality, like the article states, the generalized models get better so your value add diminished as there's no need to fine tune.

On the other hand the crypto fund made a killing off of "me too" block chain technology before it got hammered again. So who knows about 2-5 year term but 10 year almost certainly won't have these billion dollar companies that are wrappers around LLMs

https://x.com/natashamalpani/status/1772609994610835505?mx=2
I'm sorry for asking the obvious, which I put on account of not running a business in an oligarchy, but what the heck is the angle, here?

What's to gain for Meta (and presumably others) when the new administration hasn't been inaugurated yet? They obviously can't say that they are compelled by law to do that, but they very much renege the eventually of saying "they forced us to do that" when the policy landscape will inevitably flip. This is pure signalling, with the effect of putting off about a half of the local population deemed progressive, and alienating most of the developed world. Whatever might be on the other side of that bargain must be disgustingly "generous".

If I was an evil despot about to be crowned, I don't know how I would feel about that: true this is a bunch of sycophants willing to kiss the ring, on the other hand "who do you think they are?". Anyhow, I probably be a terrible despot, too.
According to many press stories in the past year, the relationship between Microsoft and OpenAI has been very strained. It looks more and more like that both sides are looking for opportunity to jump ship.

This is a very clever move by Microsoft. OpenAI has no technological moat and a very unreliable partner.
I'd think that this only means that a model cannot suffer from overfitting on average. So, it might totally have been overfitted on your specific problem.
PG liked him, because Altman decided to go to great lengths to get PG to like him.

While Drew, Chesky and the Collison brothers were busy building billion dollar companies, Altman took the “shortcut” and made a concerted effort to cozy up to the most powerful man in the room — and it payed dividends. Altman did the same thing in the early OpenAI days by doing flaterring video series interviews with Elon Musk, Vinod Khosla and others [0]. Incidentally, The YC interview with Elon Musk was done the year Musk made a donation to OpenAI (2016),

I still remember PG’s essay where he gave Altman the ultimate character reference (2008) [1]:

>When we predict good outcomes for startups, the qualities that come up in the supporting arguments are toughness, adaptability, determination. Which means to the extent we're correct, those are the qualities you need to win…Sam Altman has it. You could parachute him into an island full of cannibals and come back in 5 years and he'd be the king. If you're Sam Altman, you don't have to be profitable to convey to investors that you'll succeed with or without them.

(In retrospect, praising Altman for being the “king of cannibals” has a nice touch of gallows humor to it. Hilariously, even recently pg has a seemingly unintentional tendency to give Altman compliments that appear to be character warnings masquerading as compliments.)

In 2009, pg included Altman in the top 5 in a list of the most interesting startup founders of the last 30 years.[2] If this was an observation made from afar, you could easily say it was “prescient”. But objectively at the time, no one could find any verifiable evidence in the real world to justify such an assessment. It wasn’t prescient because pg had became directly responsibly for Altman’s future success, in a case of self-fulfilling prophesy. Altman was often referenced in the acknowledgments of pg’s essays for reading early drafts and is probably referenced more than any other founder in the essays. Altman’s entire streetcred came from pg and also, once he made Altman head of YC, YC. From afar, it looks like a victory for office poltics, a skill incidentally that sociopaths are known to excel at.

[0] https://www.youtube.com/watch?v=tnBQmEqBCY0

[1] https://www.paulgraham.com/fundraising.html

[2] https://www.paulgraham.com/5founders.html