• 0 Posts
  • 4 Comments
Joined 1 year ago
cake
Cake day: September 20th, 2023

help-circle
  • Yes, but you know what I did? nothing, I just have the program exclusively accept lowercase doom.wad

    This means it became annoying for the user. The problem shifted and now it’s the end-user the one with the responsibility to read the manual and do the work. A lot of people just get a DOOM.WAD, put it there and are surprised it doesn’t work.

    And there are many many programs that are doing the same thing in many similar situations. In fact, in the Linux world, most software pushes this to the end user. So this is just as much of a problem for users as it is for programmers.

    At the end of the day, the question should not be: is it more complexity for the user or for the programmer? …the question should be: what’s the end cause making it complex? is there a way it can be made simpler?

    This is the same for every problem. Often user-friendliness is a tradeoff, most user-friendly software I’ve used keeps so much complexity within that it becomes annoyingly slow and inefficient. I’d rather use the terminal for file management than wait for the GUI file browser to finish loading my huge remote storage directories.


  • But then you are not getting rid of the complexity, you are just forcing programs to become more complex/inefficient.

    I experienced this with the doom libretro core, which is meant to be portable and have minimal dependencies… so if I need it to automatically find DOOM.WAD/ doom.wad/Doom.WAD/etc in a directory I would either have to add a globbing library as dependency to handle this case and have it fetch [Dd][Oo][Oo][Mm].[Ww][Aa][Dd], manually check for each possible case, or list the entire directory (I hope you don’t have a library of a million wads!) and compare each file (after upper/lower) just to find the one with the right name. And that could be a real pain for embedded devices with low I/O or if there’s a remote storage layer behind.


  • I’m with you, and not just from a “human” perspective. Also when writing small programs meant to be relatively lean/simple it can be a problem when the user expects it to find a particular file regardless of its case (will it be DOOM.WAD or doom.wad? Doom.wad? Doom.WAD? … guess it’ll have to be [Dd][Oo][Oo][Mm].[Ww][Aa][Dd] and import some globbing library as extra dependency… that, or list the whole directory regardless its size and lower/upper every single filename until you find a matching one…)


  • What C does depends on the platform, the CPU, etc.

    If the result actually differs due to compilers deviating in different architectures, then what we can say is that the language/code is not as portable. But I don’t think this implies there’s no denotational semantics.

    And if the end result doesn’t really differ (despite actually executing different instructions in different architectures) then… well, aren’t all compilers for all languages (including Rust) meant to use different instructions in different architectures as appropriate to give the same result?

    who’s to say what are the denotational semantics? Right? What is a ‘function’ in C? Well most C compilers translate it to an Assembly subroutine, but what if our target does not support labels, or subroutines?

    Maybe I’m misunderstanding here, but my impression was that attempting to interpret the meaning of “what a function is in C” by looking at what instructions the compiler translates that to is more in line with an operational interpretation (you’d end up looking at sequential steps the machine executes one after the other), not a denotational one.

    For a denotational interpretation of the meaning of that expression, shouldn’t you look at the inputs/outputs of the “factorial” operation to understand its mathematical meaning? The denotational semantics should be the same in all cases if they are all denotationally equivalent (ie. referentially transparent), even if they might not be operationally equivalent.