rorytbyrne

We would need to normalise query length by the success rate to draw any informative conclusions here. The rate of immediate follow-up queries could be a decent proxy for this.

He thinks the IQ of white people (North America and Europe) is 100. He’s implying the rest of the world are lower IQ.

A fair point, but I think the "Old English" people (Hiberno-Normans) are not usually considered part of the protestant ascendancy.

The “Protestant Ascendency” are not Irish, even if they technically lived and were born on the island.

I grew up on a farm near the hills of The Burren in the west of Ireland. If you look closely, you can see walls made of stacked stones cross-crossing the hills, as if to demarcate farmland - but those hills are not arable farmland, so why? The British refused to offer free food to the starving, so they made people build these completely pointless walls to “earn” the food. They’re now known as the Famine Walls.

https://en.m.wikipedia.org/wiki/Famine_walls

I highly recommend taking a dynamical systems class, if you ever get the chance. It's shocking how many seemingly unrelated things just "make sense" when you know what a limit cycle is and how bifurcations work.

Thank you!

The immediate benefit is that "what commit produced my last good result" is a local problem, so a local solution is faster and more convenient than a round-trip to an API.

But more broadly, storing data locally makes it easy for others to build tools on top of the data. E.g. a visualisation tool that plots hyperparameters vs metrics, by parsing the metadata from `logis` commits.

Also scientists often don't commit regularly, so there is an opportunity to hijack the commit log for their benefit. Every cycle of edit->run-experiment is an iteration of the scientific method, and capturing that automatically is arguably more valuable than sporadic commits with "stuff" as the message.

Does anyone know of tools that go the other direction? i.e. taking a technical writeup (scientific paper, architecture docs, or similar) and emitting a candidate codebase.

This seems useful for building new tools. It's not strictly an end-user tool.

Oh true, forgot about that. You need someone to invite you IIRC.

Missing lobste.rs

I do neuro/ai research, so I have to instantiate a lot of Tensors from YAML definitions (that's how I define models declaratively). I built a middleware to simplify this, using intermediary pydantic models as "blueprints" for building complex objects during pydantic's build process. It lets me pass parameters (e.g. mean and standard deviation) into `thing.model_validate(...)`, and get a fully-built Tensor in the appropriate field of the model.

https://github.com/flywhl/cyantic

---

Example:

If you write a blueprint like

  @blueprint(Tensor)    
  class NormalTensor(Blueprint[Tensor]):

      mean: float  
      std: float  
      size: tuple[int, ...]  

      def build(self) -> Tensor:  
          return torch.normal(self.mean, self.std, size=self.size)  

and a data class like

  class MyModel(CyanticModel):  
      some_tensor: Tensor  

you can construct MyModel using mean and std instead of a Tensor:

  some_yaml = """common:  
      size: [3, 5]  
  some_tensor:  
      mean: 0.0  
      std: 0.1  
      size: @value:common.size  
  """

  my_model = MyModel.model_validate(yaml.safe_load(some_yaml))  

You can also pre-process the data using `@hook` references, and there's an API for defining custom hooks.

There's good test coverage and I think the library is ready for use, but would appreciate issues if you come across any bugs.

Thanks for reading

No, they are designed to elucidate the author's thought process - not the reader's learning process. There's a subtle, but important difference.

Also: https://web.stanford.edu/class/ee384m/Handouts/HowtoReadPape...

But if they want to capture (or create, commercially) the market they’ll probably price it closer to $20 or under.

As a working scientist, this is a hugely underserved category in academic/industry science. This would be very welcome.

The green card exists, so there must a priori be a valid path to get one. If it's not H1-B, then what is it?

You could continually learn a distribution over AI responses and search for outliers to surface with urgency for approval.

> the 90s IDM/jungle/trance is superior to modern EDM/house/trap

This is your own fault for going to EDM/house/trap parties. Go to better parties, then you'll find better music.

It doesn't take the whole repo as context, it tries to guess which files to look at. So if you prompt with that in mind, it works well. Haven't tried it on a very large codebase though. You can also explicitly add files, if you know where work should be done.

Just work on a branch and squash.

Implementation quality should always be high, that is standard practice for engineering disciplines.

MVP is a good approach when interpreted correctly: “minimum” is in reference to the feature set, not the implementation quality.

Or a professional politician proposed a good policy and the professional political commentator made a good comment on it?

Not everything is a conspiracy.

"X is a new version of Y" is a really uninformative way to introduce a project.

It's especially annoying when I click the link to Y and it just says "This repository contains the source code for Y".

Excuse me, the what now?

I think the idea is that it's easy to eat only 500 calories, if the only food available is potatoes. Which should surprise absolutely no one.

Potato was the only food eaten by the majority of Irish people, up until 1848.

An average man ate up to 60 potatoes per day.

Consumer blogs have been gushing over Macbook Air M1 for years, and most of them say not to even bother getting a Pro because it's so good.

I also have this problem, so I made a tool that lets you write your commit messages in-advance. It helps me to focus on one problem at a time.

https://github.com/synek/git-plan

One feature I wanted to add was for it to parse your source code for comments with a specific format (e.g. `# git-plan feat xyz` or `# git-plan fix xyz`) and then stitch all the hunks together into commits for you. So all you'd have to do is comment your code and then run `git plan commit` and it would generate commits for you to confirm with y/n.

I built a prototype of that here:

https://github.com/synek/codeline

I haven't worked these for a while unfortunately :(

Funny you say that, because I built that as well: https://github.com/synek/codeline

It's even earlier in development than git-plan, but the `commit -m "some message"` command works.