zzo38computer

I agree that the bug report is not very good. I also agree that having commits written by Claude is not necessarily what caused the bug, although it might be (it is also possible that some of them introduced bugs and others didn't); whether or not it is in this case, is I don't know (some people think it is, but some think not). (Software without code written by generative AI will still have bugs too.)

However, the claim that "the original post was [...] no bug report" seems wrong; it does have a bug report, although not a very good one. It says that incremental backups using multiple --compare-dest arguments do not work, so it is a bug report. But, it should have been written differently, including by putting the text directly instead of a screenshot, giving a proper title, better details about the bug being reported, etc.

Their claims that they introduced deliberate bugs, are unlikely to be accurate, and not worth making those claims nor the violence that they involve.

I do have reasons for not wanting LLMs to commit code, so I agree with their opinion about that, but that does not justify making a bad bug report and the other stuff that they did. If it is FOSS, someone who disagrees with the project can fork it and make their own version, as has been done with other FOSS projects as well.

I think it is good that they are making statistical analysis. However, they used a language model to classify bug reports. They mentioned some things that might be missed, and they could be missed whether or not you are using a language model to classify bug reports, although there are some other possibilities e.g. whether or not a single report should count as multiple bugs in some cases, and mistakes in marking reports as duplicate.

I also think should be moved into extensions. However, extension security policies and other restrictions do not have to necessarily be so restrictive; there can be permissions but for extensions that you can install and uninstall by yourself it can be useful to be able to load native code .so files (since you might want to do things other than what the browser does by itself). This permission would not be made available to the official extensions, so that you can write it in C and then must compile them by yourself if you want them with native codes

I had thought of that in the past too, and also thought that the additional functions (if needed, which it usually isn't, in my opinion) should be the secondary function and not the primary function.

> By this logic, shouldn't we also use plain HTTP instead of TLS?

Better would be to use plain HTTP in addition to TLS, rather than instead of TLS. TLS does have benefits, but if it is optional then it can also be used on computers without TLS (as well as potentially other situations where you do not want TLS or where it is not useful).

I agree; you should allow non-TLS connections as well as TLS. (At least, access that does not require authentication should not require TLS, but should still allow it if that is what the client wants.)

If you are concerned about accidental login or API keys without TLS, then you can consider supporting mutual TLS, which improves security (and flexibility) in other ways as well. (You do not necessarily, have to require mutual TLS, in case someone prefers to use a username/password login, or 2FA or something else like that instead.) (In the case of login forms, you can have the links to the login forms to always use HTTPS, in order to avoid the problem.)

I think it is a good idea. JavaScripts and CSS can enhance it but should not be required.

Accessibility functions are also helpful; if designed well then it would be helpful for everyone (not only if you are blind or other disabilities), in many possible circumstances.

I agree that it would be better to not require JavaScripts. (But, I think it can be helpful to have mirrors on other services as well, for this and other reasons.)

However, there are some work arounds to some situations. Git could (presumably) still be used, if you have that (although you might not want the entire repository and only some files, so that is a possible issue with this). If you have a URL of a specific file that you can change "blob" to "raw" in the URL to access the raw file (this works on other services as well and is not specific to Gitlab). For commits, you can add ".patch" or ".diff" on the end of the URL (this also is not specific to Gitlab).

The server is down, but I copied the C code to here

  #include <math.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  
  #define TAU (6.283185307179586476925286766559005768394)
  
  static unsigned char head[16];
  static float fopt[127];
  static int iopt[127];
  static float*tab;
  static float*buf;
  static float y,i,q,v,phase;
  static int n,s,width;
  
  #define R(a) ((a)>=0?buf[a]:0.0)
  #define C(a) (tab[((a)+iopt['t']+(int)fopt['m'])%iopt['t']])
  
  int main(int argc,char**argv) {
    fopt['1']=0.966882;
    fopt['2']=0.623557;
    fopt['3']=-0.274788;
    fopt['4']=-0.635691;
    fopt['5']=-1.108545;
    fopt['6']=1.709007;
    iopt['y']=12;
    iopt['i']=iopt['q']=24;
    fopt['y']=12.0;
    fopt['i']=fopt['q']=24.0;
    fopt['l']=-11.0;
    fopt['h']=92.0;
    fopt['c']=0.009574;
    fopt['s']=0.8;
    fopt['a']=fopt['m']=fopt['p']=fopt['f']=0.0;
    fopt['t']=12.0;
    iopt['t']=12;
    iopt['v']=0;
    iopt['z']=0;
    fread(head,1,16,stdin);
    width=(head[8]<<24)|(head[9]<<16)|(head[10]<<8)|head[11];
    for(n=1;n<argc;n++) if(argv[n][0] && argv[n][1]=='=') {
      iopt[argv[n][0]&127]=strtol(argv[n]+2,0,10);
      fopt[argv[n][0]&127]=strtof(argv[n]+2,0);
    }
    buf=malloc(width*sizeof(float));
    tab=malloc(iopt['t']*sizeof(float));
    if(!buf || !tab) {
      fprintf(stderr,"Allocation failed\n");
      return 1;
    }
    while(fopt['m']<=0.0) fopt['m']+=fopt['t'];
    while(fopt['p']<=0.0) fopt['p']+=fopt['t'];
    if(!iopt['v']) iopt['v']=(3*iopt['t'])/4;
    for(n=0;n<iopt['t'];n++) tab[n]=sinf(fopt['f']+TAU*((float)n)/fopt['t']);
    fwrite(head,1,16,stdout);
    if(iopt['z']) for(;;) {
      if(!s) y=i=q=fopt['a'];
      n=fgetc(stdin);
      if(n==EOF) break;
      n=(n<<8)|fgetc(stdin);
      buf[s]=v=(fopt['h']-fopt['l'])*((float)n)/65535.0+fopt['l'];
      fgetc(stdin); fgetc(stdin); fgetc(stdin); fgetc(stdin); // unused input channels
      y+=v-R(s-iopt['y']);
      i+=v*C(s)-R(s-iopt['i'])*C(s-iopt['i']);
      q+=v*C(s+iopt['v'])-R(s-iopt['q'])*C(s+iopt['v']-iopt['q']);
      // Red
      v=fopt['s']*y/fopt['y'];
      n=(int)fmax(fmin(v*65535.0,65535.0),0.0);
      putchar(n>>8); putchar(n);
      // Green
      v=fopt['s']*i/fopt['i'];
      n=(int)fmax(fmin(v*65535.0,65535.0),0.0);
      putchar(n>>8); putchar(n);
      // Blue
      v=fopt['s']*q/fopt['q'];
      n=(int)fmax(fmin(v*65535.0,65535.0),0.0);
      putchar(n>>8); putchar(n);
      // Alpha
      putchar(fgetc(stdin)); putchar(fgetc(stdin));
      if(!(s=(s+1)%width)) fopt['m']+=fopt['p'];
    } else for(;;) {
      if(!s) y=fopt['a'],i=q=0.0;
      n=fgetc(stdin);
      if(n==EOF) break;
      n=(n<<8)|fgetc(stdin);
      buf[s]=v=(fopt['h']-fopt['l'])*((float)n)/65535.0+fopt['l'];
      fgetc(stdin); fgetc(stdin); fgetc(stdin); fgetc(stdin); // unused input channels
      y+=v-R(s-iopt['y']);
      i+=v*C(s)-R(s-iopt['i'])*C(s-iopt['i']);
      q+=v*C(s+iopt['v'])-R(s-iopt['q'])*C(s+iopt['v']-iopt['q']);
      // Red
      v=y*fopt['c']/fopt['y']+i*fopt['1']*fopt['c']*fopt['s']/fopt['i']+q*fopt['2']*fopt['c']*fopt['s']/fopt['q'];
      n=(int)fmax(fmin(v*65535.0,65535.0),0.0);
      putchar(n>>8); putchar(n);
      // Green
      v=y*fopt['c']/fopt['y']+i*fopt['3']*fopt['c']*fopt['s']/fopt['i']+q*fopt['4']*fopt['c']*fopt['s']/fopt['q'];
      n=(int)fmax(fmin(v*65535.0,65535.0),0.0);
      putchar(n>>8); putchar(n);
      // Blue
      v=y*fopt['c']/fopt['y']+i*fopt['5']*fopt['c']*fopt['s']/fopt['i']+q*fopt['6']*fopt['c']*fopt['s']/fopt['q'];
      n=(int)fmax(fmin(v*65535.0,65535.0),0.0);
      putchar(n>>8); putchar(n);
      // Alpha
      putchar(fgetc(stdin)); putchar(fgetc(stdin));
      if(!(s=(s+1)%width)) fopt['m']+=fopt['p'];
    }
    return 0;
  }

I had written a NTSC emulator in C, based on some other equations I had found, although it expects command-line arguments to control many things (such as the phase), and expects a grey scale farbfeld picture as input and produces farbfeld as output, so it is with still pictures rather than videos.

Your reasoning makes sense. However, it is not quite that simple.

As another comment mentioned, "and yet Jehovah's Witnesses are denoted on the list as a Christian faith".

So are Quakers (also denoted on the list as Christian), which (as far as I can tell) have no creed ; and, furthermore, although the Religious Society of Friends is Christian, not all Quakers are necessarily Christian (there are people of other religions as well, as well as those of no religion).

This does not seem to be specific to the DoD list; I have seen this in other lists as well.

As I understand, LDS did not add another book to the Bible; Book of Mormon is not a part of the Bible, although (as far as I know) still considered a scripture according to LDS.

(Nevertheless it is the reason I had thought of too (many years ago), although other people have cited different reasons.)

Yes, I had seemed to remember something different but I looked it up and yes it is still trinitarian, although apparently the working of the trinity is different (although this different working of the trinity is not apparent by the words of the baptism) which allegedly makes it not a valid Christian baptism (according to some Christians, including the Catholic church).

It does seem to be common to make LDS not counted as Christianity, although the reason is unclear to me.

Another comment mentions that the rejection of the Nicene Creed does not seem to be the distinction.

I had thought that it is because they have the Book of Mormon, although that is unclear. Orthodox have additional books of the Bible that Catholics do not have, but are still Christian. (Although, I think the additional books that the Orthodox have are still a part of the Bible, and Book of Mormon is different.)

Something that I had heard is that it is because Mormons use a different baptism, which is not Trinitarian. However, it seems that it is Trinitarian, although this trinity is different from that of Christians (even though they still say "the Father", "the Son", and "the Holy Spirit").

Quakers (which are listed as Christian) also apparently do not use baptism (and reject other sacraments as well). Although the Religious Society of Friends is Christian, they do have differences and not all Quakers are necessarily Christian (or necessarily theists).

So, I don't know.

Atheism is not a religion, and someone who is religious can also be atheist (and some religions are not theistic), although having no religion does not necessarily make you atheist either (although many atheists are not religious). (However, considering that, putting "agnostic" in there seems to be strange compared to this.)

Howveer, when knowing what should be in the list, there is the question of what the information is used for, in order to know what divisions are helpful for this purpose.

I agree with it, although still the fork is expensive like they mention. There is clone with some flags, although that does not really solve it.

I think one problem is that it is already how it is; making an entirely new operating system (that is not Linux, not GNU, and not POSIX) would solve it, but that is not the case here, so it would need to be done as it is.

One possibility would be a new function that creates a new empty child process, but the parent process specifies what system calls the child process executes, and can stop if specifying that exec or exit is (successfully) called by the child process, or if the parent process gives it the program memory to execute directly instead of using a file (since that use is also useful). The new function can still have some of the clone flags available. (I don't actually know how much better it would work.)

There are other possibilities as well.

The existing methods can also remain available for when they are helpful, but functions such as popen might be changed to use the new method.

Different people have different opinions (including opinions in favor of AI, and opinions in between, and more nuanced opinions).

I have several objections as well, including the Dijkstra objection (i.e. it is not as precise as using a computer code), as well as concerns about the commercial intentions (and terms of use and other related issues) of whatever companies makes them, and wastes of power and other things like that. There is also expectation of use even if it does not help, and that what I have seen often does not help and is better to do by yourself, or to use different software rather than LLM/generative-AI software. (Many people have different objections, although in some cases I do not consider them significantly important.)

(Some people say there is a paywall. I do not get a paywall; the article is displayed, although it also says that it is only available to subscribers but then the article is displayed without needing to subscribe.)

I would not use LLM and generative AI systems in my programming, for several reasons.

If you can do it better without the AI, then you should not be forced to use it anyways, or tracked for using it. (Even if you only track the statistics, and how much time it takes, that is not sufficient because you must figure out if the result is actually good, and any other related issues, including e.g. costs and energy usage, testing (not all kind of testing could be automated), kinds of statistical bias, etc.)

In general, not all kind of religious exemptions would mean you would be able to do the job, but in this case the exemption is reasonable if she is competent at computers; you shouldn't need the AI systems to do it even if they insist that you should. If they have a religious exemption they should show that they could still do that job or else to leave that job (rather than being forced or coerced).

Thare are both religious and non-religious objections (as well as people of the same religions who would not be opposed, since they are different people even if religion are same; there are also some more nuanced opinions). (There are more religious objections than only Unitarian Universalists and Catholics; I have looked and found some opinions by people of a few other religions, and there are probably more than that too. Different people can also have different opinions regardless of whether or not you are religious or of a same or similar kind of religion.)

One would be if you want to design it differently than the existing kernels do.

They are right that Free software is important, not only games but other stuff as well; I agree with the ideas they mention in this article.

Freedom 1 is also important for understanding the rules of the game in case it is not documented very well; changing which server it connects to is not the only issue (and a well-designed FOSS program would have an option to configure which server it connects to without needing to recompile it).

(In some cases, other people figure out the rules of the game independently and might write independent FOSS implementations (in one case, I have done this for a single-player game; other people have also done for other games). In this case, it may be less of a problem (if the FOSS implementation is actually correct and complete (and might even have less bugs than the original and/or other improvements)), and both official and unofficial implementations can continue to be used.)

I should think that there should be a better way (e.g. port knocking, instructions for manually correcting the URL that cannot easily be automated, additionally supporting alternative protocols, etc).

That is not a good excuse for requiring overly complicated and overly specific software.

My opinion is that they should not use AI/LLMs to program this, but I think this is not the proper way to make a bug report (and that the use of AI/LLMs is not necessarily itself a bug, even though I do have concerns and objections about their use).

They should post the text directly rather than a picture of the text, and it (and the issue title) should describe what is not working in the correct details (in this case, they do provide a few details; it says incremental backups are not working correctly when using multiple --compare-dest= arguments, and it mentions which version does work).

If they are also opposed to using AI/LLMs to program this, then they can mention that as well, but by itself it is not a proper bug report; they have to indicate what (if anything) is wrong with it (whether or not they used AI/LLMs to program it).

I think a way to do is to reduce how many dependencies are needed.

It is not what I meant and also seems to me not what is meant by sp.h either.

I agree with most of the criticisms they make.

I agree that pointer and length is better than null-terminated strings (although it is difficult in C, and as they mention you will have to use a macro (or some additional functions) to work this in C).

Making the C standard library directly against syscalls is also a good idea, although in some cases you might have an implementation that needs to not do this for some reason, generally it is better for the standard library directly against syscalls.

FILE object is sometimes useful especially if you have functions such as fopencookie and open_memstream; but it might be useful (although probably not with C) to be able to optimize parts of a program that only use a single implementation of the FILE interface (or a subset of its functions, e.g. that does not use seeking).

> I've gone so far as having a Gemini instance at gemini://g.wiki.roshangeorge.dev which no one has accessed.

If nobody else knows then they might not access, but I looked; at least some of the parts looks like interesting to me.

> The protocols in use here are quite nice and there's always Gemini if you want a protocol that is pure document oriented.

As well as others, depending on what you want to do; it is not quite as simple as "pure document oriented" (e.g. Gemini does have inputs (1x status code) and TLS as well, including authentication with client certificates).

> Perhaps a HTTP browser that only `Accept`s `text/markdown`

It might also be made to be modular so that the file formats and other features can be added separately (including HTTP, HTML, Unicode, etc also would not be forcibly built-in, and the different protocols, file formats, character sets, and other features can be done by adding them on (which can be static or dynamic; static might allow some possible optimizations but would require recompiling and/or relinking it when you want to change it)).

Gopher and Gemini can both work on many kind of devices; having a monochrome display, or the differences in input (e.g. having numbered lines works OK, especially since both require links to be on a line by itself, unlike HTML), etc, without the author of the document needing to worry about such things like that. In both cases text entry might sometimes be needed so is not ideal but still it is possible.

What is "TLC" meaning here? Furthermore, for the purpose of keeping out commercial entities, it would be necessary to have the details of what is intended to be avoided and in what contexts, as well as how to avoid certain things; I think simply "keeping out commercial entities" won't do (except perhaps for such things like e.g. indexing services, which can choose not to link to them).

There are also the other "small web" protocols (and some other stuff). Either way, it is still the same internet and not a new one, and still uses TCP/IP and DNS (although not HTTP/HTML). (That does not mean that it is not worth anything, though.)

The robots.txt file should be used to restrict (and, in some cases, slow down) crawling at the time it is being crawled, not for SEO or for restricting access to mirrors or for any other purpose. It should never apply retroactively. (Unfortunately it is sometimes used badly despite this.)

They mention a compiler having access to a file called BILL for storing billing information and if you specify that it is the file for debugging then it is overwritten by the debugging information. While an appropriate kind of capability system (such as proxy capabilities, or object-capabilities described in that article which is very similar) can help, locking the file might also help (if it is locked for billing first before any files specified by the user are locked); then the compiler will complain that the file specified as the debugging output file cannot be written because it is locked (even though the compiler is the one that locked that file). A capability system is better, although it would be possible to do both, since locks (and transactions as well) are also helpful for other purposes.