stopthe

At $JOB we have an "AI adoption" dashboard, the more ai commits the better. I asked for the sources: the deterministic classifier, that decides whether a commit was ai-assisted, assigns the highest weight to the commits co-authored-by one of the known agents/models.

No. Even further than that, maintaining AGENTS.md and the like in your company repo, you basically train your own replacement. Which replacement will not be as capable as you in the long run, but few businesses will care. Anyway having some representation of an employee's thinking definitely lowers cost of firing that employee.

That is a cynical take and not very different from an advice to never write any documentation, or never help your teammates. Only that resemblance is superficial. In any organization you shouldn't help people stealing you time for their benefit (Sean Goedecke calls them predators https://www.seangoedecke.com/predators/).

On the other hand, it may be beneficial to privately save CLAUDE.md and other parts of persistent context. You may gitignore them (but that will be conspicuous unless you also gitignore .gitignore) or just load them from ~/.claude

I expect an enterprise version of Claude Code that will save any human input to the org servers for later use.

In hindsight, that would've been a real utility use case for NFTs. A decentralized cryptographic prove that some content existed in a particular form at a particular moment.

Some clarification. Since 2024 Yandex NV split into Nebius (NL-registred NASDAQ-listed company, no longer a search engine) and russian-based Yandex. The latter is fully controlled by russian investors.

The author (if there was any) stops short of admitting that it is yet another product that was heavily promoted via so-called influencers and failed to reach escape velocity and sell on itself. Like, nobody remembered Clubhouse already in 2021.

We've been using mongodb for the past 8 years. What we like:

- schema-less: we don't have to think about DDL statements at any point.

- oplog and change streams as built-in change data capture.

- it's dead simple to setup a whole new cluster (replica set).

- IMO you don't need a designated DBA to manage tens of replica sets.

- Query language is rather low-level and that makes performance choices explicit.

But I have to admit that our requirements and architecture play to the strength of mongodb. Our domain model is neatly described in a strongly typed language. And we use a sort of event sourcing.

Available in community edition 8.2+

https://www.mongodb.com/company/blog/product-release-announc...

Having dealt with similar architectures, I have a hypothesis on how this library (Hollow) emerged and evolved.

In the beginning there was a need for a low-latency Java in-process database (or near cache). Soon intolerable GC pauses pushed them off the Java heap. Next they saw the memory consumption balloon: the object graph is gone and each object has to hold copies of referenced objects, all those Strings, Dates etc. Then the authors came up with ordinals, which are... I mean why not call them pointers? (https://hollow.how/advanced-topics/#in-memory-data-layout)

That is wild speculation ofc. And I don't mean to belittle the authors' effort: the really complex part is making the whole thing perform outside of simple use cases.

Exactly zero, if answering your question as stated. But that is not the point. LLMs struggle with things that require tacit knowledge or are not found in the training set (i.e. haven't been done before). They excel at tasks that are described in the most verbose and explicit way, to the point that it looks humiliating from human POV. And what is more explicit than an existing codebase, especially with tests, comments and documentation lovingly put there by the proud author (remember, those github stars).

Unfortunately, the choice of license likely won't matter in the nearest future (if not already so). If a tech giant wants you open-source library, they will just point their agent to it and ask "to rewrite in the style of War and Peace". And more unscrupulous players won't even bother with a rewrite, as we've seen recently in the case of Cheatingdaddy/Pickle.

OTH the inefficiency of an analyst who cannot answer even basic questions about the current state of the product without developers' help. Distracting them, or even worse - blocking until a dev is available.

I think it boils down to the power of balance in the org. Likewise I've met developers who cannot book a meeting. Some people have privilege to choose what to learn and what to laugh at. Actually, I'm surprised your sales guys wrote any documentation at all:)

IBM is still selling hardware that roughly matches your description: DataPower Gateway.

business analysts don't get access to code or repositories at all for example or support people don't get access to the repositories and code.

Yes, but isn't it insane? What is the benefit from treating your own product as a black box? Yet that's mainstream. Sometimes I have the analyst (not on my team, but from a team we share a monorepo with) asking me questions that can be answered literally with a line of code. And she's a technical kind, knows SQL and such. And we write very idiomatic, high level code. But still, culture cannot change itself until it dies due to inherent inefficiency.

Brilliant, but... do you mind sharing the prompt?:)

https://www.chatterbox.io/ "Corporate language training powered by marginalised talent" - is that satire? Did I found the wrong Chatterbox?

That chess metaphor didn't age well

You may be striking the goldmine with this app. There's a lot of sentiment about the effects of tech on children and also parents spend money like no one else.

On a personal level I'm interested too. My son is too young, so we only watch youtube together, even then he's very susceptible to the attention-grabbing recommendations. "Theater mode" helps put the recommendations off-screen. "Don't recommend channel" helps a curate the feed a little bit.

But ideally I should be in control of the whole interface.

Of course, deletion is a whole different story. I was talking about addition in isolation.

Anyway, I felt I had to run the benchmarks myself.

  @Benchmark
  @Fork(1)
  @BenchmarkMode(Mode.Throughput)
  @OutputTimeUnit(TimeUnit.SECONDS)
  public Object arrayListPreallocAddMillionNulls() {
    ArrayList<Object> arrList = new ArrayList<>(1048576);
    for (int i = 0; i <= 1_000_000; i++) {
      arrList.add(null);
    }
    return arrList;
  }

  @Benchmark
  @Fork(1)
  @BenchmarkMode(Mode.Throughput)
  @OutputTimeUnit(TimeUnit.SECONDS)
  public Object arrayListAddMillionNulls() {
    ArrayList<Object> arrList = new ArrayList<>();
    for (int i = 0; i <= 1_000_000; i++) {
      arrList.add(null);
    }
    return arrList;
  }

  @Benchmark
  @Fork(1)
  @BenchmarkMode(Mode.Throughput)
  @OutputTimeUnit(TimeUnit.SECONDS)
  public Object linkedListAddMillionNulls() {
    LinkedList<Object> linkList = new LinkedList<>();
    for (int i = 0; i <= 1_000_000; i++) {
      linkList.add(null);
    }
    return linkList;
  }

  JDK8
  Benchmark                                      Mode  Cnt    Score    Error  Units
  MyBenchmark.arrayListAddMillionNulls          thrpt    5  229.950 ±  9.994  ops/s
  MyBenchmark.arrayListPreallocAddMillionNulls  thrpt    5  344.116 ±  7.070  ops/s
  MyBenchmark.linkedListAddMillionNulls         thrpt    5  199.446 ± 15.910  ops/s

  JDK17
  Benchmark                                      Mode  Cnt    Score    Error  Units
  MyBenchmark.arrayListAddMillionNulls          thrpt    5   90.462 ± 18.576  ops/s
  MyBenchmark.arrayListPreallocAddMillionNulls  thrpt    5  214.079 ± 15.505  ops/s
  MyBenchmark.linkedListAddMillionNulls         thrpt    5  216.796 ± 19.392  ops/s

Does it handle line breaks inside quotes in CSV? Frankly, I don't think its possible to reliably process CSV in а multi-threaded manner.

Did you count an allocation of LinkedList.Node<E> on every add operation? You may say it's negligible thanks to TLAB, and I will agree that fast allocation is Java's strength, but in practice I've seen that creating new objects gives order-of-magnitude perf degradation.

Well that gives some hope, unless they (I'm speculating about future possible employer) just disable WSL

A lot of people here are saying nice things about having dev environment on WSL. Honest question: how do you deal with with those minor but insufferable Windows' quirks like 0d0a line endings, selective Unicode support, byte-order-marks and so on.

While right now I enjoy the privilege to develop on Linux, things may change.

I always shrugged off the concept of code metrics (from LoCs to coverage) as a distraction from getting actual things done. But since doing more code-review I started to lack a framework to properly explain why a particular piece of code smells. I sympathize with the way the author cautiously approaches any quantitative metrics and talks of them more like heuristics. I agree that both Halstead Complexity and Cognitive Complexity are useless as absolute values. But they can be brought up in a conversation about a potential refactoring for readability.

What I didn't find is a mention of a context when reading a particular function. For example, while programming in Scala I was burnt more than once by one particular anti-pattern.

Suppose you have a collection of items which have some numerical property and you want a simple sum of that numbers. Think of shopping cart items with VAT tax on them, or portfolio positions each with a PnL number. Scala with monads and type inference makes it easy and subjectively elegant to write e.g.

  val totalVAT = items.map(_.vat).sum

You could append to the list of such things until the OutOfMemoryError. But it's such a beautiful and powerful language. Sigh.

That filter may be the advantage, but Mr. Tatham is just too polite to say that aloud.

One can argue that the described feeling is a product of suppressed instinctive behavior. Or, in other words, a detail of a particular implementation of intelligence in a certain species of mammals.

In my dreams, you have docs and source code in the same repo, and update both in a single pull request. In reality, confluence...

Wow, I'm glad that I visited HN when your tool was at the top. I'm going to use it to illustrate docs on our internal DAG-like system. By the way, is there a simple way to export the animated diagram as a GIF?

Russian air force has already destroyed numerous civilian buildings, in many cases killing dozens of people far behind the frontlines[0]. In at least one case, when 59 people attending a soldier's funeral were killed, there are "reasonable grounds to believe that the reception was the intended target of an attack, using a precision weapon"[1]. I think it shows that the military will be happy with much lower quality of classification than e.g. acceptable for driving in downtown San Francisco.

[0] https://en.wikipedia.org/wiki/Attacks_on_civilians_in_the_Ru... [1] https://www.ohchr.org/en/documents/country-reports/attack-fu...

My assumption is that only part of those $1 tn will go specifically into generative applications. The Goldman Sachs' paper in most instances mentions AI in general.

But one can also argue that actively seeking and choosing targets is a generative task, given a proper encoding of a battlefield situation and current mission.

World military spending is estimated at over $2 tn per year. Ongoing Russia's invasion in Ukraine shows that a hypothetical UAV with fully autonomous capabilities (because every known frequency is soon jammed) will meet enormous demand.