ninjha

> as of 2020 most researchers believe that backfire effects either are unlikely to occur on the broader population level, or only occur in very specific circumstances, or do not exist

from your link

They only proved that one exists; computing the actual construction is non-obvious (the naive way to construct it is computationally infeasible).

> how many work units can run in parallel

not original author but batching is one very important trick to make inference efficient, you can reasonably do tens to low hundreds in parallel (depending on model size and gpu size) with very little performance overhead

> matrix would be everywhere

now i know the bar is 1000 feet below the earth with teams but matrix is still only maybe a foot or two above the surface

i really want to like it but every few months i try it and it’s clearly just not ready :(

most slop is human slop, who do you think claude learned from :)

yeah there is apparently not a lot of overlap between hn/twitter users and devin users, and we don’t really do marketing campaigns either

logos on website if you want to see some of our customers lol

(I work at Cognition, opinions my own etcetc)

True! Devin Review doesn’t make the kind of judgements you mention, it just does its best to find bugs and help you understand the code faster. I managed to review a PR on an airplane (without starlink) with it earlier this week lol

jj-spr solves this, although it is still pretty buggy: https://github.com/LucioFranco/jj-spr

I was scared to learn but then a coworker taught me the 4 commands I care about (jj new, jj undo, jj edit, jj log) and now I can't imagine going back to plain git.

Obviously the working tree should be a commit like any other! It just makes sense!

Codeium (now Windsurf) did this, and the plugins all still work with normal Windsurf login. The JetBrains plugin and maybe a few others are even still maintained! They get new models and bugfixes.

(I work at Windsurf but not really intended to be an ad I’m just yapping)

I think I remember one of the original ViT papers saying something about 2D embeddings on image patches not actually increasing performance on image recognition or segmentation, so it’s kind of interesting that it helps with text!

Yes! The retransmission logic in Linux NFS is independent of transport (see the `retrans` option in `mount.nfs`).

Weirdly enough this also means that if you’re running with TCP you can have retransmits at the NFS/SunRPC level and at the TCP level depending on your configuration.

Is there anything in particular you like about what Octant does? I don't see anything that actually looks at the object spec, just the status fields / etc.

I mean you can edit a big YAML file inside ArgoCD, but what I'm building is an actual web form (e.x. `spec.rules[].http.paths[].pathType` is a dropdown of `Prefix`, `ImplementationSpecific`, `Exact`), and all your documentation inline as you're editing.

People have tried this before but usually the UI version is not fully complete so you have to drop to YAML. Now that the spec is good enough it's possible to build a complete UI for this.

You can have Click-Ops on Kubernetes too! Everything has a schema so it's possible to build a nice UI on top of it (with some effort).

My current project is basically this, except it edits your git-ops config repository, so you can click-ops while you git-ops.

The two almost-contradictory takes I hold about this are…

- Java is cool, actually

- Java would be just as uncool even if people weren’t required to use it in school

Having deployed a few of these over the last month or so, I feel like the devcontainer spec is very annoying. The alternative is what Coder does -- write some arbitrary terraform to bring up or down a workspace. I think this is better because I tend to need other things to go in a workspace (like an IAM role to access dev databases, associated Kubernetes resources, etc). With terraform I can configure whatever infrastructure I want to go along with workspaces.

The main downside I can see is that users have to write their workspaces for a particular deployment target. This would be a problem for e.x. open source projects trying to check in a workspace definition file of some kind. We standardize on Kubernetes across clouds and bare metal so it's not an issue for us, but it makes sense that it would be an issue for other use cases.

I think Chisel's main win is that it is great from an open-source research perspective.

Taking advantage of the functional nature of Chisel enables a set of generators called Chipyard [0] for things like cores, networking peripherals, neural network accelerators, etc. If you're focusing on exploring the design space of one particular accelerator and don't care too much about the rest of the chip, you can easily get a customized version of the RTL for the rest of your chip. Chisel handles connecting up all the components of the chip. All the research projects in the lab benefit from code changes to the generators.

Chisel even enables undergraduate students (like me!) to tape out a chip on a modern-ish process node in just a semester, letting Chisel significantly reduce the RTL we have to write. Most of the remaining time is spent working on the physical design process.

[0]: https://github.com/ucb-bar/chipyard

[1]: https://classes.berkeley.edu/content/2023-Spring-ELENG-194-0...

> their long context window isn't that accurate

Apparently this was just a function of how it was prompted, they claim it works fine if you use a different prompt -- https://www.anthropic.com/index/claude-2-1-prompting

Architecture-wise, even a regular modern CPU isn't that hard. For example, Berkeley has the BOOMv3 core[0] which is performance-competitive[1] with commercial chips taped out in the last few years. I think commercial chips are faster because of improvements in analog design, and not some super special architecture sauce (although I'm sure there's some special sauce -- it's probably not the defining factor).

[0]: https://boom-core.org

[1]: https://carrv.github.io/2020/papers/CARRV2020_paper_15_Zhao....

I would have assumed the win here would be that your Linux distribution or package manager on another OS can compile "VSCodium" themselves -- and you already trust them for all your other software, so this simplifies the trust chain somewhat.

In reality I think distributions that are willing to ship binaries (NixOS, Homebrew on MacOS) ship VSCodium, and other distributions (Alpine) have packages called things like `code-oss` that are basically the distribution's internal compiled version of VSCode and have nothing (?) to do with VSCodium.

In my day to day, 5G uses more battery, has similar speeds to LTE, and is less reliable than LTE... I just go into settings and turn off 5G.

Occasionally I'm at the airport (or someplace with the "real" wideband 5G) and I want to download a movie quickly. At that point I turn on 5G and get 2 Gbit down, which is convenient!

Yup, others have done the docked thing after installing gnome-shell. Haven’t tested it myself since I have an older PinePhone where this wasn’t functional.

I wouldn’t say any apps work “well” on mobile - but everything that works on mobile is usable on desktop.

Oh hey, this is a project I started a while ago. It's a little buggier than the other PinePhone distributions because most of our apps are straight from the "Real" Fedora repository and aren't patched. [1]

General sentiment in the thread is that this is not a replacement for Android or iOS: you are correct.

I can answer questions if people have any.

[1]: https://github.com/nikhiljha/pp-fedora-sdsetup

Kubernetes is a multi-physical-machine operating system. In a typical OS you have CPU, RAM, etc. and the kernel decides how much of each to allocate to each running task. Kubernetes works the same way, but across multiple computers by default- and it can additionally manage any other arbitrary resource through the use of CustomResourceDefinitions (IPs, higher level concepts like “Minecraft Servers”, etc.)

I’m working on this right now. My theory is that having every cluster object defined in git (but with clever use of third party helm charts to reduce maintenance burden) is the way to go.

Our cluster configuration is public[1] and I’m almost done with a blog post going over all the different choices you can make wrt the surrounding monitoring/etc infrastructure on a Kubernetes cluster.

[1] https://github.com/ocf/kubernetes

Also, the course materials for CS61C at Berkeley (https://cs61c.org/) are publicly available if you want an intro to RISC-V/Verilog.

Lecture videos for the current semester are no longer public thanks to some lawsuit, but you can find videos from previous semesters on YouTube.