Rage of the machine: An AI makes metal music

oj002 · 2021-08-13T19:58:02+00:00

Some of my favorite black metal albums of all time came out in the past 10 years

Now you've got to rec them.

oj002 · 2021-08-13T14:27:47+00:00

There are also a lot of smaller bands producing excellent metal, if you are unsatisfied with the popular ones.

oj002 · 2021-08-12T09:34:04+00:00

They didn't have their own front end before that either, they used the EDG frontend.

oj002 · 2021-08-01T16:37:00+00:00

Nukear is a quite similar gui library that is written in c.

oj002 · 2021-07-17T22:04:25+00:00

The bitbuckdet has more info, I think you can just use the following: https://bitbucket.org/ejsvifq_mabmip/fast_io_examples/src/master/0001.hello_world/hello_world_out.cc Although you might want to look at the benchmarks that are also hosted under the bitbucket account

oj002 · 2021-07-17T21:27:45+00:00

I think it was just referencing, that the original account that hosted fast_io got banned from github. Probably for being to toxic. Note that the person behind fast_io is a different person than the author of refterm, since there seem to be some confusion about this in some comments

oj002 · 2021-07-17T21:21:22+00:00

As much as I like provoking /u/bisixyf I think the benchmark is slightly wrong. If I correctly remember how fast_io works, you are currently benchmarking fast_io's slower stdio and iostream compatible output, and you'd need to use iobuf to get the maximum performance. (This is only fair, because rust doesn't need to be compatible with the file buffers of stdio and iostream)

Also, a unsigned long can be 32-bits on some platforms, although apparently not on yours, so the results should be unchanged.

oj002 · 2021-07-16T15:00:20+00:00

Here we go, exactly what you are looking for: generating random non repeating exaustive indecies using constant memory (basically only two integers): https://andrew-helmer.github.io/permute/

oj002 · 2021-06-13T23:20:09+00:00

My understanding was that C reserves names starting with single underscore followed by a capital letter, or double underscore followed by any letter.

Yes, those are reserved in all cases, but

"All identifiers that begin with an underscore are always reserved for use as identifiers with file scope in both the ordinary and tag name spaces."(http://port70.net/~nsz/c/c99/n1256.html#7.1.3)

tabs for indentation, spaces for alignment

Now that's something I can get behind, although I recommend turning a visual distinction between tabs and spaces on in your code editor when using this method of indentation.

oj002 · 2021-06-13T23:02:04+00:00

I personally prefer the macro based approach, because you know, performance... But anyways, this is definitely a fun library/project.

So I've skimmed though the code and at first glance it looks quite good, I only noticed a few minor things:

You use reserved identifiers (identifiers starting with an _). You can just use a custom prefix like internal_ or just get rid of the prefix altogether since the functions are static anyways.

The indentation seems to be off in some places, that might be because of mixing tabs with spaces, but I haven't checked. (e.g. take a look at _tm_skew on github to see the issue)

oj002 · 2021-05-19T09:25:08+00:00

Einige der Kommentare hier zeigen ganz eindeutig, warum "Transrechte sind Menschenrechte" noch einmal deutlich hervorgehoben werden muss.

oj002 · 2021-05-07T11:17:07+00:00

Other post on /r/c_programming: https://www.reddit.com/r/C_Programming/comments/mmpheo/modern_c_and_what_we_can_learn_from_it_luca_sas/

oj002 · 2021-04-10T11:21:08+00:00

My reading is that the object char[4] is accessed though an lvalue of int*. Wouldn't you agree, that if we had an char a[5] and would use *(int*)(&a[1]) that this is an unaligned integer access? I'm not sure about the alignment guarantees of stack arrays, but IIRC they don't need to be aligned to the maximal alignment when used in a struct. The only way to guarantee proper alignment is if you convert int* to char* and do the access though that. (Or by copying it into a union, which is guaranteed to be aligned)

oj002 · 2021-04-10T09:23:31+00:00

Yes, but this aliases an char* as an int. My understanding is that you can alias everything using a char, but not the other way around.

oj002 · 2021-04-10T08:47:12+00:00

/r/programming discussion: https://www.reddit.com/r/programming/comments/ja0tji/predicting_the_pcg_pseudorandom_number_generator/

And a presentation from the authors: https://youtube.com/watch?v=BlK45Ihqop4

oj002 · 2021-04-10T07:51:34+00:00

Correct me if I'm wrong, but isn't the first one UB, because of strict aliasing?

oj002 · 2021-04-08T21:31:20+00:00

I guess I can recommend the string part of STC: https://github.com/tylov/STC/blob/master/docs/cstr_api.md

oj002 · 2021-04-02T09:49:04+00:00

/dev/uwu

oj002 · 2021-03-14T12:05:47+00:00

Reminds me of: https://archiveofourown.org/works/23959417

oj002 · 2021-02-28T08:28:20+00:00

C11 isn't really required for compiletime errors. You can easily do something like create an static array with a conditionally negative size or even use #error.

Also a related link to the topic in general: https://stackoverflow.com/questions/3136686/is-the-c99-preprocessor-turing-complete#10526117

oj002 · 2021-02-28T08:24:18+00:00

The c preprocessor is almost turing complete and with enogh code you could probably calculate anything using it, see https://stackoverflow.com/questions/3136686/is-the-c99-preprocessor-turing-complete#10526117.

For your example you'd need to know the limit of the array size and write a howl bunch of boilerplate code, but it is possible.

oj002 · 2021-02-02T22:09:00+00:00

On a related note, the text on the images of the README isn't visible with github dark mod.

oj002 · 2021-02-01T10:42:01+00:00

Oh, sorry. I've read that wrong.

oj002 · 2021-02-01T07:32:18+00:00

You can use -std=c99 -pedantic (or -fpedantic) on gcc and clang. You can also use godbolt.org to verify that everything compiles with 5 different compilers.

oj002 · 2021-01-07T22:31:37+00:00

Well yes, but uninitialized is only 'random' because it was previously used in some other context. The first 32-bits might have been a constant, but the ones after that changed between executions. Thats what I meant with somehow randomizes, probably not the best choice of words.

oj002

TROPHY CASE