Threads for eterps

  1. 1

    Does anything recent exist that can be considered a holistic system?

    1. 12

      For personal computing, I would say that the Apple M1 is definitely a holistic system – and there are many instances of personal devices.

      1. 5

        I agree about Apple Silicon Macs. Asahi Linux’s description of the Apple Silicon boot process is interesting. My favorite part:

        One consequence of the boot picker being implemented as a macOS application behind the scenes is that is has full accessibility support (including VoiceOver), which is rather unique.

      2. 3

        Precursor comes close in the mobile space: https://www.crowdsupply.com/sutajio-kosagi/precursor

        1. 2

          Thank you for this. This looks a lot like a vague idea that I’ve had, have seen some related discussion on, and have been interested in exploring myself as part of my work on Dawn. This seems like a considerably better basis for a portable runtime (and, potentially, OS) than WebAssembly, and I look forward to experimenting with the concept.

        1. 3

          This is satire right?

          1. 2

            Well, the best satire is hard to distinguish from being serious, so I guess it is. :-)

            1. 1

              Poe’s law in full effect.

          1. 3

            Scripts to Rule Them All is such an effective and underestimated solution, I get the impression that some people consider the technique ‘dirty’, or too simplistic (as if professional developers wouldn’t do it that way). It’s really powerful though.

            1. 3

              Start migrating from Arch to NixOS.

              1. 2

                A write up of that process would be interesting!

                1. 2

                  Hope all goes smooth and well. I went through the same migration around 6 months ago. Haven’t looked back!

                1. 2

                  An intelligent tiling window manager that can automatically re-arrange (on demand) based on the content of its windows (i.e. it would be aware where your browser / terminal has no significant content).

                  An open educational computing system with OS & compiler (+ simple hardware) that can be understood in its entirety by a single human being. http://www.projectoberon.com comes close, but a bit more modern and less archaic.

                  A reimagined web browser that builds on itself (i.e. starts with some SVG/PDF level primitives and creates higher level webcomponents with increasing complexity from that, all with a single coherent logical syntax (like s-expressions f.i.)).

                  A UI framework targeted to power users, like a modern age ncurses that isn’t restricted to the terminal with excellent support for extensible and scriptable apps, supports (but also limits) graphics, lot’s of focus on keybindings an layered VI-like modes.

                  1. 2

                    Also wondering if this flow would be done differently in 2020.

                    1. 6

                      I don’t really see the point of the initial pull request. A pull request is a request for changes to be pulled, but if you don’t want changes to be pulled, creating a pull request seems wrong. If it is something to do with being able to ‘review’ code through GitHub’s pull request screen, I recommend avoiding trying to do that: every experience I’ve had trying to review code through GitHub’s pull request/review feature was a total nightmare honestly.

                      This just seems like a really unwieldy way of emulating a patch series. This is why mailing list-based git collaboration makes so much more sense than the ‘pull request’ system: you end up emulating the features of mailing lists anyway. If your work flow involves reacting to email notifications about changes to ‘stacked pull requests’ then I’d suggest that you might want to investigate a work flow where people just use email to respond to a patch series.

                      Even if you insist on using GitHub’s pull requests, why not just review the changes commit-by-commit instead of breaking each commit out into its own separate pull request?

                      1. 3

                        Interesting point of view, thank you. I’ll delve into this a bit more. But I’m affraid that patch by email isn’t used for many projects.

                          1. 2

                            Thanks, I found the first link a minute ago ;-)

                        1. 2

                          There is a way to create draft pull requests on github, which can’t be merged.

                        1. 2

                          I admit that I don’t have much experience in a ‘professional’ setting, but at first glance, this seems unwieldy. Submitting diffs in that many pieces, and requesting independent review seems like it would require MORE cognitive load to keep track of. Also, the ‘seems fine’ comment on the monolithic PR seems like a straw man.

                          1. 6

                            Also, the ‘seems fine’ comment on the monolithic PR seems like a straw man.

                            Having a lot of experience with participating in and/or leading teams using PR workflows in professional shops: it’s absolutely not a straw man.

                            1. 5

                              Also, the ‘seems fine’ comment on the monolithic PR seems like a straw man.

                              Could be, but that is how I experienced it in a professional setting.

                            1. 2

                              How would humor be different in this language? You can’t hide the punchline while you’re setting it up. Are there jokes that are just as funny read backwards as forwards?

                              1. 3

                                I guess it would be somewhat similar as looking at a single frame cartoon: https://www.google.com/search?q=single+frame+cartoon&tbm=isch

                                I am sure humor would work differently in this language, but it might introduce alternative ways to express it?

                                1. 2

                                  I’d also add that, while Sapir-Whorf is in general…well, um, provably wrong, to be blunt…there are certain things, especially around humour, that are language-dependent. Puns are only available in some languages, for example; German can’t really do them. Or they’re available spoken, but not written (for example, Japanese, which has many cognates, but uses a Chinese writing system in part to avoid ambiguity in written forms).

                                  In this case, I can imagine an almost reverse of the Japanese situation: some of these sentences would be recognizable as drawings, and could have a unique form of written-only pun depending on how that worked out.

                                  1. 4

                                    German can do puns. Maybe Germans can’t, though. ;)

                                    1. 2

                                      I speak German okay, not great, so I confess I’m forwarding what I was told. Can you give me a German pun? I love them in English.

                                      1. 5

                                        Germans can definitely do puns, and puns are in fact pretty common in German (though generally considered to be “lame” jokes). The German name is Kalauer. A classic one: “Es wird nie wieder ein Kalauer über meine Lippen kommen, und wenn du lauerst, bist du kahl wirst.” (Of course it doesn’t work in English, but the translation would be “Never again shall a pun cross my lips, even if you lurk till you turn bald”).

                                        1. 1

                                          Ooh, nice! Thanks! I’ll need to ask my buddy what he actually meant.

                                        2. 4

                                          Most famous German pun (at least among English speakers): https://genius.com/Rammstein-du-hast-lyrics

                                          The phrases ‘du hast’ and ‘du hast mich’ when spoken can mean either ‘you have’ or ‘you hate’ and ‘you have … me’ and ‘you hate me’ respectively. When written hate is spelled differently, i.e. hast -> hasst.

                                          In effect the song tricks the hearer into believing that the singer is accusing them of being hateful towards him. Only when the complete sentence is sung is it clear that the much tamer meaning ‘You asked me’ is meant the whole time.

                                          I am not a huge fan but its such a famous example I thought it worth bringing up.

                                          1. 1

                                            Google for “Wortspiele”.

                                            Wikipedia has a few: https://de.m.wikipedia.org/wiki/Wortspiel

                                      2. 1

                                        That’s a good comparison! I think Scalar families is in part what prompted this thought. You could make the glyph for “big” be comically big, like 10x bigger than the rest of the sentence.

                                        Maybe you could show irony by making a big glyph that says “small”, or vice versa. Like the trope of a big guy named “Tiny”.

                                      3. 1

                                        An ironic situation is ironic no matter which order you learn about it.

                                        1. 2

                                          Interesting to imagine how this would be with:

                                          • emoji like icons
                                          • along 3 axis (i.e. in 3D)

                                          Obviously handwriting isn’t viable anymore in those cases.

                                          1. 1

                                            Since mirror reflection has meaning, you might need your glyphs to all have a 3D depth and a handedness, to avoid ambiguity.

                                          1. 1

                                            The author mentions ‘the tests’ several times, as if all tests are equal. I agree with the author to some degree if he solely means unit tests.

                                            1. 2

                                              The first 2 minutes are interesting even if you’re not interested in OCaml at all.

                                              1. 1

                                                That’s exactly what I thought, I never had given much thought on the subtle distinction between types and memory layout.

                                              1. 2

                                                Arch + sway + kitty + fish

                                                neovim, firefox-nightly

                                                  1. 5

                                                    Not to be confused with RISC-V: https://en.wikipedia.org/wiki/RISC5

                                                    1. 1

                                                      I’ll admit, I was confused so thanks for clarifying!

                                                    1. -1

                                                      This post could use some upvotes on hackernews: https://news.ycombinator.com/item?id=19936838

                                                      1. 5

                                                        Since it doesn’t work on original 16-bit DOS files, why not keep the same spirit, but redefine it slightly to make it easier to work? So instead of starting at address 100, start at address 1000 maybe, mmap the file directly, don’t have to change the sysctl setting, and run with it. That’d be kinda fun.

                                                        1. 2

                                                          I agree, this is a bit too obfuscated to be practical. I do love the idea of small binaries though. Maybe something like this is more suitable for it: https://github.com/gynvael/asmloader

                                                          See also the discussion on proggit: https://www.reddit.com/r/programming/comments/bpnwa0/linux_loader_for_flat_binary_dos_like_com_files/

                                                        1. 5

                                                          I honestly tried several times to get into it but I don’t know, it just didn’t click yet.

                                                          I find golang much nicer to work with if I need to do what rust promises to be best at.

                                                          I won’t give up on it yet but that’s just my feeling today.

                                                          1. 12

                                                            I’ll likely take some heat for this but my mental model has been:

                                                            • Go is the Python of 2019
                                                            • Rust is the C++ of 2019

                                                            Go has found its niche in small-to-medium web services and CLI tools where “server-side scripting languages” were the previous favorite. Rust has found its niche in large (or performance-sensitive) interactive applications where using GC is untenable. These aren’t strict boundaries, of course, but that’s my impression of where things have ended up.

                                                            1. 9

                                                              I agree with the mental model, although I usually think of Go as the Java for (current year).

                                                              1. 5

                                                                The tooling is light years behind though

                                                                1. 3

                                                                  “go fmt” offers a standard way to format code, which removes noise from diffs and makes code other people have written more readable.

                                                                  “go build” compiles code faster than javac.

                                                                  The editor support is excellent.

                                                                  In which way is the Java tooling better than Go, especially for development or deployment?

                                                                  1. 8

                                                                    How is the debugger these days?

                                                                    When I was doing go a few years ago, the answer was “it doesn’t work”, whereas java had time-travel debugging.

                                                                    1. 1

                                                                      Delve is a pretty great debugger. VSCode, Atom etc all have good debugging support for Go, through the use of Delve. Delve does not have time-travel, but it works.

                                                                      Packaging Java applications for Arch Linux is often a nightmare (with ant downloading dependencies in the build process), while with Go, packaging does not feel like an afterthought (but it does require setting the right environment variables, especially when using the module system that was introduced in Go 1.11).

                                                                      Go has some flaws, for example it’s a horrible language to write something like the equivalent of a 3D Vector class in Java or C++, due to the lack of operator overloading and multiple dispatch.

                                                                      If there are two things I would point out as one of the big advantages of Go, compared to other languages, it’s the tooling (go fmt, godoc, go vet, go build -race (built-in race detector), go test etc.) and the fast compilation times.

                                                                      In my opinion, the tooling of Go is not “light years behind” Java, but ahead (with the exception of time-travel when debugging).

                                                                    2. 2

                                                                      My three favourite features when developing Java:

                                                                      • The refactoring support and IDE experience for plain Java is outstanding. Method extraction (with duplicate detection), code inlining, and rearranging classes (extract classes, move methods, extract/collapse hierarchies) makes it very easy to re-structure code.
                                                                      • Java Flight Recorder is an outstandingly good tool for insight into performance and behaviour, at virtually no overhead.
                                                                      • Being able to change code live, drop frames, and restart the system in the debugger is a life-saver when debugging hard-to-reach issues. that the process being debugged can be essentially anywhere is a wonderful bonus.

                                                                      Sure, it would be nice if there was a single Java style, but pick one and use that, and IDE’s generally reformat well. Also, the compile times can be somewhat long, but for plain Java thay are usually ok.

                                                                      Note that I have never had to work in a Spring/Hibernate/… project with lots of XML-configurations, dependency injections, and annotation processing. The experience then might be very different.

                                                                      1. 1

                                                                        Just the other day I connected the debugger in my IDE to a process running in a datacenter across the ocean and I could step through everything, interactively explore variables etc. etc. There is nothing like it for golang.

                                                                  2. 5

                                                                    “I’ll likely take some heat for this but my mental model has been:”

                                                                    All kinds of people say that. Especially on HN. So, not likely. :)

                                                                    “These aren’t strict boundaries, of course, but that’s my impression of where things have ended up.”

                                                                    Yup. I would like to see more exploration of the middle in Rust. As in, the people who couldn’t get past the borrow checker just try to use reference counting or something. They get other benefits of Rust with performance characteristics of a low-latency GC. They still borrow-checker benefits in other people’s code which borrow checks. They can even study it to learn how it’s organized. Things click gradually over time while they still reap some benefits of the language.

                                                                    This might not only be for new folks. Others know know Rust might occasionally do this for non-performance-sensitive code that’s not borrow-checking for some reason. They just skip it because the performance-critical part is an imported library that does borrow-check. They decide to fight with the borrow-checker later if it’s not worth their time within their constraints. Most people say they get used to avoiding problems, though, so I don’t know if this scenario can play out in regular use of the language.

                                                                    1. 6

                                                                      I agree, for 99% of people, the level of strictness in Rust is the wrong default. We need an ownership system where you can get by with a lot less errors for non-performance sensitive code.

                                                                      The approach I am pursuing in my current language is to essentially default to “compile time reference counting”, i.e. it does implement a borrow checker, but where Rust would error out, it inserts a refcount increase. This is able to check pretty much all code which previously used runtime reference counting (but with 10x or so less runtime overhead), so it doesn’t need any lifetime annotations to work.

                                                                      Then, you can optionally annotate types or variables as “unique”, which will then selectively get you something more like Rust, with errors you have to work around. Doing this ensures that a) you don’t need space for a refcount in those objects, and b) you will not get unwanted refcount increase ops in your hot loop.

                                                                      1. 2

                                                                        Ha ha, just by reading this comment I was thinking ‘this guy sounds a bit like Wouter van Oortmerssen’, funny that it turns out to be true :-) Welcome to lobste.rs!

                                                                        Interesting comment, I assume you are exploring this idea in the Lobster programming language? I would love to hear more about it.

                                                                        1. 2

                                                                          Wow, I’m that predictable eh? :P

                                                                          Yup this is in Lobster (how appropriate on this site :)

                                                                          I am actually implementing this as we speak. Finished the analysis phase, now working on the runtime part. The core algorithm is pretty simple, the hard part is getting all the details right (each language feature, and each builtin function, has to correctly declare to its children and its parent wether it is borrowing or owning the values involved, and then keep those promises at runtime). But I’m getting there, should have something to show for in not too long. I should definite do a write-up on the algorithm when I finish.

                                                                          If it all works, the value should be that you can get most of the benefit of Rust while programmers mostly don’t need to understand the details.

                                                                          Meanwhile, happy to answer any more specific questions :)

                                                                    2. 4

                                                                      I don’t understand, and have never understood, the comparisons between Go and Python. Ditto for former Pythonistas who are now Gophers. There is no equivalent of itertools in Go, and there can’t be due to the lack of generics. Are all these ex-Python programmers writing for loops for everything? If so, why???

                                                                      1. 1

                                                                        Not Go but Julia is more likely the Python of 2019.