albertzeyer

Small self-advertisement: as an alternative to dissect.cstruct, a fun side-project of mine (C parser + C interpreter in Python) can do a very similar thing:

https://github.com/albertz/PyCParser/blob/master/demos/disse...

I think the simulation in Cities Skylines is also quite advanced, or not? The simulation is much more the reason why it requires powerful hardware to run on, much less the graphics.

More information about DwarfStar 4 (DS4) in the readme: https://github.com/antirez/ds4

The code seems based on llama.cpp and GGML.

I don't fully understand why it is a standalone project. The readme discusses this: DwarfStar 4 is a small native inference engine specific for DeepSeek V4 Flash. It is intentionally narrow: ...

I think the only bigger difference in DeepSeek V4 vs other models is maybe the type of self-attention. And that leads to: KV cache is actually a first-class disk citizen.

But I still feel like those changes could have been implemented as part of some of the other local engines.

I also assume more models will come out, not just from DeepSeek but also from others, and they might share similar self-attention approaches, that would benefit from a similar KV cache implementation.

The classic function coloring problem. https://journal.stuffwithstuff.com/2015/02/01/what-color-is-...

Why not just getting the changes/extensions upstream, welcome the Mac dev on the team, and make it an official port?

But these are not errors. These are just warnings you can ignore? It's not really so critical?

I'm curious: In the current moon flyby, how often did some of these fallback methods get active? Was the BFS ever in control at any point? How many bitflips were there during the flight so far?

73°C is a bit unusual cold for a Finnish sauna. Wikipedia says:

The temperature in Finnish saunas is 80 to 110 °C (176 to 230 °F), usually 80–90 °C (176–194 °F)

And with that temperature, I think 10–15 minutes are pretty standard.

Is that real-time or sped up? This video is about 1 minute. How much real time does it correspond to?

I wonder a bit about that. What activities or possibilities are you exposed at during that age.

I know many computer science colleagues who were not exposed to programming during that age and only later came to it.

I feel kind of lucky that somewhat randomly I stumbled into computer programming (because XtreeGold could show the content of files, and I was learning to understand BAT-files by looking into them) during that age, and that's what I do now.

There are probably a lot of things you were not exposed during that age, that could have been the perfect match.

There are also lots of kids who just play games, or video games, do sports, watch films or so during that age, without really being exposed to any "potential useful" activities. Some parents would maybe even say that this is how it should be.

As a parent, I guess a good advice would be to try to expose your child to as much things as possible, without forcing it to do anything of course.

https://wiki.python.org/moin/DebuggingWithGdb

I had registered for alerts on https://aurorasaurus.org/. But that alert was sent way too late for me (strongest lights were yesterday around 10-11 PM, and the notification was sent 2 AM today). But I was very lucky and just noticed the lights by accident on my way home.

v0: 16M Parameters

v0.5 123M Parameters

v1: 700M Parameters

v2mini-eval1: 300M Parameters

I would not call this LLM. This is not large. It's just a normal-sized LM. Or even small.

(It's also not a small LLM.)

Very nice!

This is released under GPL.

I wonder, who is K1n9_Duk3? Does he have the rights to actually release this, and put it under GPL?

What does "reconstructed" mean? Is this disassembled? And if so, is it really ok to put this under GPL then?

I think the point is that for most things, you don't need to call any external tools. Python's standard library comes already with lots of features, and there are many packages you can install.

The first linked article was recently discussed here: RIP pthread_cancel (https://news.ycombinator.com/item?id=45233713)

In that discussion, most of the same points as in this article were already discussed, specifically some async DNS alternatives.

See also here the discussion: https://github.com/crystal-lang/crystal/issues/13619

Which paper is that?

This idea is often used for self-supervised learning (SSL). E.g. see DINO (https://arxiv.org/abs/2104.14294).

The random noise is added to the model parameters, not the inputs, or not?

This reminds me of variational noise (https://www.cs.toronto.edu/~graves/nips_2011.pdf).

If it is random noise on the input, it would be like many of the SSL methods, e.g. DINO (https://arxiv.org/abs/2104.14294), right?

Presumably we still wouldn't enable Modules by default.

I wonder, what LeCun wants to do is more fundamental research, i.e. where the timeline to being useful is much longer, maybe 5-10 years at least, and also much more uncertain.

How does this fit together with a startup? Would investors happily invest into this knowing not to expect anything in return for at least the next 5-10 years?

I was looking for various options to archive my data (photos, documents, code), and have looked at Perkeep since a while, but then started using Git-Annex.

However, I regret this decision. Git-Annex is not usable anymore on my data because the amount of files has grown so much (millions) and Git-Annex is just too slow (it takes minutes up to even hours for some Git operation, and the FS is decently fast). I assume I would not have had those problems with Perkeep.

It reminds me also of the 24 FPS discussion, which is still the standard as far as I know for cinema, even though 48 or 60 FPS are pretty standard for series, The 24 FPS give it a more cinematic feeling.

https://www.vulture.com/2019/07/motion-smoothing-is-ruining-... https://www.filmindependent.org/blog/hacking-film-24-frames-...

I have asked about using RPython as a generic standalone language before. I think the official statement is that is was never intended to become one, and it's really a very minimal subset of Python (so basically no existing Python code will run, it would require heavy refactoring or complete rewrite), and it's only specifically those features that they currently need, and it might also be a moving target, and they don't want to give certain guarantees on stability of the language etc.

Once you consider that you anyway need to write very different kind of code for RPython, then maybe just using Nim or some other language is a better idea?

QtCreator was a bit like the lightweight version of KDevelop for me. I didn't really needed any of the Qt features, just the C++ editor. And the C++ support was really good.

The bug was with non-contiguous data in tensors.

I also had a very similar bug a while ago, broken gradients due to non-contiguous data for masked_select: https://github.com/pytorch/pytorch/issues/99638

In my case, it was easier to identify: I had another implementation of my loss function before that did not use masked_select. But then I thought I can be clever and use masked_select to take out the non-masked frames and calculate the loss only on those. But it wasn't working. Also, it only happened for some models, not for all. It turns out, it was always happening when the data coming out of the model was non-contiguous.

I think the bugs with non-contiguous data are not so uncommon. I wonder how much of that we still have.

The argument is also that you could effectively DoS the system by exhausting space or inodes.

This is Windows only.

I wonder, why don't they use Lazarus (https://www.lazarus-ide.org/)? That would also make it cross-platform, and probably gain much more interest in the project.

Oh, I just checked, there is an active fork: https://github.com/ianBBB/boa-constructor

Ok, this post is mostly about text-based IDEs, but I think the point mostly stands as well for IDEs in general. I'm thinking about Visual Basic or Delphi.

I think such a IDE for Python would really be helpful for beginners. Not text-based, but more like Visual Basic. But everything integrated, everything easily discoverable (that's very important!). Maybe also with such a GUI builder as in VB. And a built-in debugger. I think for the code editor, as long as it has some syntax highlighting and tab auto-complete, that would already be enough. But some easy code navigation would also be good. E.g. when you place some button on your window, and double click that button in the GUI editor, you get to the call handler code of that button.

Some time ago, a small group of people (me included) (I think from some similar HN post?) got together and we brainstormed a bit on how to implement this. But we got lost in the discussion around what GUI framework to base this on. I already forgot the options. I think we discussed about PySide, Dear PyGui, or similar. Or maybe also web-based. We couldn't really decide. And then we got distracted, and the discussion died off.

Note, Free Pascal was mentioned here. But then you should also mention Lazarus (https://www.lazarus-ide.org/), which is the same as Free Pascal but cloning Delphi. Lazarus is really great. And it is actively developed. But Object Pascal is too little known nowadays, maybe also a bit outdated.