1. 4

    Is there a reason you can’t use Cygwin? I use it for developing on Windows. The terminal is fine, and you can even build standalone windows applications without any Cygwin dependency.

    Edit: Referring to the mintty terminal and the mingw64-i686-gcc-core package.

    1. 3

      It’s slow though, especially for CPU intensive tasks

      1. 2

        Came here to ask basically this. I do some Windows development occasionally and just use MSYS2 or whatever with mingw64. Yes it is not fast, but it is usable. I also occasionally just use good old cmd.exe with a Makefile since that is how I started and it’s not like you can’t do that anymore… How does the poster think we wrote software in Windows 95/98 days??

        1. 1

          Mainly I am concerned about input lag–which was quite high when running gnome-terminal from wsl through vcxsrv–although, it may be better with cygwin since that’s running as a native app–except, maybe not: siblings suggest it’s slow.

        1. 6

          YAML has a variety of quoting mechanisms for strings. One of them, block scalar, maps quite nicely to the author’s indent quoting, e.g.

          helptext: >
              Usage: This is the first line
                  This is the second line
              ^--- This whitespace is part of the string.
              <--- This whitespace is the current indent.
              We can include """, ''', " and ' just as they
              are, so we can quote any code this way,
              whether python or other.
          

          However, it gets complicated. A full description of the above might be written block scalar folded, with clip chomping. I regularly need to refer back to these, then use some trial and error

          1. 1

            Yes, this is similar. Maybe the only difference is the handling of line breaks at the end of the string. YAML seems to have three ways to do it, none of which can represent all strings:

            • Single newline at end (clip): exactly one newline
            • No newline at end (strip): exactly zero newlines
            • All newlines from end (keep): one or more newlines

            Indent quoting would be able to represent all strings using the same notation:

            The end of the string is represented by a newline, followed by an indentation decrease.

            In YAML terms, this would probably be expressed as All newlines from end except the last one.

          1. 2

            This multiple levels of escaping is nonsense, in my opinion, although this is nothing against the author.

            I’m disappointed that a better option, my preferred option, wasn’t mentioned: The beginning and ending character can be doubled to provide for a single instance. Follows is an example:

            ''''
            

            In APL, this evaluates to a string with a single quote. Follows is another example:

            """"
            

            In Ada, this is a string containing a single double quote.

            Phrased differently, this is my preferred way to consider it, this is the simple idea that a string containing the string character itself can be represented by two strings juxtaposed, with the joining point becoming the string character in a new string that is the combination.

            It’s disappointing Common Lisp uses escaping instead of this much nicer way.

            1. 4

              I too prefer doubling the quote character over backslash + quote, since I personally find it more intuitive and aestetic.

              However, this is still escaping, at least in the way I used the term in the article—the quote character does not represent itself but instead is a dispatch character. It will still suffer some downsides of escaping, e.g. copying the text between the start and end quote characters will not put the actual string in your clipboard.

              1. 2

                The author appears to be aware of this method of escaping quotes:

                In PostgreSQL, apostrophe (’) is escaped as two apostrophes (’’).

                I first saw this kind of escaping in Plan 9’s rc(1):

                A quoted word is a sequence of characters surrounded by single quotes (’). A single quote is represented in a quoted word by a pair of quotes (’’).

              1. 4

                The primary example would be representing the length of the string followed by the string itself, which is very common in protocols and formats that are mostly read and written by machines. To use this technique in programming languages would mean making humans with no interest in counting symbols do just that, which is so painful that escaping is a better tradeoff.

                Someone’s never had to deal with ancient FORTRAN.

                1. 2

                  You mean Hollerith constants in FORTRAN 66?

                  4HCorr, 4Hect,, 4H I h, 4Had n, 4Hot s, 4Heen , 4Hthis, 4H bef, 4Hore.

                1. 1

                  I think this vision can and should be divided into several sub-problems that can then be solved independently and in several ways.

                  1. How to represent project data: The author suggests a new protocol using signature chains and point out how they are very similar in concept to git. I suggest they shouldn’t be just similar, but that the protocol to represent project data should be implemented in terms of actual git concepts. Such a protocol could for example make use of special rules for branch names, filenames, commit history structure etc to represent project data. Another thought is that it could be represented as a standardized directory structure with special merge rules, so that it becomes independent from the version control system.

                  2. How to distribute project data: The author suggests SSB. Even if this could work out, trying to push a standard that is incompatible with existing workflows would probably not succeed very widely. Yes, web bridges are possible, but unless and until such bridges are implemented the use of the protocol would be proportionally hampered. I suggest using existing infrastructure and workflows albeit for new purposes, e.g. opening an issue using a pull request. If the project data is encoded in git concepts, then anything able to distribute git data can also distribute project data. This already includes git..b, http etc. With no change whatsoever, these protocols and platforms would already be compatible. Adding SSB to achieve some proposed higher level of decentralization would be a separate issue that could succeed or fail independently.

                  3. How to authenticate project data: The author suggests developer signature chains, while I have suggested implementing something like signature chains using git concepts. A signature chain could be implemented as a git branch with signed commits, but authentication of project data could be provided in one of several ways. For example, github could be used as a web bridge if someone is authorized to authenticate data added by *@github users.

                  What do you think, would this be viable and desirable?