Dobiasd

While I did not succeed in making the matmul code from https://github.com/Mozilla-Ocho/llamafile/blob/main/llamafil... work in isolation, I compared eigen, openblas, and mkl: https://gist.github.com/Dobiasd/e664c681c4a7933ef5d2df7caa87...

In this (very primitive!) benchmark, MKL was a bit better than eigen (~10%) on my machine (i5-6600).

Since the article https://justine.lol/matmul/ compared the new kernels with MLK, we can (by transitivity) compare the new kernels with Eigen this way, at least very roughly for this one use-case.

Are there any benchmarks on the performance of these new matrix multiplication kernels compared to the Eigen library (ideally for float32)?

https://github.com/Dobiasd/articles/commit/b5342dd5072480800...

Better? :)

Thanks for the feedback! I just extended the comment to touch on the "why" part. :) https://github.com/Dobiasd/articles/commit/53f360259ad8e64ca...

Thanks for the feedback! My code snippets in the article don't use any real/existing language. C# for example, is quite explicit with the transformation of generated to state machines, but also does not provide such methods, as far as I know. I've just added a comment explaining this choice: https://github.com/Dobiasd/articles/commit/f44b897f2a4d20aa9...

Thanks! Yeah, that was one of the intentions. :)

The interview for my current job first went mediocre, but by talking about frugally-deep (a side project of mine) I was able to excite my (now) employer. :-)

https://github.com/Dobiasd/frugally-deep

Hoogle is really amazing!

Inspired by it, I implemented something similar for FunctionalPlus (a functional-programming library for C++): https://www.editgym.com/fplus-api-search/

I'd love to see more projects taking this path too. :)

I spent some time over those 30 years looking at new IDEs, trying them out, configuring them, and each and every time this was time wasted, because the IDE was discontinued, abandoned, or otherwise became useless.

"wasted" sounds a bit too hard to me. If you learn and use some tool productively for some years, even if this stops, the years were not wasted. Ephemeral things can also have value.

Yeah, this one does something much less insane, i.e., it converts the paths to the tree outputs into their corresponding DNS (disjunctive normal form) and represents each term as a node (side by side in the same layer) in the NN, as described by Arunava Banerjee in "Initializing Neural Networks using Decision" [1]. The resulting NN architecture is much more reasonable than the one that treebomination produces.

[1] https://www.cise.ufl.edu/~arunava/papers/clnl94.pdf

Thank! Yes, in contrast to treebomination, using TF-DF can actually make sense. ;)

Thanks! This looks interesting. Some of the main differences I can spot so far are: - Hummingbird does not construct a NN with an architecture isomorphic to the source decision tree but instead cleverly compiled it into other (more sane) tensor computations. - Hummingbird is actually useful. ;)

EditGym - text editing training: https://www.editgym.com/text-editing-training/

It's a website for practicing manipulating text (start -> target, like a diff) quickly (timed) and efficiently (few keystrokes). The allowed keyboard shortcuts are only the "common" ones, that you can use in most "normal" (not Vim, not Emacs) text editors or IDEs.

I made this page not only because I was interested in building it, but also because I actually wanted to have such a training tool. Turned out, I really like using it, but almost nobody else does. :D (There are ads, but the revenue is basically zero.)

1. It allows for minimal disruption to thinking process, close to 90% of the time even when coding is not actively typing, but when typing is subconscious and fast it removes the potential of where it interrupts the thinking process.

I agree, and even wrote an article about that a few years ago. :-)

https://github.com/Dobiasd/articles/blob/master/how_touch_ty...

You're absolutely right, of course. :) While this was not the point of this article, I just added a remark about this important fact nonetheless: https://github.com/Dobiasd/articles/commit/2a251204183cb45e7... Thanks!

(author here)

Thanks for the nice feedback. :)

Regarding your idea, I actually did this for other topics too. You can find the results here: http://www.editgym.com/subreddits-and-their-choice-of-words/

Wow, what an effortful solution. I simply use a recliner and a monitor mount, and it works perfectly for me.

Components similar to the ones used in my setup:

- https://i.imgur.com/fdcwta6.jpg

- https://i.imgur.com/rdyJnQX.jpg

The mouse is located on the armrest (I don't need to use it too often), and the keyboard (a heavy and thus stable one) is on my lap (I don't need to look at it while typing).

Thanks. I committed a change (https://github.com/Dobiasd/articles/commit/8ac8db11eb95de688...). Feel free to open a PR if you have a better phrasing in mind. :)

This article feels like it was written by someone half-way through [...]

You might be right. I'm not a principal engineer. :)

The first solution in the wild we came up with back then when confronted with this problem, actually was to use a lock-free queue. Only later we figured out, that we did not need the prioritizing after all, and our software worked just fine with all threads having the default priority.

I would like to understand why priority inversion is not a solved problem.

Maybe I just was not careful enough in choosing this phrasing when writing the article.

Do you think it would make sense if I change "but it's far from being solved once and for all." to "each of them with different upsides and downsides."?

Initially I started to built this library solely as a learning experience. But then I needed to deploy Keras models in a specific C++ application and thus added the Keras import. Along the way I learned a lot about the the Keras model format, the details of implementing the different layer types and the computational graph. I would be happy to hear your feedback and to answer questions. :-)

8 hours of standing still (even with good posture) is not the healthiest thing. Movement, using the range of motion of ones joints, changing the posture and alternating load and deload is healthy. This does not happen automatically with a desk job, and even expensive equitment might not be the solution. But there are many different positions one can alternate between (floor: standing, sitting, kneeling, lunging, squatting; chair: sitting upright, leaning forward with some weight on the elbows, reclining with feet elevated, indian style sitting). Additionally one can do some squats and alike regularly, e.g. every time one visits the toilet (aka. "pee, squat, drink"). Making movement an effortless habit ensures that for example the spinal discs get their nutrients pumped in etc.

Great to hear that. Good luck on your journey to functional programming. I also started with Haskell and had problems with it. Then I found Elm, and that was like of a gateway drug for me. Here is my story in case you are interested: https://github.com/Dobiasd/articles/blob/master/switching_fr...

What do you do if your application needs to do both?

That does not sound like a nice way to die. ;)

Yes, stream fusion is a really cool thing. I do not know how to implement it without making things complicated in my Library.

I know it is not designed perfectly.

OK, I understand. I just think that performance can be neglected completely at many places.

I really like your remark about the performance of

    if (Contains("I", SplitWords(team)))

If you don't want the 15 in the odds, just to this:

    auto goodOdds = without(15, keep_if(is_odd, numbers));

I agree with you in general. The library is not made for performance-critical stuff.

But the "raw loops etc. are easier to understand by outsiders" seems like an argument agains using any libraries at all.

I write performance critical software for a living (industrial image recognition) and I often try to squeeze the last few percent out of an algorithm. But even in my case the by far largest part of code I write is not performance relevant at all. And there I prefer terseness and readability over performance. Yes, there can be some cases where I have to switch to a more efficient version later, because profiling shows a bottleneck where I did not expect one to be. But in my experience this has never been too big of a problem to sacrifice readability from the beginning in all places.

While working on my last projects I accumulated a collection of pure functions I needed now and then. So I thought, why not write a short pitch as a README and make it public? So here it is. It would be very nice of you if you could tell me what you think, so I can learn and improve.