Good luck.
I once knew how to fix shift/reduce reduce/reduce errors, but that was a long time ago.
With recursive descent parser you need to check for left recursion, which is somewhat less tricky.
the default writing style of 'Google AI mode' is less tiresome than that of Claude or ChatGPT. I wonder if the difference is due to training or due to prompting.
We usually see this kind of discussion around weekends. To me it looks a bit like psychological warfare, designed to drive up the mega valuation of some IPO candidates, in other words: to make LLM based systems more valuable by bashing an entire class of workers.
I don't quite believe in the doom scenario: a lot of stuff depends on the correct functioning of software. However language model don't have a complete model of reality, they won't be able to evaluate if a given change is sufficient. Therefore systems based on language models will not be able to provide complete solutions - for some time to come. There will still be quite a bit of work in software development.
You can't come up with a counterexample for P != NP because there isn't a formula to disprove. For P = NP you would propose a general algorithm to convert all NP problems into P in P time, and an AI could then find a counterexample which would disprove that particular method. To demonstrate P != NP you need to prove that no possible algorithm can convert any NP into P which is much harder than providing a counterexample.
AI has just gotten to the intelligence that it can make clever counterexamples to mathematical conjectures, but the frontier isn't quite smart enough that it can make novel contributions to mathematics. We are really close though. Only a matter of months away.
The paper does not resolve P versus NP, but it does make an important advance in a closely related area. To prove that P ≠ NP, it would be enough to show that every algorithm for an NP-complete problem requires superpolynomial time. We cannot prove anything remotely that strong. For explicit NP-complete problems in unrestricted computational models, we cannot even prove superlinear lower bounds. There is therefore an enormous gap between the lower bounds we can prove and the superpolynomial bounds we would need.
VP and VNP are closely related algebraic analogues of P and NP. Here the paper proves new lower bounds for computing the permanent, a VNP-complete polynomial, in particular models of arithmetic computation: roughly (n^2\log\log n) arithmetic gates for unrestricted division-free circuits, and (n^4/\log n) size for the more restrictive formula model. These are still polynomial bounds, so they do not separate VP from VNP. But lower bounds on the resources needed to compute explicit functions are exactly what would ultimately be required for such a separation, and meaningful lower bounds of this kind are exceptionally rare.
> "Everything is a Remix" is a good watch on youtube that explains this
Not completely. Novelty used to be a major thing, when Humans did it. Another important criteria used to be if that new thing makes sense at all. Here the language model has a problem, as it doesn't have the means to evaluate this criteria.
I think this is a veiled advertisement for Norway. Half of the world is engulfed in wars and terror (half across the road towards Mad Max), however Norway is worrying about the environmental effect of salmon feces on its fjords.
Eh foreign correspondent stuff like this tends to release at the end of a long pipeline. They spent 12 months on a piece on Israel that was focusing on the conditions of Palestinians near Israeli settlements in the West Bank, and it dropped a couple weeks after October 7, you could tell that they were pissed that it wasn't about Gaza, but were still happy to be in roughly the correct ballpark.
There other arm, 4Corners, did a piece about a big government construction project and IIRC there was a different prime minister when it released vs when they started the investigation.
Interesting link, thanks. What about the contradiction between the next two sentences?
“a human may select or arrange AI-generated material in a sufficiently creative way that ‘the resulting work as a whole constitutes an original work of authorship.’”
"copyright would extend to the material the human author contributed but would not extend to the underlying AI-generated content itself."
The linked document is mentioning the act of selecting AI generated images for a comic book as an example, where the result is adding material that is copyrightable on its own merit. I am not sure if the same line of reasoning would apply to programming.
"in one early case, for instance, the Office found that the
selection and arrangement of AI-generated images with human-authored text in a comic book were protectable as a compilation."
I think that AI is adding an extra layer of politics to just about everything. It is as if we are entering a phase of super-extra politics, as everyone is trying to figure out what should come next.
Instead of a war with machines we get an eternal war among lawyers and managers. Don't know which prospect is worse.
1) By the time I’ve determined, and expressed to my satisfaction, exactly what I want, I’ve already done the hard work of coding that thing. The rest is fairly mechanical by comparison.
2) It’s a universal truth (which I know someone’s gonna argue with :D ) that reading and working with other peoples’ code is much less fun than reading and working with your own. This applies even if the other people are robots.
3) When checking and troubleshooting code, the bulk of the time is spent understanding it in the first place. If you wrote the code yourself this already implicitly happened and is ‘free’.
Put those four[1] things together and at least for me personally, AI-assisted coding isn’t a better experience than just doing it myself. It’s still great for bootstrapping yourself into a new unfamiliar language/environment though.
"I love building software, I just don't like the data entry parts", to paraphrase a guy I worked with once who explained how he loved writing design docs for junior engineers to implement.
I don't personally know anyone who writes code any more (for work). Is this not the case for you?
The distinction I see now is between teams that read PRs and teams that don't. I still think the former is a good approach... for now, but I don't expect this will necessarily be the case in a year (or less).
This article was such an inspiration to me when I was younger, and the advice, for that time, was very correct. However seeing it today really drives home how big the gap is going to be in really understanding code in just a few more years.
Cutting-edge models are capable of much more than generating CRUD apps and understanding the details is orthogonal to whether you wrote the lines yourself or not.
>understanding the details is orthogonal to whether you wrote the lines yourself or not
Reading the code does not give you the knowledge of the 10 different approaches you would have tried and failed before coming up with that code. Why exactly a piece of code is the way that it is cannot be determined by just reading the code.
Reading a mathematical proof does not give you any meaningful understanding of it.
You haven't considered that I probably already discussed 10 different approaches with my agent before authorizing a particular implementation. Or that I didn't ask about alternatives during review. You're confusing physically coding with thinking. You can still think just fine without writing code yourself.
If you are experienced, attentive, curious, willing to explore, etc., that doesn't change after an LLM allows you to deeply discuss any concept at will, quickly try different prototypes and zone in on the correct implementation. You will use these tools to their full extent.
> Why exactly a piece of code is the way that it is cannot be determined by just reading the code.
If you maintained a good commit history and your code is self-documenting and you're not capable of understanding and navigating code you read, you can still literally just ask the LLM to explain the code within the context of the codebase. They are extremely good at that exact task. They will give you as much as you give them. If you want to know, and can understand, the nitty gritty, you can do that and no one is stopping you.
> Reading a mathematical proof does not give you any meaningful understanding of it.
Again: these things can function as personal tutors. Run the proof through an LLM and ask it what you care about. Furthermore, there are plenty of elegant proofs you can read which confer "meaningful" understanding.
Before just assuming that everyone telling you these tools are useful is less capable or experienced than you, it's worth considering if it's actually you who needs to maintain an open mind and attempt to learn from others.
Yeah, I disagree on the latter point by a lot :-). Really, is it truly "orthogonal"? Not really, you will understand the details better by writing them yourself. On your first point, they are pretty good at a lot of stuff, given that they have seen it before. A lot of the time, I'm writing code that no LLM has seen before. That sounds super smug, but it's "da tru tru".
I welcome you to prove this conjecture, otherwise it's just vibes.
> A lot of the time, I'm writing code that no LLM has seen before
I hear this tired point over and over from people who cannot fathom that others who use LLMs successfully could possibly also be working in a specialized domain. Frontier models are excelling at difficult, long-horizon tasks now. I write all sorts of esoteric stuff, and I can confidently hand a frontier model specification for a language it's never even seen before, working in a domain it's never encountered, and likely get good results, provided I have the knowledge and experience to guide the model.
The reality is that this "they are only good at things they have 'seen before'" talking point that often gets parroted is vaguely defined and largely based in opinion. Obviously, models perform worse when the input or expected output are out of distribution.
But this was much more true a couple years ago than it is today; the gap has closed considerably, and those who are learning to think deeply with these tools will be better positioned than those who arrogantly think that their process cannot be augmented by the most intelligent systems ever created.
This is HN, most of it is vibes. Lol, conjecture, touch grass man. I do PL research, it's not that good at that stuff, do you think I'm not trying using it?
You're claiming that one cannot understand the details of well-documented and well-written code which they did not write themselves, and I'm pushing back asking for proof. We can move on from this though, I'm more interested in where you currently feel they fall short doing PL research. I think the state of frontier models today in this area is a lot better than it was even six months ago and I think there's still room for improvement.
Programming without writing, to me, feels like doing mathematics by reading proofs but not doing proofs. Which quite frankly works very poorly for me. I write code if, for nothing else, so that I can spot bad code/proofs with an easier time, rather than dealing with an equation that blew up in prod.
Reading the code will not give you the same mental model as writing it. Sure you can catch some high level issues, but the brain is incentivized to skip over the lines which look like boilerplate. any issue in between boilerplate is going to be unnoticed.
The original sin of the programming industry is not valuing expressive notation and expressive programming languages. (I am not talking about map/filter/reduce level party tricks but better metaprogramming and coherent abstractions). No amount of sacrificing tokens for Anthropicus is going to give you the same amount of understanding as writing the program.
I do not know anyone competent who stopped writing code. You have to write the code yourself if you want good results, or spend so much time reviewing the clanker that you may as well have written it yourself.
Claude isn’t even good enough for Anthropic to release native desktop applications for each OS. As someone said in a comment in a different post here, it seems like these tools are good at web and web related (like Electron) development.
Anthropic intentionally missed the opportunity to show that its models can develop really good native applications.
OpenAI’s latest desktop applications seem to be worse than before too.
At some point there will be no one left to review Claude generated code. I think that will be an interesting time, given our reliance on software based systems...
A linked-in post on CS enrollment at universities:
"In the past two years, the drop was ~20% at UC Berkeley and ~30% at UC Davis, while UC San Diego is the only one still rising."
On the other hand: LeetCode traffic rankings are up, so some people still solve programming problems by hand - or they hope to get a job, by being able to solve them.
I suspect that distillation attacks may be slightly exaggerated.
Most of the training data used during fine-tuning is now synthetic data. You can't just repeat the same stuff twice, therefore another LLM is writing a text book that is explaining a topic in detail, ideally without any gaps in the material.
reply