| ▲ | dmix 3 hours ago |
| Finding the bugs with LLMs is easy. Reviewing the output, cleaning it up, and making sure it doesn't break something else is the hard part. |
|
| ▲ | black_knight 17 minutes ago | parent | next [-] |
| This is where I believe strong typing (like, Haskell-strong or stronger) and functional programming in general will be a win. The confidence I have that my fixes are localised when fixing Haskell code is infinitely stronger than fixing even Java, not speak about C, code. |
| |
| ▲ | astrange 7 minutes ago | parent | next [-] | | Haskell's type system would not easily prevent this bug. It's not good at numeric/logic issues like that. When people say "Haskell makes it impossible to write bugs" they mean "Haskell has enums" (ADTs). | | |
| ▲ | black_knight 2 minutes ago | parent [-] | | I am not claiming you cant write buggy code in Haskell! But following good functional style, your bug will more likely be compartmentalised, and fixing it will not break some other part of your program. |
| |
| ▲ | theLiminator 7 minutes ago | parent | prev | next [-] | | Imo, formal methods like more expressive/stricter type systems are key to making LLM generated code successful. Of course models will get better, but trusting the output will become much easier with a type system that proves more properties. | |
| ▲ | fouronnes3 8 minutes ago | parent | prev [-] | | What's stronger than Haskell? | | |
| ▲ | black_knight 5 minutes ago | parent | next [-] | | Dependent types is one possible direction. Not sure when a language with dependent types will arise which will be useful for making real programs. Agda is the most mature dependently typed programming languae (having been around since the 90s – it is basically Haskell on steroids), but has a more proof-assistant flavor than an actual programming language flavor. Opus & Fable write Agda quite well, so LLMs can understand dependent types. | |
| ▲ | TheGoddessInari a minute ago | parent | prev | next [-] | | Lean 4, Idris 2. | |
| ▲ | astrange 6 minutes ago | parent | prev | next [-] | | Anything with ranged numeric types. Like everyone's favorite functional programming language, Ada. | | | |
| ▲ | theLiminator 7 minutes ago | parent | prev [-] | | Perhaps coq/agda/idris/etc. |
|
|
|
| ▲ | nonethewiser an hour ago | parent | prev | next [-] |
| No one can keep up with the volume of code AI produces. We wont stop using AI. We will use AI to check AI. Of course this is crazy, but it will also unlock pretty insane scaling and productivity and ultimately we will manage it on either end via requirements and tests. |
| |
| ▲ | harambae an hour ago | parent | next [-] | | It's mostly (not entirely, but mostly) finding security issues in old human-written code. It'll eventually start running out of those. From that standpoint, it's not a crazy setup security-wise. Maybe still crazy for development. | | |
| ▲ | stefan_ 34 minutes ago | parent [-] | | You can point AI at any AI produced code and ask it to review it, get back 10 bullet points and a few pages of prose. And the fun part is, you can do that over and over and over again! |
| |
| ▲ | CPLX 4 minutes ago | parent | prev | next [-] | | In fairness at root this has been going on for awhile. No one can keep up with the volume of machine code that modern more abstracted codebases produce. We didn't stop using syntactic programming languages we used code to check code. Not sure it's really crazy at all. It's been an abstraction for programmers probably since we stopped soldering transistors to each other. | |
| ▲ | krona an hour ago | parent | prev | next [-] | | You're suggesting that LLMs get better at fixing bugs/vulnerabilities, but at the same time stop getting better at finding them? What if this difference is inherent and essential? | | |
| ▲ | TacticalCoder 33 minutes ago | parent [-] | | > You're suggesting that LLMs get better at fixing bugs/vulnerabilities, but at the same time stop getting better at finding them? Are you implying that all code writing by LLMs atm is bug-free? |
| |
| ▲ | an hour ago | parent | prev [-] | | [deleted] |
|
|
| ▲ | hombre_fatal an hour ago | parent | prev | next [-] |
| The missing part of this is that verifying the bug with LLMs is also easy, and so is adversarially reviewing the proposed fix with LLMs. The only thing left for you to do should be directional decisions. The LLMs should pause and rope you in if the fix involves directional/invariant changes. |
|
| ▲ | 2 hours ago | parent | prev | next [-] |
| [deleted] |
|
| ▲ | bewareofscams 2 hours ago | parent | prev [-] |
| [flagged] |
| |
| ▲ | shevy-java 2 hours ago | parent [-] | | > LLMs do find bugs, do save time They find bugs but whether they save time is nowhere near as clear as you try to insinuate here. | | |
|
