I imagine this can very useful for Go-based forges that need syntax highlighting (i.e. Gitea, Forgejo).
I have a strict no-cgo requirement, so I might use it in my project, which is Git+JJ forge https://gitncoffee.com.
I don't think that "Code you did not write is code you do not understand" implies that the only way to understand code is to write it. I can read code, run it, debug it and figure out how it works.
It's true that all of that is possible with AI generated code. But the thing is, is it worth for me spending time understanding that PR, when I can make the change or launch my own agent to prompt it myself? At least with my own prompt I know exactly what I want it to be.
This would make sure this data is part of repository history (and commit SHA). Additional tooling can be still used to visualize it.
I see this doesn't use <textarea> or contenteditable, I'm curious how close can it get to native controls or can this replace them? Things like mouse selection and usual hot keys like Cmd+A and maybe other things.
Currently just the cloud hosted version (https://gitncoffee.com), but plan to open-source most of it when it's more complete.
If you want to see a repo example, https://gitncoffee.com/gitncoffee/git-demo
It goes to extreme lengths to ensure great performance, i.e. rewritten most server-side parts of git from scratch, so there is no "exec"-ing git nor calls to libraries like libgit2. The frontend should also be very fast thanks for HTMX.
I'm not convinced that review comments as commits make thing easier, but I think storing them in git in some way is a good idea (i.e. git annotations or in commit messages after merge etc)
With many engineers using copilots and since LLMs output the most frequent patterns, it's possible that more and more software is going to look the same, which would further reinforce the same patterns.
For example, emdash thing, requires additional prompts and instructions to override it. Doing anything unusual would require more effort.
yeah, I plan to release it under AGPL at some point when it’s more complete. Currently it still needs more work. But no timeline yet.
Gitpatch attempts to build a Git hosting with native support for patches and commit-based review system, where each commit is its own patch. It's also smart to handle force pushes and can update or reorder patches as needed.
Gitpatch is a bit different. It implements a new storage backend and Git library from scratch. It also uses patch-based model for code review vs pull requests, where specially-named branches are used to submit patches and patch stacks.
I know this is completely different scale, but compare: [1] https://github.com/git/git [2] https://gitpatch.com/gitpatch/git-demo
And there is no page cache. Sub 100ms is just completely different experience.
Git hosting for async teams that supports versioned patches and patch stacks instead of pull requests. All done using the standard git SSH protocol, so no git-send-email needed.
See also the difference between reset, restore and revert https://git-scm.com/docs/git#_reset_restore_and_revert
Hey HN,I built Gitpatch to make sending code patches as simple as git push.The idea is that patch-based workflows are powerful but they're not very well supported by git platforms.Gitpatch brings this model to any repository:* Send patches by pushing branches (e.g. patch/my-patch-name)* Apply any patch locally with one command* Review them in a lightweight UI* Stack patches with patchstack/...
V8 supports script interruption for contexts. Engine puts interrupt guard checks into every function and every loop. So its possible to interrupt context even in a middle of infinite loop.
Yes, system doesn't solve multicore balancing problem for applications automatically. The idea is that every app can use available cores on a machine similar to a fixed size thread pool. So it can manually schedule tasks for available cores.
Whats interesting, that this thread pool could provide transparent access to computing power on other physical machines. So this should be pretty scalable.
GC pauses. Yes, this is a problem, but it shouldn't corrupt any data. I think hardware interfaces should provide some kind of error checking mechanism with the option to retry transmission. Worst case - critical parts implemented in native code.
Another idea how to deal with GC pauses is to reserve one core specifically for V8 concurrent GC tasks for every other core. Additionally this core can take care of all interrupt handlers.
Built on V8 engine and actually boots on my hardware :)