1. 2

    So, why do you require a screen? why not VR? I kind of remember that stream had an application that let you access the terminal on VR. Is that not available?

    1. 7

      Personally a VR headset while lying down would give me a terrible neck ache - moving the neck while lying down is very hard work compared to being upright.

      Also: do not do this if you can avoid it. Many bodily systems (inc digestion) do not function well while lying down, and your muscles will start to waste within days. Lying down for 16 hours a day will cause you lasting harm within a couple of weeks.

      1. 2

        ↑ This. Aside from dealing with an injury (like the author), I don’t see why anyone would completely rid their body of physical exercise. Sitting is bad as we all know but there are better ways to deal with that (a convertible sitting/standing desk + a pomodoro timer reminding me to take a break work wonders for me).

    1. 22

      If you’re the kind of person who’s willing to put up with a learning curve and a smaller ecosystem of plugins to gain access to a powerful editing model, also consider Kakoune. It’s like Vim, but moreso.

      1. 8

        I simply can’t go back to Vim after using Kakoune. Feels like a step back to me.

        1. 8

          I am in the same boat. I think by and large Kakoune is a step up from Vim. That said, it is not emulated in very many other places (it is in vs-code now via dance) – so you do lose the ability to pop into IDE of your choice and have a good experience.

          1. 1

            Dance is cool, but there are a lot of little things that does not work the same way and it’s annoying.

            When i’m at the beginning of a line and press x, it doesn’t select the line. It selects the line below. If i go forward one character before pressing x, it works.

            It’s good enough…

          2. 1

            I wish emacs had a kakoune mode like the evil mode. It would help me pick up emacs finally. Each time I have tried evil, I got stuck in small differences with vim.

            1. 1

              Unfortunately every emulation of another editor is not the same thing.

              I use kakoune to write small programs and scripts, but i have vscode as well. Vscode has a plugin called “dance”, it is a kakoune simulation plugin. It works, but not very much…

              The problem is the little things… there is always something that doesn’t really work the same and becomes annoying.

          3. 6

            How would you say the transition to Kakoune from someone who’s been using vim for awhile is like? I took it for a spin and am very confused, but I can already see things that I like.

            1. 6

              I switched from vim to kakoune about 6 months ago. I think the majority of the users, including the author himself, came from vim. My strategy was to switch entirely for a week then decide if it was worth committing fully or not. I never went back to vim. Once you get over the initial hurdle of unlearning your vim muscle memory, kakoune is very intuitive to learn, more so than vim in my opinion.

              1. 4

                Seconding ifreund’s experience, I came to Kakoune after maybe 20 years using Vim and it took me maybe a month for Kakoune to feel comfortable. The biggest hurdles for me were a few commonly-used key-bindings that changed (x in Kakoune is “select the current line”, not “delete the character under the cursor), and that Kakoune is a little bit like that “Snake” game on old Nokia phones: as you’re moving around, you need to be conscious of where the “tail” of your selection is as well as the “head”.

                The thing I love most about Kakoune is global search-and-replace. In Vim, I’d often wind up in a cycle of “write a replacement regex, try it, check the document, find a mistake, undo, try again”, which was particularly frustrating when the thing I wanted to select was easy to describe in Vim’s normal mode (like % to select a matched pair of brackets) but difficult to describe in regex. Meanwhile, in Kakoune, I can match a regex across the entire document, producing multiple selections, cycle through them all to check I’ve selected the right things, manually adjust them with normal-mode commands or even drop false-positives, and then do the replacement. It’s more work than the best-case Vim equivalent, but far smoother and more pleasant than the worst-case Vim equivalent.

                1. 2

                  I know you don’t use Vim anymore but for anyone else who has the problem described in the second paragraph: traces.vim offers a live preview that makes searching and replacing easier, if not quite as easy as it seems to be in Kakoune. As you’re typing a :s command, the plugin will highlight the parts of the file or line that would be matched, and it will also show you what they would be replaced with. It’s pretty magical.

              2. 3

                I really want to, but the hidden benefit of Vim keybindings is they translate to other programs too (I assume Vim people are just very militant and force devs to support them ;) ) so I can use IntelliJ or Emacs or even a web-based IDE and have access to those bindings. If I changed muscle memory to Kakoune, I’m going to be in trouble for hopping between programs.

                1. 3

                  powerful editing model

                  Can someone pitch to me, the established emacs user, what the benefits of Kakoune are? I have multiple cursors package enabled, plus helm and swoop (intra file fuzzy matching), but I presume Kakoune presents more benefits.

                  1. 6

                    EDIT: This explains it better https://kakoune.org/why-kakoune/why-kakoune.html


                    Disclaimer: I’ve used Emacs for fewer than 10 hours in my life. I remember very little.

                    The last time I looked into it, the big difference that Kakoune brings to the table is that nouns come before verbs. This feels minor but in practice it makes discoverability so much easier because you’re deciding which text to act upon before doing an action.

                    For example, in Vim if you want to delete three words you type d3w, and if you realize that you meant to delete 2 words then you have to undo and try again. Kakoune lets you make your selection first, highlighting as you go, and makes it easy to change your selection before taking an action. It’s also constantly auto-completing with all of the possible commands you might want to make, which is much simpler than reading through a manual.

                    1. 2

                      Not having used the Emacs multiple cursors package (or Emacs at all, really) it’s hard for me to say what the advantages of Kakoune’s editing model might be. If I had to guess, though, I suspect the biggest difference would be that since the Emacs core is only built for single selections, most Emacs functionality (including third-party extensions, etc.) only works with single selections, except for the things that the multiple cursors package specifically modifies. Meanwhile, all of Kakoune’s standard features and third-party extensions deal with multiple selections, so you don’t need a mental model of how single-selection features interact with multiple-selection data.

                      I don’t know how complete Emacs’ multiple cursors package is, but I expect it has all the same kinds of cursor interactions as Kakoune, like selecting substrings of the selection that match a regex, splitting the selection on a regex, dropping selections that do/do not match a regex, dropping selections interactively, rotating content through selections, etc. If not, that might be another reason to try Kakoune!

                  1. 0

                    But… why? Can somebody please explain to me why this is better than just running MuPDF in another window, maybe with some custom keyboard shortcuts? I don’t get it.

                    1. 1

                      A lot of us really like the terminal and the infrastructure around it such as Tmux.

                      1. 1

                        So, you can have a pdf viewer inside tmux inside a terminal inside your WM, OK, fine. But why? What does that give you? Is it just about key bindings? Or is it just “the terminal is cool, let’s cram everything we can into it?”

                        1. 1
                          1. You get the ability to hide and show the particular window in an intuitive fashion. Having a new window is often a distraction when you are working on something that requires multiple open terminals.
                          2. Having something in a terminal, when using a tiling window manager such as awesome or xmonad lets you keep your preferred layout.
                          3. Often I log into remote machines, and I do not have to worry about exporting X, or downloading the file locally. Sometimes, the file is too large, or gets rewritten too often, and I can simply check the latest report.
                          4. On the whole much better control over desktop management.
                          1. 1

                            Thanks! I think your points 1, 2, and 4 are more or less the same: they’re about window management, i.e. key bindings and layout. I’d try to optimize these in my window manager, myself, but I suppose if I was already doing window management inside a terminal (with tmux or emacs or kitty or whatever) I might see it differently.

                            Point 3 is different, and interesting. Does that actually work, though? Can I view a remote PDF over SSH in a local kitty+termpdf.py? I’d solve that at the filesystem level, with something like sshfs, that lets me use all my local tools.

                            What I typically do with PDFs, beside the page navigation basics, is selecting and copying chunks of text, using a mouse. I don’t imagine that having my pdf viewer wrapped in a terminal would make that anything but complicated.

                            1. 1

                              Does that actually work, though? Can I view a remote PDF over SSH in a local kitty+termpdf.py?

                              It worked for me with sixel. Copy and paste probably wouldn’t work; I never had to use that though. I extract the text from PDFs directly when necessary.

                      2. 1

                        Being able to display graphical content in a terminal window opens up all sorts of interesting possibilities (eg, being able to display graphical content within a terminal Emacs session). Unfortunately the graphical extensions added by iTerm2, Kitty, etc. don’t (yet) seem to be compatible with one another.

                        1. 2

                          There is the SIXEL standard that is supported even by the venerable Xterm.

                          This PDF rendering (using the green pdf viewer) was done using sixel.

                          1. 1

                            Ah, thanks - I had forgotten about that. I see termpdf, termpdf.py’s shell-based predecessor, supports SIXEL.

                            1. 1

                              Wow, I had no idea this existed, and I’ve been unix’ing since the early 90s. So cool!

                        1. 13

                          One of the Factor devs here. Feel free to ask any questions you might have, and I’ll do my best to answer.

                          1. 6

                            What do you think is the over arching goal for factor? Were you trying to solve a particular problem which was not solved well by other languages?

                            1. 9

                              I’m not the inventor, so I wasn’t trying to solve any particular problem as such. I just really liked what I saw.

                              For me, Factor provides a sweet spot of easy and very powerful metaprogramming, a simple runtime, and incredible introspectability. The feel of doing development in it is somewhere near a Lisp Machine, since all objects have graphical representations, you have a full REPL with compiler the entire time, and yet you still compile down to fully native code at all times. This makes doing incremental development extremely easy, and I think the amazingly rich standard library and GUI toolkit (for a language with its user base, at least!) speaks to its productivity. And unlike, say, Pharo/Squeak Smalltalk (an old haunt of mine), it uses normal text files for code, so I can use traditional tooling like Git and GitHub to manage development.

                              These days, I write a lot less in Factor. Most of that’s due to real life taking precedence as I get older, some of that’s due to other languages closing the gap quite a bit. (Things like Jupyter, or Swift Playgrounds, did not exist when Factor was created, for example.) But Factor remains my preferred environment when I’m trying to learn a new concept or explore a domain I’m not terribly familiar with. Most recently, I had a blast using it for Cryptopals, for example.

                              1. 2

                                These days, I write a lot less in Factor. Most of that’s due to real life taking precedence as I get older, some of that’s due to other languages closing the gap quite a bit. (Things like Jupyter, or Swift Playgrounds, did not exist when Factor was created, for example.) But Factor remains my preferred environment when I’m trying to learn a new concept or explore a domain I’m not terribly familiar with. Most recently, I had a blast using it for Cryptopals, for example.

                                Not to make light of anyone’s excellent work, but whenever I’ve explored Factor this matches what I’ve seen. The community was incredibly vibrant and active a few years back, but recently activity seems to have really fallen off across the board.

                                Am I mis-perceiving things or are you not alone in having moved on in some respects to other languages and environments?

                                1. 5

                                  Eh, it’s mixed. Yes, things have slowed down: Slava left, the company using Factor commercially folded, and a lot of us (such as me) have kids and stuff that make coding for fun harder.

                                  On the other hand, there’s actually a lot of work going on (largely driven by @erg) to make the syntax and runtime a bit more standardized, there have been a number of library improvements from Alexander Iljin, when people have needed more libraries they’ve added them, and so on. If you look at the core repo, you’ll see there honestly been a tremendous amount of activity since the last release. Sure, the pace may be slower, but it’s steady.

                                  In other words: I don’t think development has stalled, but I think it’s stabilized. For me, that’s great: Factor’s library grows and its stability improves, but things are generally where I left them. I know that same kind of things draws a lot of people to the Common Lisps as well, which also have a slower churn rate.

                                  1. 2

                                    I guess I was referring less to the language itself than to the ecosystem around it - blog posts and the like. But you’re right, none of this is an actual measure of a project or community.

                                    1. 2

                                      Blog posts are definitely down, but the mailing list is still quite active. I think it depends a bit where you look. But yes, I hear your point.

                            2. 3

                              Factor is a dynamic language and that makes sense to me: You have values on the stack that know their own types. When you are going to use a value, you check it’s type.

                              How do you think a statically typed concatenative language would look? My intuition is that it would be like a reduce operation over all of words in the program. I think I’m a bit hung up due to the lack of formal parameters.

                              1. 4

                                How do you think a statically typed concatenative language would look?

                                Probably exactly like our (optional) static typing. Do note that the compiler could do a lot more than it currently does for optimizations, but you can play with optimized. to see what it’s able to pull off. For even relatively complex cases that involve fixnums, it can basically do ops on straight machine words.

                                1. 1

                                  That is neat! Is it used a lot in practice?

                                  How is the data stack implemented in Factor? Is it just an array of pointers? Or does it use the top bits to determine the types? Tried looking at the repo, but wasn’t sure what file it might be in…

                                2. 3

                                  There was also cat from Diggins and Kleffners thesis

                                3. 2

                                  On the “See some example programs” page, the example program links all give me a 502 error.

                                  1. 1

                                    How related is concatenative programming related to array programming (APL)? I feel that some of the concatenative combinators seem familiar to transformers in Nial

                                    1. 1

                                      Can the REPL run in a console? I installed the factor package from AUR, and factor-vm seems to only be able to open its own graphical window.

                                      1. 3

                                        I can’t speak to whatever Arch is doing, but I just double-checked that plain factor on my box kicks off a command-line REPL, so I’m not sure what’s going on with their package.

                                        That said, I would strongly discourage using the vanilla command-line REPL; you’re missing so much awesomeness. If you really badly want to use a terminal for whatever reason, I would strongly suggest at least using FUEL (our SLIME workalike) in Emacs.

                                        1. 1

                                          ArchLinux doesn’t install a plain factor (perhaps because the name collides with the factor binary from the coreutils package). There is /usr/bin/factor-vm which is a symlink to /usr/lib/factor/factor. The latter also opens a GUI thing, but I just found out I could factor-vm -run=listener to get a TTY thing, so that’s cool.

                                          Thanks.

                                          1. 3

                                            That’s exactly the reason why the factor binary is renamed in the package. Source: Arch Linux packager here.

                                            It is kinda sad that there hasn’t been any new releases in years, so if you want to have the new features you’re better off with factor-git.

                                            1. 1

                                              Thanks, I’ll switch to factor-git.

                                              1. 1

                                                I’m not thrilled with that, but there’s an (in my opinion, wrong) attitude that our next release needs to be Perfect™, which means it’s forever delayed. The good news is, as you said and @kas is now doing, that Git is honestly quite stable, so that’s probably the route most people should go for now.

                                                1. 1

                                                  I think cutting a release would also send out a signal that Factor is not dead. I can confirm that git is quite stable so maybe there could be a point where tagging a new release might make sense.

                                                  In any case, thanks for maintaining Factor. I’m not actively using it any more but honestly due to the whole environment and community this was the most fun learning a programming language I’ve ever had, especially a completely different paradigm.

                                      1. 2

                                        I think once you have to start naming your variables, and define capture groups, you are much better off simply using parser combinators. One can define a full fledged combinator parser library with recursion and naming in about 20 lines of code if one is not already available in your language. The nice thing is that, you can incorporate regular expressions for tokens to strike a balance between readability and terseness.

                                        1. 7

                                          The comic is very true. See also the movement for papers that can be verified (open data for AI models etc). Oh and I can tell you that you can be even declined from a conference when publishing a continuation of your previous work: “there is already a paper XY on that” “that is mine, that was the first publication on this, this takes it further” “bye, duplicate of XY”

                                          1. 1

                                            I am not sure I get what you are saying; you have cited the work in question and explained why your current paper is an improvement over the state of the art?

                                            (OTOH, I agree, continuations are typically hard, because the bleeding edge research in some of the topics are of interest only to very few people until it filters down to the rest of the community, and it can be difficult to make the point why your current work is a significant advancement.)

                                            1. 2

                                              You don’t get to explain anything. You just get a deny from the reviewers that somebody else already published something about that stuff. Although they can totally see that the paper they referenced was also from you and they should’ve just read part of the paper to get the idea..

                                              1. 2

                                                Just to confirm; you do cite the previous paper in your related work and explain what you do new right? I have had the same problem as a submitter, but I have been also on the other side of the fence as a reviewer, and it can be hard to convince other reviewers that a paper is good when the new contributions are not clear.

                                                In particular, what has worked best for me, is to start by mentioning your previous work in third party, in the introduction itself, and talk about how this paper advances from there.

                                          1. 2

                                            So, when can we expect to see it in SMT solvers like Z3? or is there a way to use it in Z3 already?

                                            1. 3

                                              Z3 requires incremental solving and Kissat is not incremental yet, so you can’t use it with Z3 for now.

                                              1. 2

                                                Thanks, much appreciated! Any SMT solvers that I can use with Kissat at this poing?

                                            1. 2

                                              For those who are still on the fence, remake is GNU make with extra stuff added. That means, your make files will work as is, including extra bells and whistles, and really, once your run remake -X you will not go back to plain gnu make.

                                              1. 1

                                                I really really wish there was a good solution to saving the session in Jupyter, and restoring it afterword. Pickling doesn’t cut it :(.

                                                1. 13

                                                  It’s a little worrisome to me that people don’t see through this. It’s grammatically fine, but there is no conceptual power behind the words, which is a common problem (in different forms) with procedural generation algorithms. I would have hoped that readers expect, and can evaluate, coherence of writing beyond grammar. Maybe that’s overly optimistic.

                                                  1. 26

                                                    There are plenty of low-quality blog posts with no conceptual power behind their words.

                                                    1. 4

                                                      Can you imagine what the content marketing mills will do with this?

                                                      1. 2

                                                        Please don’t give them ideas; If I get a new story from Maupassant in my email, there is no way I am not going to read it.

                                                        1. 1

                                                          They’re just replacing humans with robots, which has been the trend for decades in other industries.

                                                        2. 3

                                                          I saw a tweet about jokes generated by GPT-3 being amazing, complete with a screenshot. When I clicked through I found Gwern’s tests. Nothing like what was implied. None of the examples in the screenshot were actual output.

                                                          It was the No Man’s Sky of joke writing. Semantically correct but an empty void when it came to humour.

                                                          1. 2

                                                            Yeah, I got about halfway through the generated post and then just started scrolling, which led me straight to the gotcha. I was completely bored and confused by what the ‘author’ was trying to say. Sure, it was largely grammatically coherent, but bits of it just flat out did not make sense in context. I was especially confused by the line ‘The forum also has many people I don’t like’, which I read about three times trying to work out why the ‘author’ had said that. There were several other bits that tripped me up because they just didn’t make contextual sense. While I could see this tool being useful for generating painting-by-numbers style sports reports and the like I’m not too worried about it putting actual writers with something to say out of a job.

                                                            1. 1

                                                              ‘The forum also has many people I don’t like’, which I read about three times trying to work out why the ‘author’ had said that.

                                                              That was my favorite part. I read it as the bot saying “There’s a lot of people I don’t like, and I’ll show everyone how dumb they are when they think a bot is being intelligent and funny.”

                                                            2. 1

                                                              It’s grammatically fine, but there is no conceptual power behind the words, which is a common problem (in different forms) with procedural generation algorithms.

                                                              And it’s a common problem in people too. Too many lost points on high-school essays…

                                                            1. 1

                                                              The reason this is interesting: The best effort in this direction (automatic program optimization) has been superoptimizers such as souper (paper) that can at best optimize loop free assembly sequences (and uses SMT solvers and search based approach). This approach shows that we can now do more complex control flow.

                                                              1. 5

                                                                Honestly, I feel the ACM prices are fair.

                                                                Membership with library access is only $198 a year, and realistically that’s not a burden for most people who would want access.

                                                                Furthermore, as the author points out, “The ACM exists to serve the field of computing and society itself,” and the main way they fund that work is through membership fees and charging for library access. The money has to come from somewhere.

                                                                1. 6

                                                                  If journal access is the only value that the ACM can provide for their membership fees, then they don’t have much of a legitimate reason to exist. Real professional societies do much more, both for their members and for society at large. I can appreciate that the ACM doesn’t have anything close to the kind of leverage that they would need to really fulfill their mission, but they’ll never get there with that kind of petty gatekeeping mindset and revenue model. It’s simply off-putting.

                                                                  Here’s what Scott Aaronson had to say about the practice of charging for access to academic research. Please do follow the links to statements from John Baez and Donald Knuth, too.

                                                                  1. 3

                                                                    Journal access isn’t the only value they provide, it’s the only thing they provide that gets them net revenue. They also do things like run conferences, running the library, and “magazines”. You can read the full breakdown here.

                                                                    1. 2

                                                                      Membership is what brings them revenue. Tying that to journal access is just a marketing strategy.

                                                                  2. 5

                                                                    I looked into getting ACM membership, but unfortunately I did not agree with all of their principles and other things as stated, and did not wish to compromise my own integrity or insult their stance by agreeing to a membership just so I could download articles.

                                                                    1. 7

                                                                      Woof. I see what you mean.

                                                                      They’re really walking themselves out onto an ethical cliff, aren’t they?

                                                                      I’ve never gone for membership simply because the price/value equation never made sense to me, but having read the above now I have two reasons to avoid it :)

                                                                      I own a hardbound set of volumes 1-3 of their History of Programming Languages series though, and treasure them :)

                                                                      1. 6

                                                                        Any chance you can point out the problematic principle?

                                                                        1. 5

                                                                          It’s less about one single principle, and more about the fact that many of these are an INCREDIBLY slippery slope.

                                                                          Let me give you an example:

                                                                          3.1 Ensure that the public good is the central concern during all professional computing work.

                                                                          Step back and think about that for a moment.

                                                                          Is anything any of us ever does in this industry short of those of us doing charity work REALLY in the public good?

                                                                          Lots of folks think writing open source software is in the public good. Is it? It encourages the use of computers, which have some VERY serious environmental impacts both in terms of their manufacture and their use at scale.

                                                                          It’s a very slippery slope. I appreciate the fact that they are striving to live and work by a set of ideals, but my point is that trying to reduce those ideals down to an actionable set of guidelines for our daily work is an incredibly daunting task, and possibly impossible.

                                                                          1. 2

                                                                            Is anything any of us ever does in this industry short of those of us doing charity work REALLY in the public good?

                                                                            Yes! (After a long career of “not really”).

                                                                            World would be a markedly worse place for humans without the stuff I get to work on (a widely used study aid for medicine), including a few people who are alive today because their doctors were able to look things up (in much of the world the specialist textbooks you would otherwise need are prohibitively expensive).

                                                                            1. 2

                                                                              As usual I phrased that poorly.

                                                                              I wasn’t saying that such jobs don’t exist, because I’ve worked at jobs like that as well.

                                                                              What I was ham fisted-ly trying to communicate is that not everyone is so lucky, and so putting that in their list of tenets is creating a moral quandary where there doesn’t need to be one.

                                                                              Do no harm is enough for me.

                                                                      2. 7

                                                                        Huh, I admit I didn’t read the principles very carefully, but after skimming through them these all seem pretty reasonable to me. Could you say which ones you don’t agree with?

                                                                        1. 8

                                                                          For what it’s worth, while I don’t like the ACM’s code of ethics I do support something in the form of the ASME code of ethics or the AlChE code of ethics.

                                                                          A big difference I see between the ACM and those other forms is that there is a focus not on some lofty idealism but instead on the realpolitick of a guild looking to protect its interest. An extremely cynical reading of those classical engineering ethics suggests an impetus of “Hey, look, people don’t understand what we do and they’re gonna blame us if we fuck up. so, we need to explicitly always be trying to serve the public good so that they trust us, ensure we don’t engage in buddyfucking that would harm our guild, and act in a generally moral way that means our mandate to charge what we do to do the work we do to the standards we want is not revoked.”

                                                                          I’ll point at a few to give the flavor, though I think @asthasr has a good explanation of overall what bothers me.

                                                                          In section 1.2, “harm” is vague and made worse by the frequent qualifier of “unjustified”. If somebody thinks something is “justified”, poof, there goes the protections.

                                                                          The requirement to use “generally accepted best practices” is so at odds with how software is actually developed today that it shakes my belief in the empirical grounding of any of what follows. Ditto the absurd idea that “consequences of data aggregation and emergent properties of systems should be carefully analyzed”–not that those sentiments are wrong, but they’re so clearly not how we do software “engineering” outside of a few niche applications.

                                                                          The entire bit about “capricious or misguided reporting of risks” is basically useless–practitioners must report risks, expect when there’s a chance the reporting might introduce “harm”. So, your obligation is to report issues except when reporting it might have further issues. The ASME criteria (criteria section, 1.3.1) is a lot more straightforward:

                                                                          Whenever the Engineers’ professional judgments are over ruled under circumstances where the safety, health, and welfare of the public are endangered, the Engineers shall inform their clients and/or employers of the possible consequences.

                                                                          You report the risks, always. If they go ahead with it and you believe there is imminent danger to the public, you go to the authorities. You don’t have this “a computing professional should carefully assess relevant aspects of the situation” nonsense–if you see something, you say something, and if it’s bad enough to endanger the public you fucking report it.

                                                                          The problem with the ACM stuff here is that, frankly, it’s very rare that any individual software system is going to pose such an obvious threat to life and limb (compared with, say, a bridge) that a practitioner is going to risk souring their relationship with their work over it. Only recently have we seen any approximation of this behavior with the walkouts over ICE contracts or what have you, but that’s been quite limited.

                                                                          In section 1.4, the wording of discrimination includes the phrase “inappropriate factor”. This implies that there are in fact appropriate factors for discrimination, and thus some subset of people that should be discriminated against. This goes directly against (in my reading) the immediately preceding claim of that we “should foster fair participation of all people, including those of underrepresented groups.”. Well, which is it?

                                                                          It goes on to talk about “computing professionals should take action to avoid creating systems or technologies that disenfranchise or oppress people.” What exactly does this mean? If I work on software for ultrasound used in abortions, am I not aiding in disenfranchising or oppressing future people? If I work on door lock software for prisons where we put violent white nationalists, am I not doing the same? What about banking software that by necessity only serves those with some pre-existing form of wealth?

                                                                          Section 1.5 is about supporting patents. In the first paragraph, we are told to “respect copyrights, patents, trade secrets, license agreements, and other methods of protecting authors’ works.” In the very next paragraph, “Computing professionals should not unduly oppose reasonable uses of their intellectual works”. Again, which is it? The entire bloody point of patents is to prevent any unauthorized use of intellectual work (for a good cause or no!) and grant a limited monopoly so as to encourage further innovation. The invocation of “protecting of authors’ works” is supporting a fictional narrative where we don’t live in a world where every salaried or engaged software engineer signs away their rights as parts of Assignments of Invention.

                                                                          It goes on and on, and I won’t take up more space here.

                                                                          The real failure of the ACM document is that it’s so goddamn long. Any sort of reasonable ethical boundaries need to be succinct, trivially seen to be representative of common practice, and ideally not containing text that directly contradicts itself. The ACM Code fails on all three of those counts for me.

                                                                          1. 2

                                                                            The problem with these sorts of lists is that they are meaningless without an ethics. What does it mean to “do no harm?” What is the “public good?” What is the justifying authority behind the “compelling belief” that accessing someone else’s system would help the public good?

                                                                            Without an ethical basis this is worse than useless: it’s gormless sloganeering.

                                                                            1. 2

                                                                              i don’t think you have to provide a clear plan before saying you want to do no harm

                                                                              1. 2

                                                                                So what if I think it’s very harmful not to send your data to my religious organization for inspection to make sure you’re not sinning? That’s clearly “justified” disclosure of information.

                                                                          2. 4

                                                                            I’m sure you’re not the only one. For as toothless and out-of-touch as they are, they sure do a lot of purity testing and virtue signalling. It just serves to keep them irrelevant outside academia… which in turn sure doesn’t enhance the relevance of academia to industrial practice. The whole thing is a sad mess, IMHO.

                                                                            1. 3

                                                                              Seems like a pretty reasonable list, and the baseline of ethical, professional responsibility for somebody working in the field of computing. What in particular do you have an issue with?

                                                                              1. 1

                                                                                Interesting. You may not want to explain on a public forum but that’s some really mild stuff. If you dropped the “computing” phrases it wouldn’t be out of line in a list of Abrahamic religion’s sermon topics (and maybe other faiths, I don’t have first hand experience in those).

                                                                            1. 6

                                                                              Following through to the main Pyret description page, I don’t know if this is new to Pyret or half-inched from some amazing promethean functional language I’ve never heard of, but this is one of the best things I’ve come across in a new-to-me language for a very long time:

                                                                              Functions can end in a where: clause that holds unit tests for the function. These assertions are checked dynamically.

                                                                              Maybe not awesome for performance but what a boon for function-level correctness without having to dive deep into complex types. Also

                                                                              you can also write check: blocks at the top level, for general program testing

                                                                              All-round good thinking about consistency and coherence from the ground up. Rad.

                                                                              1. 3

                                                                                Might be taking contracts from Eiffel/OO languages and/or pattern matching guards from Erlang/Elixir/functional languages. Not sure what the lineage of Pyret is though.

                                                                                1. 3

                                                                                  Might be taking contracts from Eiffel

                                                                                  That’s what I thought at first, too. But a look at their example shows that they aren’t contracts/invariants, they’re literally just standard unit tests. The only difference between these and, say, a D unit test, is that these are syntactically tied to the function. This affords you better test failure messages, at least.

                                                                                2. 1

                                                                                  That “where: “ clause is kinda neat, and I’ve never seen it before either. Seems like there shouldn’t be any performance impact if the compiler is smart enough.

                                                                                  1. 1

                                                                                    I wish they did not use where as the keyword. I like how Haksell uses where to define small local functions, and it fits better there.

                                                                                1. 1

                                                                                  Does any one know how to connect entr with either make or redo correctly? Essentially, I want to describe the relationships between targets using Make, but want the builds to happen automatically. A brute force approach is to simply connect all dependencies with make but that seems inelegant.

                                                                                  1. 2

                                                                                    Use remake instead of make. It is completely compatible (remake is a layer over gnu make), and much more powerful. Using remake, it is just

                                                                                    remake --tasks
                                                                                    
                                                                                    1. 1

                                                                                      In my opinion, this is the state of affairs in the fuzzing world too. No one discusses the non-obvious questions, and makes any attempt to find out exactly why a certain approach worked.

                                                                                      1. 1

                                                                                        Note: This paper posted here provides some evidence for the OP’s concerns. Notably, previous languages does interfere with learning a new language.

                                                                                        1. 1

                                                                                          TL;DR Writing code does not look like prose writing

                                                                                          Please read it along with this story which says reading code looks just like speech comprehension.

                                                                                          1. 1

                                                                                            Researchers took an extremely small and uniform sampling group (17 students, roughly the same age and programming expertise) and asked them to find syntax errors. No wonder regions responsible for speech comprehension lighted up — the task was inherently concerned with textual medium and, well, reading, unconcerned with code semantics.

                                                                                            This new paper sounds more interesting and reliable (larger sampling group, albeit still picked from the same cohort of students, a variety of stimuli), and correlates with my personal problem-solving experience.

                                                                                            Also reminds me of BASE initiative.

                                                                                          1. 10

                                                                                            This was the biggest revelation for me

                                                                                            Do Python learners struggle less than C++ learners? We analyzed student submissions on small coding exercises in CS 1 courses at 20 different universities, 10 courses using Python, and 11 using C++. Each course used either the Python or C++ version of an online textbook from one publisher, each book having 100+ small coding exercises, expected to take 2-5 minutes each. We considered 11 exercises whose Python and C++ versions were nearly identical and that appeared in various chapters. We defined struggle rate for exercises, where struggle means a student spent excessive time or attempts on an exercise. Based on that rate, we found the learning for Python was not eased; in fact, Python students had significantly higher struggle rates than C++ students (26% vs. 13%)

                                                                                            1. 3

                                                                                              It kinda makes sense! The syntax of C++ is insane, but students will never encounter all of it, so it will not hurt them. It’s hard to know how much C++ students are helped by the compiler nudging them with warnings, but it could be a lot!

                                                                                              I know Python has warnings too, but I don’t think there are as many, and I don’t think people use them much.

                                                                                              1. 4

                                                                                                I wonder what the development environments looked like. Learning with a well-configured IDE is, IMO, an advantage because it literally tells you about many problems as you type. But I think there is a tendency to forgo an IDE with Python because it doesn’t really “need” one.

                                                                                                Also, I’d be interested in whether they used type hinting with Python. I used to hate writing Python but I’ve had to more recently and found that it’s a lot less annoying if I use type annotations consistently.

                                                                                                1. 4

                                                                                                  one of the things that bothered me a lot when switching from java to python (and still bothers me a little, today) is that most functions never tell you the type of parameters they expect. will this be a string, or an object of some class?

                                                                                                  so you waste a lot of time in TypeError-s and ValueError-s where as other languages (like java and c++) are explicit on what is expected.

                                                                                                  also, even though I haven’t written java in almost 10 years, i still think that the javadoc is the best format for library documentation. packages-classes/interfaces-methods. you can browse it all, find what you need and discover a lot more.

                                                                                                  python documentation… ugh. it’s an exercise in infinite scrolling and searching in the browser, over and over again.

                                                                                              1. 3

                                                                                                Does anybody know if the regex with backreferences are Turing complete? or is that still an unsolved question?

                                                                                                1. 3

                                                                                                  Doesn’t seem to be as per https://stackoverflow.com/questions/7983115/are-perl-regexes-turing-complete (assuming embedded code isn’t allowed)

                                                                                                  1. 2

                                                                                                    Thanks! much appreciated.